*   New loss reduction types:
    *   `AUTO`: Indicates that the reduction option will be determined by the
        usage context. For almost all cases this defaults to
        `SUM_OVER_BATCH_SIZE`. When used with `tf.distribute.Strategy`, outside
        of built-in training loops such as `tf.keras` `compile` and `fit`, we
        expect reduction value to be `SUM` or `NONE`. Using `AUTO` in that case

        ChannelInfo healthyChannel = new ChannelInfo("test-channel", mockTransport, localInterface, remoteInterface);
        healthyChannel.setState(ChannelState.ESTABLISHED);

        // Use reflection or package-private method to add channel for testing
        // For now, just test the empty case
        assertEquals(0, channelManager.getHealthyChannels().size());
    }

    @Test

public class SmbResourceLocatorInternalTest {

    @Mock
    SmbResourceLocatorInternal locator;

    @Mock
    SmbResourceLocator other;

    @Mock
    DfsReferralData referral;

    // Reflection-based API checks ensure the interface contract is as expected
    @Test
    @DisplayName("Type hierarchy and method signatures are correct")
    void typeAndSignatures() throws Exception {

   * Returns {@link Method} instances for the remove tests that assume multisets support duplicates
   * so that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getRemoveDuplicateInitializingMethods() {
    return asList(getMethod(MultisetRemoveTester.class, "testRemove_some_occurrences_present"));
  }

   * Returns {@link Method} instances for the remove tests that assume multisets support duplicates
   * so that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getRemoveDuplicateInitializingMethods() {
    return asList(getMethod(MultisetRemoveTester.class, "testRemove_some_occurrences_present"));
  }

import java.util.concurrent.locks.LockSupport;
import org.jspecify.annotations.Nullable;

@GwtCompatible
@ReflectionSupport(value = ReflectionSupport.Level.FULL)
// Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
// getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
// Since this class only needs CAS on one field, we can avoid this bug by extending AtomicReference

* the Tutorial - User guide
* the Advanced User Guide
* the SQLModel docs
* the API docs
* the automatic docs

* Data Science
* Deep Learning
* Machine Learning
* Dependency Injection
* HTTP Basic authentication
* HTTP Digest
* ISO format
* the JSON Schema standard
* the JSON schema
* the schema definition
* Password Flow
* Mobile

* deprecated
* designed
* invalid

   * can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()} until <a
   * href="https://bugs.openjdk.org/browse/JDK-5045147">JDK-5045147</a> is fixed.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getPutAllNullKeyUnsupportedMethod() {
    return getMethod(MapPutAllTester.class, "testPutAll_nullKeyUnsupported");
  }

 * strategies.
 *
 * <ul>
 *   <li>SafeAtomicHelper: uses Atomic FieldsUpdaters to implement synchronization
 *   <li>SynchronizedHelper: uses {@code synchronized} blocks for synchronization
 * </ul>
 *
 * To force selection of our fallback strategies we load {@link AggregateFutureState} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain

  }

  /**
   * Returns a new thread-safe interner which retains a strong reference to each instance it has
   * interned, thus preventing these instances from being garbage-collected. If this retention is
   * acceptable, this implementation may perform better than {@link #newWeakInterner}.
   */
  public static <E> Interner<E> newStrongInterner() {
    return newBuilder().strong().build();
  }

  /**