private int alt;

    /**
     * This is really just for {@link jcifs.netbios.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
     * @param tc the CIFS context
     * @return resolved name, null if not found
     */

                consecutiveFailures.get(), getSuccessRate());
    }

    /**
     * Calculate success rate
     *
     * @return success rate (0.0 to 1.0)
     */
    private double getSuccessRate() {
        long total = totalCalls.get();
        if (total == 0) {
            return 1.0;
        }

          return UnmodifiableEntry.transformEntries(super.iterator());
        }

        @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

  }

  /**
   * Creates a suite whose map has some elements filtered out of view.
   *
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(
      FeatureSpecificTestSuiteBuilder<
              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>

          taskRunner.withLock {
            activeThreads--
            startNextTask()
          }
        }
      }
    }
  }

  /**
   * This blocking queue hooks into a fake clock rather than using regular JVM timing for functions
   * like [poll]. It is only usable within task faker tasks.
   */
  private inner class TaskFakerBlockingQueue<T>(
    val delegate: BlockingQueue<T>,

   *     wait on each method call to the proxy
   * @return a time-limiting proxy
   * @throws IllegalArgumentException if {@code interfaceType} is a regular class, enum, or
   *     annotation type, rather than an interface
   */
  <T> T newProxy(T target, Class<T> interfaceType, long timeoutDuration, TimeUnit timeoutUnit);

  /**
   * Invokes a specified Callable, timing out after the specified time limit. If the target method

   *
   * <p>Among the improvements that this method and {@code LoadingCache.get(K)} both provide are:
   *
   * <ul>
   *   <li>{@linkplain LoadingCache#get(Object) awaiting the result of a pending load} rather than
   *       starting a redundant one
   *   <li>eliminating the error-prone caching boilerplate
   *   <li>tracking load {@linkplain #stats statistics}
   * </ul>
   *

        req.addFlags0(0x10);
        int flags0 = (int) getPrivateField(req, "flags0");
        assertTrue((flags0 & 0x10) != 0, "flag should be set after addFlags0");
        // Calling again should combine rather than overwrite
        req.addFlags0(0x20);
        flags0 = (int) getPrivateField(req, "flags0");
        assertTrue((flags0 & 0x20) != 0, "flag should accumulate");
    }

    @Test

         * are read from the project model during the build. They represent build-time configuration that
         * is specific to the project and is stored with the project definition itself rather than in
         * external configuration.
         */
        MODEL
    }

  - "routeTableCacheTTLInSeconds"
  ([#86266](https://github.com/kubernetes/kubernetes/pull/86266), [@zqingqing1](https://github.com/zqingqing1)) [SIG Cloud Provider]