searchLog.setQueryPageSize(pageSize);
        ComponentUtil.getRequestManager().findUserBean(FessUserBean.class).ifPresent(user -> {
            searchLog.setUser(user.getUserId());
        });

        LaRequestUtil.getOptionalRequest().ifPresent(req -> {
            searchLog.setClientIp(StringUtils.abbreviate(ComponentUtil.getViewHelper().getClientIp(req), 100));

    }
    return result;
  }

  // Helpers + main

  private byte runHashFunction(int reps, HashFunction hashFunction) {
    byte result = 0x01;
    // Trick the JVM to prevent it from using the hash function non-polymorphically
    result ^= Hashing.crc32().hashInt(reps).asBytes()[0];
    result ^= Hashing.adler32().hashInt(reps).asBytes()[0];

   and such litigation shall be governed by laws of that jurisdiction, without
   reference to its conflict-of-law provisions. Nothing in this Section shall
   prevent a party’s ability to bring cross-claims or counter-claims.

9. Miscellaneous

   This License represents the complete agreement concerning the subject matter

                            return authInfo;
                        }
                    }
                }
            }
        }

        // empty one to prevent NPE
        return new AuthenticationInfo();
    }

    public ProxyInfo getProxy(String protocol) {
        MavenSession session = legacySupport.getSession();

val localRepository = layout.buildDirectory.dir("repository")

val publishPluginsToTestRepository by tasks.registering {
    dependsOn("publishPluginMavenPublicationToTestRepository")
    val repoDir = localRepository // Prevent capturing the Gradle script instance for configuration cache compatibility
    // This should be unified with publish-public-libraries if possible
    doLast {

            final String value = processVirtualHost(s -> s, StringUtil.EMPTY);
            LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(FessConfig.VIRTUAL_HOST_VALUE, value));
            return value;
        });
    }

    protected <T> T processVirtualHost(final Function<String, T> func, final T defaultValue) {

    }

    @Internal
    protected
    fun getContributorsFromPullRequests(): Set<GitHubUser> {
        if (!milestone.isPresent) {
            error("Milestone not set: please rerun the task with `--milestone <milestone>`")
        }
        val prs: MutableList<GitHubPullRequest> = mutableListOf()
        for (page in 1..10) {

  }

  public void testIsPresent_no() {
    assertFalse(Optional.absent().isPresent());
  }

  @SuppressWarnings("OptionalOfRedundantMethod") // Unit tests for Optional
  public void testIsPresent_yes() {
    assertTrue(Optional.of("training").isPresent());
  }

  public void testGet_absent() {
    Optional<String> optional = Optional.absent();

 * limitations under the License.
 */

package gradlebuild.binarycompatibility

import japicmp.util.Optional


internal

    public int hashCode() {
      return slowItDown() + hash;
    }

    @Override
    public int compareTo(Element e) {
      int x = slowItDown();
      return x + super.compareTo(e) - x; // silly attempt to prevent opt
    }

    static int slowItDown() {
      int result = 0;
      for (int i = 1; i <= 1000; i++) {
        result += i;
      }
      return result;
    }
  }