}

  // Helper to assert common properties of xml escapers.
  static void assertBasicXmlEscaper(
      CharEscaper xmlEscaper, boolean shouldEscapeQuotes, boolean shouldEscapeWhitespaceChars) {
    // Simple examples (smoke tests)
    assertEquals("xxx", xmlEscaper.escape("xxx"));
    assertEquals("test & test & test", xmlEscaper.escape("test & test & test"));
    assertEquals("test &lt;&lt; 1", xmlEscaper.escape("test << 1"));

 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public abstract class TestStringQueueGenerator implements TestQueueGenerator<String> {
  @Override
  public SampleElements<String> samples() {
    return new Strings();
  }

  @Override
  public Queue<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {

 */
package okhttp3.logging.internal

import java.io.EOFException
import okio.Buffer

/**
 * Returns true if the body in question probably contains human readable text. Uses a small
 * sample of code points to detect unicode control characters commonly used in binary file
 * signatures.
 */
fun Buffer.isProbablyUtf8(): Boolean {
  try {
    val prefix = Buffer()
    val byteCount = size.coerceAtMost(64)

import com.google.common.collect.testing.TestContainerGenerator;
import java.util.Map.Entry;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates bimaps, containing sample entries, to be tested.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestBiMapGenerator<K extends @Nullable Object, V extends @Nullable Object>

   * input, even if some are invalid.
   */
  @CanIgnoreReturnValue
  @Override
  Hasher putString(CharSequence charSequence, Charset charset);

  /** A simple convenience for {@code funnel.funnel(object, this)}. */
  @CanIgnoreReturnValue
  <T extends @Nullable Object> Hasher putObject(
      @ParametricNullness T instance, Funnel<? super T> funnel);

  /**

 * UniAddress} are network dependent and therefore not exercised here – they
 * would require complex stubbing of static methods.  Instead the tests
 * concentrate on the instance methods and simple static predicates
 * that are observable without network access.
 */
@ExtendWith(MockitoExtension.class)
class UniAddressTest {

    /* ---------------------------------------------------------------------

 * helper implementations to exercise expected interaction patterns and edge cases.
 */
@ExtendWith(MockitoExtension.class)
public class SmbRenewableCredentialsTest {

    // Simple base class to satisfy the extended CredentialsInternal contract
    static abstract class BaseCreds implements SmbRenewableCredentials {
        @Override
        public CredentialsInternal clone() {

    asByteSource(from).copyTo(to);
  }

  /**
   * Returns a {@code URL} pointing to {@code resourceName} if the resource is found using the
   * {@linkplain Thread#getContextClassLoader() context class loader}. In simple environments, the
   * context class loader will find resources from the class path. In environments where different
   * threads can have different class loaders, for example app servers, the context class loader

        return false;
      }

      EndpointPair<?> other = (EndpointPair<?>) obj;
      if (isOrdered() != other.isOrdered()) {
        return false;
      }

      // Equivalent to the following simple implementation:
      // boolean condition1 = nodeU().equals(other.nodeU()) && nodeV().equals(other.nodeV());
      // boolean condition2 = nodeU().equals(other.nodeV()) && nodeV().equals(other.nodeU());

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.Credentials;

@ExtendWith(MockitoExtension.class)
class CredentialsInternalTest {

    @Mock
    CIFSContext mockContext;

    /**
     * Simple in-test implementation of CredentialsInternal to exercise the API surface.
     * It validates inputs, records calls, and delegates some behavior to collaborators
     * so we can verify interactions.
     */