default -> throw new IllegalArgumentException("Unsupported time encoding");
        };
    }

    /*
     * Decode times
     */

    /**
     * Decodes a Date value according to the specified time encoding type.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @param enc the time encoding type (e.g., TIME_1970_SEC_32BE)

	disk StorageAPI    `msg:"-"`
	mu   *sync.RWMutex `msg:"-"`

	ID         string
	PoolIndex  int
	SetIndex   int
	DiskIndex  int
	Path       string
	Endpoint   string
	Started    time.Time
	LastUpdate time.Time

	ObjectsTotalCount uint64
	ObjectsTotalSize  uint64

	ItemsHealed uint64
	ItemsFailed uint64

	BytesDone   uint64
	BytesFailed uint64

	// Last object scanned.

    }

    /**
     * Verify that writeParameterWordsWireFormat writes the file id and the
     * unsigned time correctly.  The last write time is zero which should be
     * encoded as four 0xFF bytes by {@code writeUTime}.
     */
    @ParameterizedTest(name = "fid={0}, lastWriteTime={1}")
    @MethodSource("validParams")

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.security.SecureRandom;
import java.util.Arrays;

            byte[] buffer = new byte[200];

            // When
            copy.encode(buffer, 0);

            // Then
            verify(mockChunk1, times(1)).encode(eq(buffer), eq(HEADER_SIZE));
            verify(mockChunk2, times(1)).encode(eq(buffer), eq(HEADER_SIZE + CHUNK_SIZE));
        }

        @Test
        @DisplayName("Should accumulate encoded bytes from chunks")

  }

  /**
   * Enters this monitor. Blocks at most the given time, and may be interrupted.
   *
   * @return whether the monitor was entered
   * @throws InterruptedException if interrupted while waiting
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public boolean enterInterruptibly(long time, TimeUnit unit) throws InterruptedException {
    return lock.tryLock(time, unit);

query_or_cookie_extractor(["query_or_cookie_extractor"])

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```

## Dieselbe Abhängigkeit mehrmals verwenden { #using-the-same-dependency-multiple-times }

    }

    /**
     * Build a basic CREATE response body without create contexts.
     */
    private static byte[] buildCreateBodyNoContexts(byte oplock, byte openFlags, int createAction, long ctime, long atime, long mtime,
            long chtime, long allocSize, long eof, int attrs, byte[] fileId) {
        byte[] body = new byte[2 + 2 + 4 + 8 + 8 + 8 + 8 + 8 + 8 + 4 + 4 + 16 + 4 + 4];
        int i = 0;

        id("${model.projectId}_FlakyQuarantine_${testCoverage.asId(model)}")
        name = "Flaky Test Quarantine - ${testCoverage.asName()}"
        description = "Run all flaky tests skipped multiple times"

        applyDefaultSettings(os = os, arch = arch, buildJvm = BuildToolBuildJvm, timeout = 60)

        if (os == Os.LINUX) {
            steps {
                script {

import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;