Guillaume Nodet <******@****.***> 1725988727 +0200

	match     func(*DB) bool
	handler   func(*DB)
	processor *processor
}

func (cs *callbacks) Create() *processor {
	return cs.processors["create"]
}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

func (cs *callbacks) Update() *processor {
	return cs.processors["update"]
}

func (cs *callbacks) Delete() *processor {
	return cs.processors["delete"]
}

            processor = ProcessorHolder.CACHED_PROCESSOR.get();
        }
        return processor.process(object);
    }

    /**
     * Load the first available processor implementation.
     */
    private static ModelObjectProcessor loadProcessor() {
        /*
         * No-op processor that returns objects unchanged.
         */
        class NoOpProcessor implements ModelObjectProcessor {

            this.modularJar = requireType(Type.MODULAR_JAR);
            this.processor = requireType(Type.PROCESSOR);
            this.classpathProcessor = requireType(Type.CLASSPATH_PROCESSOR);
            this.modularProcessor = requireType(Type.MODULAR_PROCESSOR);
            this.needsDerive = Set.of(Type.PROCESSOR, Type.CLASSPATH_PROCESSOR, Type.MODULAR_PROCESSOR);
            this.stack = new ArrayDeque<>();
        }

        def testError2 = Mock(Throwable)

        when:
        processor.started(rootDescriptor, rootTestStartEvent)
        processor.started(testDescriptor1, testStartEvent1)
        processor.started(testDescriptor2, testStartEvent2)
        processor.failure("testId2", testError2)
        processor.completed("rootId", rootCompleteEvent)

        then:

    /**
     * Artifact type name for a JAR file that can be placed either on the annotation processor class path
     * or module path. The path (classes or modules) is chosen by the plugin, possibly using heuristic rules.
     */
    String PROCESSOR = "processor";

    /**
     * Artifact type name for a JAR file to unconditionally place on the annotation processor class path.
     * If the JAR is modular, its module information are ignored.
     */

 */
package org.codelibs.fess.crawler.processor;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.crawler.entity.AccessResult;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.entity.ResultData;
import org.codelibs.fess.crawler.processor.impl.DefaultResponseProcessor;
import org.codelibs.fess.ingest.IngestFactory;

                    java.util.function.BiFunction<org.opensearch.action.update.UpdateRequestBuilder, org.opensearch.search.SearchHit, org.opensearch.action.update.UpdateRequestBuilder> processor) {
                // Return a fixed count for testing
                return 3L;
            }
        };
        ComponentUtil.register(mockSearchEngineClient, "searchEngineClient");

        // Mock FessConfig

import org.opensearch.index.query.QueryBuilder;

import jakarta.annotation.PostConstruct;

/**
 * Query processor component that handles query filters and commands.
 * This class provides a pipeline for processing Lucene queries by applying
 * a chain of filters and executing registered query commands.
 *
 * <p>The processor maintains a map of query commands indexed by query class names

      assertTrue("I received an event when I wasn't ready!", ready);
      eventsReceived.add(event);
    }
  }

  public void testEventOrderingIsPredictable() {
    EventProcessor processor = new EventProcessor();
    bus.register(processor);

    EventRecorder recorder = new EventRecorder();
    bus.register(recorder);

    bus.post(FIRST);

    assertEquals(
        "EventRecorder expected events in order",