ContiguousSet.closedOpen(Integer.MIN_VALUE, Integer.MIN_VALUE),
            ImmutableSortedSet.of(),
            ImmutableSet.of())
        .testEquals();
    // not testing hashCode for these because it takes forever to compute
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.<Integer>all(), integers()));
    assertEquals(

  ImmutableList() {}

  public static <E> Collector<E, ?, ImmutableList<E>> toImmutableList() {
    return CollectCollectors.toImmutableList();
  }

  // Casting to any type is safe because the list will never hold any elements.
  @SuppressWarnings("unchecked")
  public static <E> ImmutableList<E> of() {
    return (ImmutableList<E>) RegularImmutableList.EMPTY;
  }

### Raise an `HTTPException` in your code { #raise-an-httpexception-in-your-code }

`HTTPException` is a normal Python exception with additional data relevant for APIs.

Because it's a Python exception, you don't `return` it, you `raise` it.

        // We can only test that the method can be called without crashing
        // when proper conditions are not met.

        Map<String, Object> docMap = new HashMap<>();

        // This will return false because getFessConfig() will fail
        // We verify the method handles the case gracefully
        try {
            emptyGenerator.isTarget(docMap);
        } catch (IllegalStateException e) {

        }

        @Override
        public Object[] toArray() {
          /*
           * standardToArray returns `@Nullable Object[]` rather than `Object[]` but only because it
           * can be used with collections that may contain null. This collection is a collection of
           * non-null Entry objects (Entry objects that might contain null values but are not

    out.write(0xFF & (v >> 8));
  }

  @Override
  public void writeUTF(String str) throws IOException {
    ((DataOutputStream) out).writeUTF(str);
  }

  // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:
  // it silently ignores any exception thrown by flush(). Instead, just close the delegate stream.
  // It should flush itself if necessary.
  @Override

            /*
             * The NbtAddress object used to query this node will be in the list
             * returned by the Node Status. A new NbtAddress object should not be
             * created for it because the original is potentially being actively
             * referenced by other objects. We must populate the existing object's
             * data explicitly (and carefully).
             */

    private static int alt;
    private static LogStream log = LogStream.getInstance();

    /**
     * This is really just for {@link jcifs.smb1.UniAddress}. It does
     * not throw an {@link java.net.UnknownHostException} because this
     * is queried frequently and exceptions would be rather costly to
     * throw on a regular basis here.
     *
     * @param host the hostname to resolve
     * @return the resolved NbtAddress or null if not found

     * now depends upon d, which has a transitive dependency on c.  Even though
     * we did list an exclusion on c, it was only from within the context of
     * project b.  We will pick up project c in this case because no
     * restrictions were placed on d.  This demonstrates that a, b, c, & d will
     * all be collected.
     *
     * @throws Exception
     */
    @Test

		// will keep performing the callhome. If the leader goes down for some reason,
		// the lock will be released and another node will acquire it and take over
		// because of this loop.
		for {
			if !globalCallhomeConfig.Enabled() {
				return
			}

			if !runCallhome(ctx, objAPI) {
				// callhome was disabled or context was canceled
				return
			}