static final int INVERSE_COMPUTE_FOR_WORD_OF_ALL_1S = 0xeee3ddcd;

    static int computeForWord(int word) {
      return strideTable[3][word & 0xFF]
          ^ strideTable[2][(word >>> 8) & 0xFF]
          ^ strideTable[1][(word >>> 16) & 0xFF]
          ^ strideTable[0][word >>> 24];
    }

    static int combine(int csum, int crc) {
      csum ^= crc;

            for (int i = 0; i < 100; i++) {
                int bytesRead = response.readBytesWireFormat(buffer, 0);
                // Then
                assertEquals(4, bytesRead, "Failed at iteration " + i);
            }

            // When - perform multiple write operations
            for (int i = 0; i < 100; i++) {
                int bytesWritten = response.writeBytesWireFormat(buffer, 0);

    void testWriteSetupWireFormatWithVariousFids(int fid, byte expectedLow, byte expectedHigh) {
        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);
        byte[] buffer = new byte[10];
        int offset = 0;

        // Act
        int bytesWritten = transPeekNamedPipe.writeSetupWireFormat(buffer, offset);

        // Assert

package utils

import (
	"database/sql/driver"
	"fmt"
	"path/filepath"
	"reflect"
	"runtime"
	"strconv"
	"strings"
	"unicode"
)

var gormSourceDir string

func init() {
	_, file, _, _ := runtime.Caller(0)
	// compatible solution to get gorm source directory with various operating systems
	gormSourceDir = sourceDir(file)
}

func sourceDir(file string) string {
	dir := filepath.Dir(file)

class BasicTrustRootIndex(
  vararg caCerts: X509Certificate,
) : TrustRootIndex {
  private val subjectToCaCerts: Map<X500Principal, Set<X509Certificate>>

  init {
    val map = mutableMapOf<X500Principal, MutableSet<X509Certificate>>()
    for (caCert in caCerts) {
      map.getOrPut(caCert.subjectX500Principal) { mutableSetOf() }.add(caCert)
    }
    this.subjectToCaCerts = map

     */
    protected int destroyProcess(final String sessionId, final JobProcess jobProcess) {
        if (jobProcess != null) {
            final InputStreamThread ist = jobProcess.getInputStreamThread();
            try {
                ist.interrupt();
            } catch (final Exception e) {

        RestAssured.baseURI = getFessUrl();
        settingTestToken();
    }

    @BeforeEach
    protected void init() {
    }

    @AfterEach
    protected void tearDown() {
        final Map<String, Object> searchBody = createSearchBody(SEARCH_ALL_NUM);
        int count = 0;
        List<String> idList = getIdList(searchBody);
        while (idList.size() > 0 && count < NUM) {

        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 255, 65535 })
        @DisplayName("Should throw exception for various invalid structure sizes")
        void testReadBytesWireFormatVariousInvalidSizes(int invalidSize) {
            // Given
            byte[] buffer = new byte[10];
            int bufferIndex = 0;
            SMBUtil.writeInt2(invalidSize, buffer, bufferIndex);

          + aggregateAboveRange(aggr, node.left);
    }
  }

  @Override
  public int size() {
    return Ints.saturatedCast(aggregateForEntries(Aggregate.SIZE));
  }

  @Override
  int distinctElements() {
    return Ints.saturatedCast(aggregateForEntries(Aggregate.DISTINCT));
  }

  static int distinctElements(@Nullable AvlNode<?> node) {
    return (node == null) ? 0 : node.distinctElements;
  }

    } else {
      toIndex = ranges.size();
    }
    int length = toIndex - fromIndex;
    if (length == 0) {
      return ImmutableList.of();
    } else {
      return new ImmutableList<Range<C>>() {
        @Override
        public int size() {
          return length;
        }

        @Override
        public Range<C> get(int index) {
          checkElementIndex(index, length);