if (logger.isDebugEnabled()) {
                    logger.debug("SSO is available but no user found.");
                }
                saveError(messages -> messages.addErrorsSsoLoginError(GLOBAL));
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Redirecting to login page.");
            }
            return redirect(LoginAction.class);
        }

     * @throws SmbException if validation fails
     */
    public void validateBuffer(byte[] buffer, int expectedSize, int maxSize) throws SmbException {
        totalValidations.incrementAndGet();

        if (buffer == null) {
            failedValidations.incrementAndGet();
            throw new SmbException("Response buffer is null");
        }

        if (buffer.length < expectedSize) {

  if (!status->status.ok()) return nullptr;

  if (input_index >= op_def->input_arg_size() || input_index < 0) {
    status->status = tensorflow::errors::InvalidArgument(
        input_index, " out of range for ", op_name);
    return nullptr;
  }

  const tensorflow::OpDef_ArgDef& input_arg = op_def->input_arg()[input_index];

  if (input_arg.number_attr().empty()) {

                 * resolve externally, to mimic the behavior if the cache didn't exist in the first place. Otherwise,
                 * the cache would obscure a bad POM.
                 */

                File pomFile = parentData.getModel().getPomFile();
                if (pomFile != null) {

        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
            BoolQueryBuilder builder = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),
                    mustNotQuery.getQueryBuilderList(), filterQuery.getQueryBuilderList());
            if (opLambda != null) {
                opLambda.callback(builder);

// checkID will check if the disk ID matches the provided ID.
func (p *xlStorageDiskIDCheck) checkID(wantID string) (err error) {
	if wantID == "" {
		return nil
	}
	id, err := p.storage.GetDiskID()
	if err != nil {
		return err
	}
	if id != wantID {
		return fmt.Errorf("disk ID %s does not match. disk reports %s", wantID, id)
	}
	return nil
}

	if err != nil {
		t.Fatal("Failed to create a queue store ", err)
	}
	for range 10 {
		if _, err := store.Put(testItem); err != nil {
			t.Fatal("Failed to put to queue store ", err)
		}
	}
	// Should return all the item keys in the store.
	keys := store.List()

	if len(keys) != 10 {
		t.Fatalf("List() Expected: 10, got %d", len(keys))
	}

	// re-open
	store, err = setUpQueueStore(queueDir, 10)

                if (sort == 0) {
                    if (compareNames(dirents[i], name, iter.next()) < 0) {
                        break;
                    }
                } else if (sort == 1) {
                    if (compareSizes(dirents[i], name, iter.next()) < 0) {
                        break;
                    }
                } else if (sort == 2) {

	objectAPI := api.ObjectAPI()
	if objectAPI == nil {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL)
		return
	}
	if s3Error := checkRequestAuthType(ctx, r, policy.PutReplicationConfigurationAction, bucket, ""); s3Error != ErrNone {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL)
		return
	}
	// Check if bucket exists.

    repo = g.get_repo(settings.github_repository)
    use_pr = next(
        (pr for pr in repo.get_pulls() if pr.head.sha == settings.commit_sha), None
    )
    if not use_pr:
        logging.error(f"No PR found for hash: {settings.commit_sha}")
        return
    commits = list(use_pr.get_commits())
    current_commit = [c for c in commits if c.sha == settings.commit_sha][0]