* escaping with {@link com.google.common.html.HtmlEscapers} or {@link
 * com.google.common.xml.XmlEscapers}.
 *
 * @author David Beaumont
 * @author Chris Povirk
 * @since 15.0
 */
@GwtCompatible
public final class UrlEscapers {
  private UrlEscapers() {}

  // For each xxxEscaper() method, please add links to external reference pages

  private static final char MAX_ASCII_CONTROL_CHAR = 0x1F;

  // For each xxxEscaper() method, please add links to external reference pages
  // that are considered authoritative for the behavior of that escaper.

  /**
   * Returns an {@link Escaper} instance that escapes special characters in a string so it can
   * safely be included in an XML document as element content. See section <a

   *
   * <ul>
   *   <li>{@code null} initial state, nothing has happened.
   *   <li>{@link Cancellation} terminal state, {@code cancel} was called.
   *   <li>{@link Failure} terminal state, {@code setException} was called.
   *   <li>{@link DelegatingToFuture} intermediate state, {@code setFuture} was called.
   *   <li>{@link #NULL} terminal state, {@code set(null)} was called.

/**
 * Utility class for {@link DecimalFormatSymbols}.
 *
 * @author higa
 */
public abstract class DecimalFormatSymbolsUtil {

    private static final Map<Locale, DecimalFormatSymbols> CACHE = newConcurrentHashMap();

    /**
     * Do not instantiate.
     */
    protected DecimalFormatSymbolsUtil() {
    }

    /**
     * Returns {@link DecimalFormatSymbols}.
     *

        }

        @Test
        @DisplayName("Should set link")
        void testSetLink() {
            String link = "\\\\server\\share\\link";

            // Test with mock
            doNothing().when(mockReferralData).setLink(link);
            mockReferralData.setLink(link);
            verify(mockReferralData, times(1)).setLink(link);

            // Test with concrete implementation

    protected boolean hasNext = true;

    /**
     * Returns an {@link Iterable} that wraps a {@link SingleValueIterator} for use in a for-each statement.
     *
     * @param <E> the element type
     * @param value the single value returned by the iterator
     * @return an {@link Iterable} wrapping a {@link SingleValueIterator}
     */
    public static <E> Iterable<E> iterable(final E value) {

/**
 * Utility class for {@link JarURLConnection}.
 *
 * @author higa
 */
public abstract class JarURLConnectionUtil {

    /**
     * Do not instantiate.
     */
    protected JarURLConnectionUtil() {
    }

    /**
     * A method that wraps the exception handling of {@link JarURLConnection#getJarFile()}.
     *
     * @param conn
     *            {@link JarURLConnection}. Must not be {@literal null}.

/**
 * Utility class for conversions related to {@link Float}.
 *
 * @author higa
 */
public abstract class FloatConversionUtil {

    /**
     * Do not instantiate.
     */
    protected FloatConversionUtil() {
    }

    /**
     * Converts to {@link Float}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@link Float}
     */

        }

        @ParameterizedTest
        @NullAndEmptySource
        @DisplayName("Should handle null and empty links")
        void testNullAndEmptyLinks(String link) {
            referralData.setLink(link);
            assertEquals(link, referralData.getLink());
        }

        @ParameterizedTest
        @NullAndEmptySource
        @DisplayName("Should handle null and empty keys")

 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link
 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>
 * possible sequences of these operations, up to a given number of steps. So, if the caller