*/
  private fun assertWildcardRule(rule: String) {
    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added with a wildcard that is not in leftmost position! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
    check(rule.indexOf(WILDCARD_CHAR, 1) == -1) {
      """Wildcard Assertion Failure: '$rule'

        assertEquals("METADATA", SsoResponseType.METADATA.name());
        assertEquals("LOGOUT", SsoResponseType.LOGOUT.name());
    }

    public void test_ordinal() {
        // Test ordinal() method returns correct position
        assertEquals(0, SsoResponseType.METADATA.ordinal());
        assertEquals(1, SsoResponseType.LOGOUT.ordinal());
    }

    public void test_toString() {

        super();
    }

    /** The search query string. */
    @Size(max = 1000)
    public String q;

    /** The sort field and direction. */
    public String sort;

    /** The start position for search results. */
    @ValidateTypeFailure
    public Integer start;

    /** The offset for pagination. */
    @ValidateTypeFailure
    public Integer offset;

    /** The page number. */

 * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12
 *
 * This implementation uses an array for the dynamic table and a list for indexed entries. Dynamic
 * entries are added to the array, starting in the last position moving forward. When the array
 * fills, it is doubled.
 */
@Suppress("NAME_SHADOWING")
object Hpack {
  private const val PREFIX_4_BITS = 0x0f
  private const val PREFIX_5_BITS = 0x1f

      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }

  static <T extends @Nullable Object> T get(Iterator<T> iterator, int position) {
    for (int i = 0; i < position; i++) {
      iterator.next();
    }
    return iterator.next();
  }

  private static final class EntryComparator<K extends @Nullable Object, V extends @Nullable Object>

     * which pages you deem most important for the crawlers.
     *
     * The default priority of a page is 0.5.
     *
     * Please note that the priority you assign to a page is not likely to
     * influence the position of your URLs in a search engine's result pages.
     * Search engines may use this information when selecting between URLs on
     * the same site, so you can use this tag to increase the likelihood that

            Arrays.fill(buffer, (byte) 0);

            int startIndex = 100;
            request.writeBytesWireFormat(buffer, startIndex);

            // Verify data is at correct position
            for (int i = 0; i < data.length; i++) {
                assertEquals((byte) 0xAB, buffer[startIndex + 48 + i]);
            }
        }

        @Test

        - name: start
          in: query
          description: Start position
          required: false
          schema:
            type: integer
            minimum: 0
            exclusiveMinimum: false
            default: 0
            example: 0
        - name: offset
          in: query
          description: Offset from a start position
          required: false
          schema:
            type: integer

 *
 * <p><b>Warning:</b> As in all {@link SetMultimap}s, do not modify either a key <i>or a value</i>
 * of a {@code SortedSetMultimap} in a way that affects its {@link Object#equals} behavior (or its
 * position in the order of the values). Undefined behavior and bugs will result.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/NewCollectionTypesExplained#multimap">{@code Multimap}</a>.
 *

     */
    public String[] lang;

    /**
     * Array of additional query strings to exclude from search.
     */
    public String[] ex_q;

    /**
     * The starting position for search results pagination.
     */
    @ValidateTypeFailure
    public Integer start;

    /**
     * The offset for search results.
     */
    @ValidateTypeFailure
    public Integer offset;