scheme: default
      primary: teal
      accent: blue
      toggle:
        icon: octicons/sun-24
        name: "Switch to Dark Mode"
    - media: "(prefers-color-scheme: dark)"
      scheme: slate
      primary: teal
      accent: blue
      toggle:
        icon: octicons/moon-24
        name: "Switch to Light Mode"
  features:
  - navigation.tabs

extra_css:
  - 'assets/css/app.css'

        )

    @BeforeEach
    fun setUp() {
        val stepsCapturer = slot<BuildSteps.() -> Unit>()
        every { buildType.steps } returns steps
        every { buildType.stage } returns buildModel.stages[2]
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test

import org.junit.jupiter.api.Test;

/**
 * Unit tests for DirectoryLeaseState
 */
public class DirectoryLeaseStateTest {

    @Test
    public void testDirectoryLeaseConstants() {
        // Test that directory lease states use correct base values
        assertEquals(Smb2LeaseState.SMB2_LEASE_READ_CACHING | Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING,
                DirectoryLeaseState.DIRECTORY_READ_HANDLE);

	}
	info.Used = info.Total - info.Free
	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor
func GetDriveStats(major, minor uint32) (iostats IOStats, err error) {
	return IOStats{}, errors.New("operation unsupported")

            assertEquals(80, result);
            verify(mockSmbPipeHandleInternal).recv(inB, 40, 40);
        }

        @Test
        @DisplayName("Should throw IOException when handle is stale")
        void testDoSendReceiveFragment_StaleHandle() throws Exception {
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();
            when(mockSmbPipeHandleInternal.isStale()).thenReturn(true);

	// Canceling the context will abort the remote call.
	// In that case, the resource may or may not be unlocked.
	Unlock(ctx context.Context, args LockArgs) (bool, error)

	// Refresh the given lock to prevent it from becoming stale
	Refresh(ctx context.Context, args LockArgs) (bool, error)

	// Unlock (read/write) forcefully for given LockArgs. It should return
	// * a boolean to indicate success/failure of the operation

 *   // The resource was cached! Show it.
 * } else {
 *   // The resource was not cached.
 * }
 * ```
 *
 * This technique works even better in situations where a stale response is better than no response.
 * To permit stale cached responses, use the `max-stale` directive with the maximum staleness in
 * seconds:
 *
 * ```java
 * Request request = new Request.Builder()
 *     .cacheControl(new CacheControl.Builder()

func (h *Target) Endpoint() string {
	return "kafka"
}

// String - kafka string
func (h *Target) String() string {
	return "kafka"
}

// Stats returns the target statistics.
func (h *Target) Stats() types.TargetStats {
	h.logChMu.RLock()
	queueLength := len(h.logCh)
	h.logChMu.RUnlock()

	return types.TargetStats{
		TotalMessages:  atomic.LoadInt64(&h.totalMessages),

//
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364937(v=vs.85).aspx
func GetInfo(path string, _ bool) (info Info, err error) {
	// Stat to know if the path exists.
	if _, err = os.Stat(path); err != nil {
		return Info{}, err
	}

	lpFreeBytesAvailable := int64(0)
	lpTotalNumberOfBytes := int64(0)
	lpTotalNumberOfFreeBytes := int64(0)

	// Extract values safely

 * Provides a common structure for handling delays at different stages of the crawling process.
 * It encapsulates the delay logic and exception handling, allowing subclasses to focus on
 * defining the specific delay behavior for each stage.
 *
 * <p>
 * This class defines the contract for delaying the crawling process at various points, such as:
 * </p>
 * <ul>
 *   <li>Before processing a URL ({@link #delayBeforeProcessing()})</li>