byte[] ntResponse = type3.getNTResponse();
                if (ntResponse == null) ntResponse = new byte[0];
                return new NtlmPasswordAuthentication(type3.getDomain(),
                        type3.getUser(), challenge, lmResponse, ntResponse);
            }
        } else {
            resp.setHeader("WWW-Authenticate", "NTLM");
        }
        resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

                byte[] ntResponse = type3.getNTResponse();
                if ( ntResponse == null )
                    ntResponse = new byte[0];
                return new NtlmPasswordAuthentication(type3.getDomain(), type3.getUser(), challenge, lmResponse, ntResponse);
            }
        }
        else {
            resp.setHeader("WWW-Authenticate", "NTLM");
        }
        resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

 * - Collection like structures should have deterministic order - either sorted, or meaningful
 * - Should expose either java.util.List or java.util.Map over specialised collection types
 *
 * Implementations can assume that their getters will be called at-most-once.
 *
 * The lifecycle of details and result objects are effectively undetermined.
 * The build scan plugin will retain the objects for a short time after the operation has

  llvm::Regex coeff_index_trait_regex{"AffineOpCoefficient<(-?[0-9]*),"};
  llvm::Regex fixed_uniform_trait_regex{
      "FixedResultUniformScale<([0-9]+).*(true|false)>"};
  emitSourceFileHeader("Generated Ops Quant Spec Getters", os);

  // Retrieve all the definitions derived from Op definition and sort by record
  // name.
  std::vector<Record *> defs = records.getAllDerivedDefinitions("Op");
  llvm::sort(defs, LessRecord());

    Value res = read.getResource();
    Operation* scope = res.getParentBlock()->getParentOp();
    if (!scope->isProperAncestor(replicate)) continue;
    bool has_conflicting_write = false;
    for (OpOperand& use : res.getUses()) {
      Operation* using_op = use.getOwner();
      if (using_op == read) continue;
      if (!replicate->isProperAncestor(using_op)) continue;
      Operation* peer = GetAncestorBelow(using_op, replicate);

        resolver.resolve(LocalUserCredential.class, credential -> {
            final LocalUserCredential userCredential = credential;
            final String username = userCredential.getUser();
            final String password = userCredential.getPassword();
            if (!fessConfig.isAdminUser(username)) {

    }

    @Override
    public String toString() {
        return "{" + getUserId() + "}";
    }

    @Override
    public String getUserId() {
        return nameId;
    }

    public SamlUser getUser() {
        return new SamlUser(nameId, sessionIndex, nameIdFormat, nameidNameQualifier, nameidSPNameQualifier, getDefaultGroupsAsArray(),
                getDefaultRolesAsArray());
    }

// before or above the parallel_execute.
TF::AssignVariableOp GetSingleUseResourceWrite(
    tf_device::ParallelExecuteOp parallel_execute, Value result) {
  if (!result.hasOneUse()) return nullptr;

  OpOperand& use = *result.getUses().begin();
  auto assign_var = dyn_cast<TF::AssignVariableOp>(use.getOwner());
  if (!assign_var) return nullptr;

  if (use.get() != assign_var.getValue()) return nullptr;

import (
	"database/sql"
	"encoding/json"
	"errors"
	"regexp"
	"testing"

	"github.com/jinzhu/now"
	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

func TestSoftDelete(t *testing.T) {
	user := *GetUser("SoftDelete", Config{})
	DB.Save(&user)

	var count int64
	var age uint

	if DB.Model(&User{}).Where("name = ?", user.Name).Count(&count).Error != nil || count != 1 {

  }

  // All results in our set that have a user outside our set.
  llvm::DenseSet<Value> outputs_seen;
  for (Operation* op : ops) {
    for (Value result : op->getResults()) {
      for (auto& use : result.getUses()) {
        if (!all_operations.contains(use.getOwner())) {
          if (!outputs_seen.contains(result)) {
            outputs->push_back(result);
            outputs_seen.insert(result);
          }