getMockRequest().addHeader("user-agent", "Dummy");
        assertEquals(UserAgentType.OTHER, userAgentHelper.getUserAgentType());
    }

    public void test_getUserAgentType_nullUserAgent() {
        getMockRequest().addHeader("user-agent", null);
        assertEquals(UserAgentType.OTHER, userAgentHelper.getUserAgentType());
    }

    public void test_getUserAgentType_emptyUserAgent() {

  patent or other intellectual property rights of any other entity.
  Each Contributor disclaims any liability to Recipient for claims
  brought by any other entity based on infringement of intellectual
  property rights or otherwise. As a condition to exercising the
  rights and licenses granted hereunder, each Recipient hereby
  assumes sole responsibility to secure any other intellectual

  public void testPutAllTable() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Table<String, Integer, @NonNull C> other = HashBasedTable.create();
    other.put("foo", 1, cellValue('d'));
    other.put("bar", 2, cellValue('e'));
    other.put("cat", 2, cellValue('f'));
    table.putAll(other);
    assertEquals((Character) 'd', table.get("foo", 1));
    assertEquals((Character) 'b', table.get("bar", 1));

    for details.

    The summary is that it ignores one file in favor of the other.
    util.concurrent, like nearly all our packages, has two .gwt.xml files: one
    for prod and one for tests. However, unlike our other packages, as of this
    writing it has test supersource but no prod supersource.

    GWT happens to use the prod .gwt.xml, so it looks for no supersource for

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {
      return s.equals(((BaseComparable) other).s);
    } else {
      return false;
    }
  }

  @Override
  public int compareTo(BaseComparable o) {
    return s.compareTo(o.s);

    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Table<String, Integer, Character> other = HashBasedTable.create();
    other.put("foo", 1, 'd');
    other.put("bar", 2, 'e');
    other.put("cat", 2, 'f');
    assertThrows(UnsupportedOperationException.class, () -> table.putAll(other));
    assertEquals((Character) 'a', table.get("foo", 1));
    assertEquals((Character) 'b', table.get("bar", 1));

    } //-- int hashCode()

    /**
     * Checks equality based on {@link #getType()} and {@link #getProvides()} values.
     */
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        } else if (other instanceof ToolchainModel that) {
            return java.util.Objects.equals(this.getType(), that.getType())

     * For other types of values, they are registered directly.
     *
     * @param data the RenderData object to register the value in
     * @param key the key to associate with the value
     * @param value the value to register; can be null, Entity, Collection, or any other object
     */

    void overlapsReturnsTrueThenFalse() throws Exception {
        when(locator.overlaps(other)).thenReturn(true, false);

        assertTrue(locator.overlaps(other));
        assertFalse(locator.overlaps(other));

        verify(locator, times(2)).overlaps(other);
        verifyNoMoreInteractions(locator);
    }

    // Error path: overlaps may throw a CIFSException per signature

            return false;
        if (getClass() != obj.getClass())
            return false;
        RequestData other = (RequestData) obj;
        return method == other.method && Objects.equals(url, other.url)
                && Float.floatToIntBits(weight) == Float.floatToIntBits(other.weight);
    }

    /**
     * Returns a string representation of this object.
     * @return A string representation.