}
	if size == 0 {
		return nil
	}
	if !c.Type.Is(other.Type.Base()) {
		return fmt.Errorf("checksum type does not match got %s and %s", c.Type.String(), other.Type.String())
	}
	// If never set, just add first checksum.
	if len(c.Raw) == 0 {
		c.Raw = other.Raw
		c.Encoded = other.Encoded
		return nil
	}
	if !c.Valid() {
		return fmt.Errorf("invalid base checksum")
	}
	if !other.Valid() {

        override fun source(): BufferedSource = this@asResponseBody
      }

    @JvmStatic
    @Deprecated(
      message = "Moved to extension function. Put the 'content' argument first to fix Java",
      replaceWith =
        ReplaceWith(
          expression = "content.toResponseBody(contentType)",
          imports = ["okhttp3.ResponseBody.Companion.toResponseBody"],
        ),

    entry = cacheEntry1;
    if (entry != null && entry.key == key) {
      return entry.value;
    }
    entry = cacheEntry2;
    if (entry != null && entry.key == key) {
      // Promote second cache entry to first so the access pattern
      // [K1, K2, K1, K3, K1, K4...] still hits the cache half the time.
      addToCache(entry);
      return entry.value;
    }
    return null;
  }

  @Override
  void clearCache() {

        // When
        String firstName = mockAddress.firstCalledName();

        // Then
        assertEquals(expectedFirstName, firstName, "Should return first called name");
        assertNotNull(firstName, "First called name should not be null");
    }

    @Test
    @DisplayName("nextCalledName should return valid name for fallback attempts")
    void testNextCalledNameContract() {

      if (valueReference.isLoading()) {
        valueReference.notifyNewValue(null);
        return first;
      } else {
        return removeEntryFromChain(first, entry);
      }
    }

    @GuardedBy("this")
    @Nullable ReferenceEntry<K, V> removeEntryFromChain(
        ReferenceEntry<K, V> first, ReferenceEntry<K, V> entry) {
      int newCount = count;

    if (!elements.hasNext()) {
      return of();
    }
    E first = elements.next();
    if (!elements.hasNext()) {
      return of(first);
    }

    Set<E> delegate = Sets.newLinkedHashSet();
    delegate.add(checkNotNull(first));
    do {
      delegate.add(checkNotNull(elements.next()));
    } while (elements.hasNext());

            while ((n = in.read(buf)) != -1) {
                out.write(buf, 0, n);
            }
        }
    }

    /**
     * Compares two SMB files by name
     * @param f1 first file to compare
     * @param f1name name of first file
     * @param f2 second file to compare
     * @return comparison result for sorting
     * @throws IOException if an I/O error occurs
     */

   * Number value = optionalInt.or(0.5); // error
   *
   * FluentIterable<? extends Number> numbers = getSomeNumbers();
   * Optional<? extends Number> first = numbers.first();
   * Number value = first.or(0.5); // error
   * }
   *
   * <p>As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code

    *extra_items: DefaultPlaceholder | DefaultType,
) -> DefaultPlaceholder | DefaultType:
    """
    Pass items or `DefaultPlaceholder`s by descending priority.

    The first one to _not_ be a `DefaultPlaceholder` will be returned.

    Otherwise, the first item (a `DefaultPlaceholder`) will be returned.
    """
    items = (first_item,) + extra_items
    for item in items:
        if not isinstance(item, DefaultPlaceholder):

  }

  /**
   * Returns a dispatcher that dispatches events to subscribers immediately as they're posted
   * without using an intermediate queue to change the dispatch order. This is effectively a
   * depth-first dispatch order, vs. breadth-first when using a queue.
   */
  static Dispatcher immediate() {
    return ImmediateDispatcher.INSTANCE;
  }

  /** Dispatches the given {@code event} to the given {@code subscribers}. */