* |      |
   * e ---- c ---- f
   * }
   */
  private static final SuccessorsFunction<Character> JAVADOC_GRAPH =
      createUndirectedGraph("ba", "ad", "be", "ac", "ec", "cf");

  /**
   * A diamond shaped directed graph (arrows going down):
   *
   * {@snippet :
   *   a
   *  / \
   * b   c
   *  \ /
   *   d
   * }
   */
  private static final SuccessorsFunction<Character> DIAMOND_GRAPH =

  public static final MediaType MEDIA_TYPE_JSON = MediaType.get("application/json");

  private final OkHttpClient client = new OkHttpClient.Builder()
      .addInterceptor(new GzipRequestInterceptor())
      .build();
  private final Moshi moshi = new Moshi.Builder().build();
  private final JsonAdapter<Map<String, String>> mapJsonAdapter = moshi.adapter(

 *
 * @author Sven Mawson
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class ListenableFutureTester {

  private final ExecutorService exec;
  private final ListenableFuture<?> future;
  private final CountDownLatch latch;

  public ListenableFutureTester(ListenableFuture<?> future) {
    this.exec = newCachedThreadPool();
    this.future = checkNotNull(future);

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapPutTester<K, V> extends AbstractMapTester<K, V> {
  private Entry<K, V> nullKeyEntry;
  private Entry<K, V> nullValueEntry;
  private Entry<K, V> nullKeyValueEntry;
  private Entry<K, V> presentKeyNullValueEntry;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    nullKeyEntry = entry(null, v3());

              .createTestSuite());
    }
    return derivedSuites;
  }

  private static final class ReserializedListGenerator<E> implements TestListGenerator<E> {
    final OneSizeTestContainerGenerator<Collection<E>, E> gen;

    private ReserializedListGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
      this.gen = gen;
    }

    @Override

    assertSame(copy.forward, copy.backward.inverse());
  }

  private static final class BiMapPair<K, V> implements Serializable {
    final BiMap<K, V> forward;
    final BiMap<V, K> backward;

    BiMapPair(BiMap<K, V> original) {
      this.forward = original;
      this.backward = original.inverse();
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  /**

    NavigableMap<K, V> outer = Synchronized.navigableMap(inner, mutex);
    return outer;
  }

  static class TestEntry<K, V> extends ForwardingMapEntry<K, V> implements Serializable {
    private final Entry<K, V> delegate;
    private final Object mutex;

    TestEntry(Entry<K, V> delegate, Object mutex) {
      this.delegate = delegate;
      this.mutex = mutex;
    }

    @Override
    protected Entry<K, V> delegate() {

 * This class tests the functionality of the NTLM URLStreamHandler wrapper.
 */
@ExtendWith(MockitoExtension.class)
class HandlerTest {

    @Mock
    private CIFSContext mockCifsContext;

    private Handler handler;

    private Properties originalSystemProperties;

    @BeforeEach
    void setUp() throws Exception {
        // Backup system properties to restore them after each test

 */
class SMBSigningDigestTest {

    @Mock
    private SMBSigningDigest signingDigest;

    @Mock
    private CommonServerMessageBlock request;

    @Mock
    private CommonServerMessageBlock response;

    @Mock
    private CommonServerMessageBlock message;

    private byte[] testData;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);

  private static Stats buildManyValuesStatsSnapshot() {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(MANY_VALUES);
    Stats stats = accumulator.snapshot();
    accumulator.add(999.999); // should do nothing to the snapshot
    return stats;
  }

  private static Stats buildLongManyValuesStatsSnapshot() {