}

    return true
  }

  override fun hashCode(): Int {
    var result = 17
    if (isTls) {
      result = 31 * result + (cipherSuitesAsString?.contentHashCode() ?: 0)
      result = 31 * result + (tlsVersionsAsString?.contentHashCode() ?: 0)
      result = 31 * result + if (supportsTlsExtensions) 0 else 1
    }
    return result
  }

  override fun toString(): String {

    other is Challenge &&
      other.scheme == scheme &&
      other.authParams == authParams

  override fun hashCode(): Int {
    var result = 29
    result = 31 * result + scheme.hashCode()
    result = 31 * result + authParams.hashCode()
    return result
  }

  override fun toString(): String = "$scheme authParams=$authParams"

   */
  fun newBuilder(): Builder {
    val result = Builder()
    result.scheme = scheme
    result.encodedUsername = encodedUsername
    result.encodedPassword = encodedPassword
    result.host = host
    // If we're set to a default port, unset it in case of a scheme change.
    result.port = if (port != defaultPort(scheme)) port else -1
    result.encodedPathSegments.clear()
    result.encodedPathSegments.addAll(encodedPathSegments)

    }
  }

  @LazyInit private transient @Nullable Set<Cell<R, C, V>> cellSet;

  @Override
  public Set<Cell<R, C, V>> cellSet() {
    Set<Cell<R, C, V>> result = cellSet;
    return (result == null) ? cellSet = createCellSet() : result;
  }

  Set<Cell<R, C, V>> createCellSet() {
    return new CellSet();
  }

  abstract Iterator<Table.Cell<R, C, V>> cellIterator();

     * In this case though, the result contains simply the (parsed) input version, regardless of the
     * repositories and their contents.
     *
     * @param session the session to use
     * @param artifactCoordinates t
     * @return the version range resolution result
     * @throws VersionResolverException if an errors occurs
     */
    @Nonnull

  public static <E extends @Nullable Object> Comparator<? super E> comparator(
      SortedSet<E> sortedSet) {
    Comparator<? super E> result = sortedSet.comparator();
    if (result == null) {
      result = (Comparator<? super E>) Ordering.natural();
    }
    return result;
  }

            // When
            String result = fileFsFullSizeInfo.toString();

            // Then
            assertNotNull(result);
            assertTrue(result.contains("SmbInfoAllocation"));
            assertTrue(result.contains("alloc=0"));
            assertTrue(result.contains("free=0"));
            assertTrue(result.contains("sectPerAlloc=0"));
            assertTrue(result.contains("bytesPerSect=0"));
        }

        } catch (CyclicDependencyException e) {
            result.addCircularDependencyException(e);

            return result;
        } catch (OverConstrainedVersionException e) {
            result.addVersionRangeViolation(e);

            return result;
        }

        ManagedVersionMap versionMap = getManagedVersionsMap(originatingArtifact, managedVersions);

	AssumedRoleID string `xml:"AssumeRoleId"`
	// contains filtered or unexported fields
}

// AssumeRoleResponse contains the result of successful AssumeRole request.
type AssumeRoleResponse struct {
	XMLName xml.Name `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleResponse" json:"-"`

	Result           AssumeRoleResult `xml:"AssumeRoleResult"`
	ResponseMetadata struct {
		RequestID string `xml:"RequestId,omitempty"`

        SearchRequestParams params = createTestSearchRequestParams();
        OptionalThing<FessUserBean> userBean = OptionalThing.empty();

        SearchResult result = testSearcher.search(query, params, userBean);

        assertNotNull(result);
        assertEquals(query, testSearcher.lastQuery);
        assertEquals(params, testSearcher.lastParams);
        assertEquals(userBean, testSearcher.lastUserBean);
    }