*/
        return uncheckedCastNullableTToT(delegate.get(key));
      }
      updateLastKnownIndex();
      /*
       * If the entry has been removed from the map, we return null, even though that might not be a
       * valid value. That's the best we can do, short of holding a reference to the most recently
       * seen value. And while we *could* do that, we aren't required to: Map.Entry explicitly says

modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a

    }

    /*
     * These methods "should" call checkNotNull. However, I'm wary of accidentally introducing
     * anything that might slow down execution on such a hot path. Given that the methods are only
     * package-private, I feel OK with just not testing them for NPE.
     *

    List<Boolean> reference = Booleans.asList(ARRAY_FALSE);
    assertEquals(Booleans.asList(ARRAY_FALSE), reference);
    // Explicitly call `equals`; `assertEquals` might return fast
    assertThat(reference.equals(reference)).isTrue();
  }

  public void testAsListHashcode() {
    assertThat(Booleans.asList(EMPTY).hashCode()).isEqualTo(1);

              if (entry.getLowerBound().compareTo(subRange.upperBound) >= 0) {
                return endOfData();
              } else if (entry.getUpperBound().compareTo(subRange.lowerBound) > 0) {
                // this might not be true e.g. at the start of the iteration
                return immutableEntry(entry.getKey().intersection(subRange), entry.getValue());
              }
            }
            return endOfData();
          }

_2016-02-06_

 *  Fix: Permit the trusted CA root to be pinned by `CertificatePinner`.


## Version 2.7.2

_2016-01-07_

 *  Fix: Don't eagerly release stream allocations on cache hits. We might still
    need them to handle redirects.


## Version 2.7.1

_2016-01-01_

 *  Fix: Don't do a health check on newly-created connections. This is

### DELETE operation in REST API

        } catch (NullPointerException e) {
            // Acceptable behavior
            assertTrue(true);
        } catch (Exception e) {
            // Other exceptions might be acceptable
            assertTrue(true);
        }
    }

    /**
     * Test destroyObject with PooledObject containing null object
     */

        }

        if (dr != null && domain.equals(dr.getServer()) && root.equals(dr.getShare())) {
            // If we do cache these we never get to the properly cached
            // standalone referral we might have.
            log.warn("Dropping self-referential referral " + dr);
            dr = null;
        }
        return dr;
    }

    /**
     * @param tf
     * @param domain
     * @param root

    }

    /*
     * These methods "should" call checkNotNull. However, I'm wary of accidentally introducing
     * anything that might slow down execution on such a hot path. Given that the methods are only
     * package-private, I feel OK with just not testing them for NPE.
     *