testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {
            context.close();
            context.close();
            context.close();
        });

        assertTrue(context.isClosed());
    }

        RequestTrace parentTrace = new RequestTrace("parent-context", null, "parent-data");
        RequestTrace childTrace = new RequestTrace("child-context", parentTrace, "child-data");

        assertEquals("parent-context", parentTrace.context());
        assertNull(parentTrace.parent());
        assertEquals("parent-data", parentTrace.data());

        assertEquals("child-context", childTrace.context());

	dm.Unlock(t.Context())
}

func TestSimpleLockUnlockMultipleTimes(t *testing.T) {
	dm := NewDRWMutex(ds, "test")

	dm.Lock(id, source)
	time.Sleep(time.Duration(10+(rand.Float32()*50)) * time.Millisecond)
	dm.Unlock(t.Context())

	dm.Lock(id, source)
	time.Sleep(time.Duration(10+(rand.Float32()*50)) * time.Millisecond)
	dm.Unlock(t.Context())

	dm.Lock(id, source)

	Last(ctx context.Context) (T, error)
	Take(context.Context) (T, error)
	Find(ctx context.Context) ([]T, error)
	FindInBatches(ctx context.Context, batchSize int, fc func(data []T, batch int) error) error
	Row(ctx context.Context) *sql.Row
	Rows(ctx context.Context) (*sql.Rows, error)
}

type JoinBuilder interface {
	Select(...string) JoinBuilder
	Omit(...string) JoinBuilder

        assertFalse(context.hasDefaultCredentials());
    }

    @Test
    void testHasDefaultCredentials_withNull() {
        context = new TestAbstractCIFSContext(null); // Test with null credentials
        assertFalse(context.hasDefaultCredentials());
    }

    @Test
    void testRenewCredentials() {
        assertFalse(context.renewCredentials("someLocation", new Exception("someError")));
    }

    @Test

            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

        try {
            byte[] newHash = calculateHash(context.getCurrentHash(), messageData, context.getHashAlgorithm());
            context.updateHash(newHash);

            log.debug("Updated preauth hash for session {} with {} bytes of data", sessionId, messageData.length);

	health       *diskHealthTracker
	healthCheck  bool

	metricsCache *cachevalue.Cache[DiskMetrics]
	diskCtx      context.Context
	diskCancel   context.CancelFunc
}

func (p *xlStorageDiskIDCheck) getMetrics() DiskMetrics {
	p.metricsCache.InitOnce(5*time.Second,
		cachevalue.Opts{},
		func(ctx context.Context) (DiskMetrics, error) {
			diskMetric := DiskMetrics{
				LastMinute: make(map[string]AccElem, len(p.apiLatencies)),

func (c *lockRESTClient) RUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRUnlock, &args)
}

// Refresh calls Refresh REST API.
func (c *lockRESTClient) Refresh(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRefresh, &args)
}

// Unlock calls write unlock RPC.

        SecDispatcher.ValidationResponse response = secDispatcher.validateConfiguration();
        if (!response.isValid() || context.options().verbose().orElse(false)) {
            dumpResponse(context, "", response);
        }
        return response.isValid();
    }

    protected void dumpResponse(EncryptContext context, String indent, SecDispatcher.ValidationResponse response) {

            // Reuse context map or create new
            entry.context = getContextMap();
            if (context != null) {
                entry.context.putAll(maskContext(context));
            }

            // Add MDC context efficiently
            addMdcContext(entry.context);

            // Process asynchronously or synchronously based on configuration