assertTrue(result.isPresent());

        // Test that we can chain operations
        String processed = result.map(s -> s.toLowerCase()).orElse("default");

        assertEquals("hello world", processed);

        // Test with null value
        String nullValue = null;
        OptionalEntity<String> emptyResult = OptionalUtil.ofNullable(nullValue);

        QueryBuilder builder = queryCommand.convertTermRangeQuery(context, query, 1.0f);
        assertNotNull(builder);
        assertTrue(builder instanceof RangeQueryBuilder);

        // Query was processed successfully
        RangeQueryBuilder rqb = (RangeQueryBuilder) builder;
        assertEquals("title", rqb.fieldName());
    }

        return sval;
    }

    /**
     * Advances to the next token.
     *
     * @return The type of the token.
     */
    public int nextToken() {
        initVal();
        if (processEOF()) {
            return ttype;
        }
        if (processWhitespace()) {
            return ttype;
        }
        if (processWord()) {
            return ttype;
        }

     *
     * @param index the name of the index to scroll through
     * @param callback the function to apply to each search hit, returning true to continue or false to stop
     * @return the number of documents processed
     */
    public static long scroll(final String index, final Function<SearchHit, Boolean> callback) {
        final SearchEngineClient client = ComponentUtil.getSearchEngineClient();

     * Represents an API response for bulk operations, containing a list of processed items.
     */
    public static class ApiBulkResponse extends ApiResponse {
        /**
         * Constructs an empty ApiBulkResponse.
         */
        public ApiBulkResponse() {
            // NOP
        }

        /**
         * The list of items processed in the bulk operation.
         */

 *               operations. May be null for top-level requests.
 * @param data Additional data associated with this request trace, typically containing the actual request
 *             object being processed or any application-specific state information. May be null if no
 *             additional data is needed.
 */
public record RequestTrace(@Nullable String context, @Nullable RequestTrace parent, @Nullable Object data) {

 * 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.crawler.processor;

import org.codelibs.fess.unit.UnitFessTestCase;

public class FessResponseProcessorTest extends UnitFessTestCase {

    @Override
    public void setUp() throws Exception {
        super.setUp();
    }

import jcifs.internal.CommonServerMessageBlockRequest;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Cancel request message.
 *
 * This command is used to cancel a previously sent command
 * that is still being processed by the server.
 *
 * @author mbechler
 */
public class Smb2CancelRequest extends ServerMessageBlock2 implements CommonServerMessageBlockRequest {

    /**
     * Constructs a SMB2 cancel request
     *

 * <p>
 * Model transformers allow plugins and extensions to modify the POM model during the build process.
 * Transformations can be applied at three different stages:
 * <ol>
 *   <li>File model - The raw model as read directly from the file</li>
 *   <li>Raw model - The model after inheritance has been applied</li>
 *   <li>Effective model - The fully processed model with all interpolation and inheritance applied</li>
 * </ol>
 * <p>

          }
        };

    File asciiFile = getTestFile("ascii.txt");
    byte[] result = Files.readBytes(asciiFile, processor);
    assertEquals(Bytes.asList(Files.toByteArray(asciiFile)), Bytes.asList(result));
  }

  public void testReadBytes_returnFalse() throws IOException {
    ByteProcessor<byte[]> processor =
        new ByteProcessor<byte[]>() {
          private final ByteArrayOutputStream out = new ByteArrayOutputStream();