}

func (ies *IAMEtcdStore) deleteIAMConfig(ctx context.Context, path string) error {
	return deleteKeyEtcd(ctx, ies.client, path)
}

func (ies *IAMEtcdStore) loadPolicyDocWithRetry(ctx context.Context, policy string, m map[string]PolicyDoc, _ int) error {
	return ies.loadPolicyDoc(ctx, policy, m)
}

func (ies *IAMEtcdStore) loadPolicyDoc(ctx context.Context, policy string, m map[string]PolicyDoc) error {

///

## Hash and verify the passwords { #hash-and-verify-the-passwords }

Import the tools we need from `passlib`.

Create a PassLib "context". This is what will be used to hash and verify passwords.

/// tip

The PassLib context also has functionality to use different hashing algorithms, including deprecated old ones only to allow verifying them, etc.

            boolean exclusive);

    /**
     * Gets or creates an SMB transport for the given context.
     *
     * @param tc
     *            context to use
     * @param address the server address
     * @param port the port number
     * @param localAddr the local address to bind to
     * @param localPort the local port to bind to

    private final Path stateDirectory;
    private final ScheduledExecutorService scheduler;
    private final CIFSContext context;
    
    public PersistentHandleManager(CIFSContext context) {
        this.context = context;
        this.handles = new ConcurrentHashMap<>();
        this.guidToHandle = new ConcurrentHashMap<>();
        this.scheduler = Executors.newScheduledThreadPool(1);

						if _, isZero := pkField.ValueOf(db.Statement.Context, rv); isZero {
							db.AddError(pkField.Set(db.Statement.Context, rv, insertID))
							insertID += pkField.AutoIncrementIncrement
						}
					}
				}
			case reflect.Struct:
				_, isZero := pkField.ValueOf(db.Statement.Context, db.Statement.ReflectValue)
				if isZero {
					db.AddError(pkField.Set(db.Statement.Context, db.Statement.ReflectValue, insertID))
				}
			}

	}
}

func (c *check) mustGetIAMUserInfo(ctx context.Context, admClnt *madmin.AdminClient, accessKey string) madmin.UserInfo {
	c.Helper()
	ui, err := admClnt.GetUserInfo(ctx, accessKey)
	if err != nil {
		c.Fatalf("should be able to get user info: %v", err)
	}
	return ui
}

func (c *check) mustNotCreateIAMUser(ctx context.Context, admClnt *madmin.AdminClient) {
	c.Helper()

func benchmarkPutObjectPart(b *testing.B, instanceType string, objSize int) {
	// create a temp Erasure/FS backend.
	ctx, cancel := context.WithCancel(b.Context())
	defer cancel()
	objLayer, disks, err := prepareTestBackend(ctx, instanceType)
	if err != nil {
		b.Fatalf("Failed obtaining Temp Backend: <ERROR> %s", err)
	}

			tc, ok := r.Context().Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt)
			if ok {
				tc.FuncName = "s3.AppendObject"
				tc.ResponseRecorder.LogErrBody = true
			}

			writeErrorResponse(r.Context(), w, getAPIError(ErrNotImplemented), r.URL)
			return
		}

		tc, ok := r.Context().Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt)
		if ok {
			tc.FuncName = "s3.ValidRequest"

        PreauthIntegrityContext context = preauthService.initializeSession(sessionId, salt, PreauthIntegrityService.HASH_ALGO_SHA512);

        assertNotNull(context);
        assertEquals(PreauthIntegrityService.HASH_ALGO_SHA512, context.getHashAlgorithm());
        assertArrayEquals(salt, context.getSalt());
        assertTrue(context.isValid());
        assertNotNull(context.getCurrentHash());
    }

    @Test

            protected FilterChain createDefaultFilterChain() {
                return (context, query, boost) -> {
                    called.set(true);
                    return QueryBuilders.boolQuery();
                };
            }
        };
        queryProcessor.init();

        QueryContext context = new QueryContext(null, false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();