/**
 * @param <S> the source or sink type
 * @param <T> the data type (byte[] or String)
 * @param <F> the factory type
 * @author Colin Decker
 */
@AndroidIncompatible // TODO(b/230620681): Make this available (even though we won't run it).
@NullUnmarked
public class SourceSinkTester<S, T, F extends SourceSinkFactory<S, T>> extends TestCase {

  static final String LOREM_IPSUM =
      "Lorem ipsum dolor sit amet, consectetur adipiscing "

        assertEquals(Integer.MAX_VALUE, negotiationResponse.getReceiveBufferSize());
        assertEquals(Integer.MAX_VALUE, negotiationResponse.getTransactionBufferSize());

        // Test negative values (though not typical, should be tested)
        when(negotiationResponse.getSendBufferSize()).thenReturn(-1);
        when(negotiationResponse.getReceiveBufferSize()).thenReturn(-1);

 *
 * <pre>
 * new SmbNamedPipe("smb://server/IPC$/foo", SmbNamedPipe.PIPE_TYPE_RDWR, context);
 * </pre>
 *
 * </td>
 * <td>
 * Open the Named Pipe foo for reading and writing. The pipe will
 * behave as though the <code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> interface was
 * being used.
 * </td>
 * </tr>
 * </table>
 *
 * <p>

 *
 * <p><b>Note:</b> {@code ComparisonChain} instances are <b>immutable</b>. For this utility to work
 * correctly, calls must be chained as illustrated above.
 *
 * <p>Performance note: Even though the {@code ComparisonChain} caller always invokes its {@code
 * compare} methods unconditionally, the {@code ComparisonChain} implementation stops calling its

   * abruptly. In other cases, a test may put a thread into an uninterruptible operation
   * intentionally, so there is no other way to clean up these threads. (The better solution,
   * though, would be to run the tests that use TestThread in separate VMs so that their threads
   * don't hang around during other tests.)
   */
  @Override
  public void tearDown() throws Exception {
    try {

        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
        // Compressed size should typically be smaller (though not guaranteed for all data)

        byte[] decompressed = compressionService.decompress(compressed, CompressionService.COMPRESSION_LZ77);
        assertArrayEquals(testData, decompressed);
    }

    @Test

        // Only second directory should be invalidated
        assertFalse(entry2.isComplete());
        // First directory should still be cached (though modified by previous change)
        assertNotNull(directoryLeaseManager.getCacheEntry(dir1));
    }

    @Test
    public void testCacheExpiration() throws Exception {

In Kubernetes 1.19 this feature will be enabled by default with kube-proxy reading from EndpointSlices instead of Endpoints. Although this will mostly be an invisible change, it should result in noticeable scalability improvements in large clusters. It will also enable significant new features in future Kubernetes releases like Topology Aware Routing.

                 * BCAST, Node Status) we need to augment the hashcode generated
                 * for the addresses hostname or failed lookups for one type will
                 * be cached and cause other types to fail even though they may
                 * not be the authority for the name. For example, if a WINS lookup
                 * for FOO fails and caches unknownAddress for FOO, a subsequent

   *     neither fast nor secure. As of January 2017, we suggest:
   *     <ul>
   *       <li>For security:
   *           {@link Hashing#sha256} or a higher-level API.
   *       <li>For speed: {@link Hashing#goodFastHash}, though see its docs for caveats.
   *     </ul>
   */
  @Deprecated
  public static HashFunction md5() {
    return Md5Holder.MD5;
  }

  private static final class Md5Holder {