static final NonPublicConstantIgnored INSTANCE = new NonPublicConstantIgnored();

    private NonPublicConstantIgnored() {}
  }

  public static class NonStaticFieldIgnored {
    // This should cause infinite recursion. But it shouldn't be used anyway.
    public final NonStaticFieldIgnored instance = new NonStaticFieldIgnored();

    private NonStaticFieldIgnored() {}
  }

   * otherwise, the rounding will choose between the two nearest representable values with {@code
   * mode}.
   *
   * <p>For the case of {@link RoundingMode#HALF_DOWN}, {@code HALF_UP}, and {@code HALF_EVEN},
   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigInteger.valueOf(2).pow(2000), HALF_UP)}

   * fluent iterable. The iterator's {@code hasNext()} method returns {@code true} until this fluent
   * iterable is empty.
   *
   * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an infinite loop. You
   * should use an explicit {@code break} or be certain that you will eventually remove all the
   * elements.
   *
   * <p><b>{@code Stream} equivalent:</b> if the source iterable has only a single element {@code

   * iterable}. The iterator's {@code hasNext()} method returns {@code true} until {@code iterable}
   * is empty.
   *
   * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an infinite loop. You
   * should use an explicit {@code break} or be certain that you will eventually remove all the
   * elements.
   *
   * <p>To cycle over the iterable {@code n} times, use the following: {@code

   * provided null elements.
   */
  public Joiner skipNulls() {
    return new Joiner(this) {
      @Override
      @SuppressWarnings("JoinIterableIterator") // suggests infinite recursion
      public String join(Iterable<?> parts) {
        return join(parts.iterator());
      }

      @Override

    public static final long DEFAULT_DURABLE_TIMEOUT = 120000;  // 2 minutes
    public static final long MAX_DURABLE_TIMEOUT = 300000;      // 5 minutes
    public static final long PERSISTENT_TIMEOUT = 0;            // Infinite for persistent
}
```

## 4. Data Structures

### 4.1 Handle GUID Structure
```java
package jcifs.internal.smb2.persistent;

import java.util.UUID;
import java.nio.ByteBuffer;

    static final NonPublicConstantIgnored INSTANCE = new NonPublicConstantIgnored();

    private NonPublicConstantIgnored() {}
  }

  public static class NonStaticFieldIgnored {
    // This should cause infinite recursion. But it shouldn't be used anyway.
    public final NonStaticFieldIgnored instance = new NonStaticFieldIgnored();

    private NonStaticFieldIgnored() {}
  }

**This release fixes a severe bug where OkHttp incorrectly detected and recovered from unhealthy
connections.** Stale or canceled connections were incorrectly attempted when they shouldn't have
been, leading to rare cases of infinite retries. Please upgrade to this release!

 *  Fix: don't return stale DNS entries in `DnsOverHttps`. We were caching DNS results indefinitely
    rather than the duration specified in the response's cache-control header.

   * iterable}. The iterator's {@code hasNext()} method returns {@code true} until {@code iterable}
   * is empty.
   *
   * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an infinite loop. You
   * should use an explicit {@code break} or be certain that you will eventually remove all the
   * elements.
   */
  public static <T extends @Nullable Object> Iterator<T> cycle(Iterable<T> iterable) {

_2017-01-29_

 *  Fix: Don't crash with a "cache is closed" error when there is an error initializing the cache.
 *  Fix: Calling `disconnect()` on a connecting `HttpUrlConnection` could cause it to retry in an
    infinite loop! This regression was introduced in OkHttp 2.7.0.
 *  Fix: Drop cookies that contain ASCII NULL and other bad characters. Previously such cookies
    would cause OkHttp to crash when they were included in a request.