/**
     * Converts a long value to hexadecimal characters and writes them to the specified character array.
     *
     * @param val the long value to convert to hexadecimal characters
     * @param dst the destination character array to write the hex digits into
     * @param dstIndex the starting index in the destination array
     * @param size the number of hex digits to write (will be left-padded with zeros)
     */

   * http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp, which contained the
   * following header:
   *
   * MurmurHash3 was written by Austin Appleby, and is placed in the public domain. The author
   * hereby disclaims copyright to this source code.
   */
  static int smear(int hashCode) {

   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link
   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *

     */
    public Smb2RdmaTransform getTransform() {
        return transform;
    }

    /**
     * Encode to byte array for SMB2 READ/WRITE channel info
     *
     * @param dst destination buffer
     * @param dstIndex starting index
     * @return number of bytes written
     */
    public int encode(byte[] dst, int dstIndex) {
        return transform.encode(dst, dstIndex);
    }

    @Override

        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

        // Assert
        assertNotNull(transPeekNamedPipe);
        // FID is written in writeSetupWireFormat, verify it there
    }

    @Test
    @DisplayName("writeSetupWireFormat should write correct bytes")
    void testWriteSetupWireFormat() {
        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_FID);

            try {
                try (Writer writer = new BufferedWriter(new OutputStreamWriter(Files.newOutputStream(tempFile), getCsvEncoding()))) {
                    elevateWordService.exportCsv(writer);
                } catch (final Exception e) {
                    logger.warn("Failed to process a request.", e);

    }

    @Override
    protected int doExecute(EncryptContext context) throws Exception {
        String cleartext = context.reader.readLine("Enter the password to encrypt: ", '*');
        context.terminal.writer().println(secDispatcher.encrypt(cleartext, null));
        return OK;
    }

     *
     * @param s the short value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @return the number of bytes written (2)
     */
    public static int enc_uint16be(final short s, final byte[] dst, int di) {
        dst[di] = (byte) (s >> 8 & 0xFF);
        di++;
        dst[di] = (byte) (s & 0xFF);
        return 2;
    }

        when(mockConfig.getOemEncoding()).thenReturn("windows-1252");
        cmd = new SmbComQueryInformation(mockConfig, "testfile.txt");
    }

    @Test
    @DisplayName("writeBytesWireFormat writes the command byte followed by the null terminated string")
    void testWriteBytesWireFormatHappy() throws UnsupportedEncodingException {
        byte[] buffer = new byte[50];
        int used = cmd.writeBytesWireFormat(buffer, 0);

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.index.writer;

import org.codelibs.fess.suggest.entity.SuggestItem;
import org.codelibs.fess.suggest.settings.SuggestSettings;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.transport.client.Client;

/**