type Result struct {
		Endpoint  string
		ItemState madmin.ItemState
	}

	var wg sync.WaitGroup
	results := make([]Result, len(c.client.Endpoints))
	for i := range c.client.Endpoints {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()

			client := kes.Client{
				Endpoints:  []string{c.client.Endpoints[i]},
				HTTPClient: c.client.HTTPClient,
			}

			var item madmin.ItemState

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

/**
 * Unit tests for the {@link StrategyOrchestrator} class.
 * Tests strategy execution coordination and result aggregation.
 */
@DisplayName("StrategyOrchestrator")
class StrategyOrchestratorTest {

                @Override
                public boolean equals(Object obj) {
                    return obj instanceof AlwaysTrueFilter;
                }

                @Override
                public int hashCode() {
                    return AlwaysTrueFilter.class.hashCode();
                }

                @Override
                public String toString() {
                    return "AlwaysTrueFilter[]";

	} else if len(users2) != len(users) {
		t.Fatalf("Failed to load join users, got: %v, expect: %v", len(users2), len(users))
	}

	sort.Slice(users2, func(i, j int) bool {
		return users2[i].ID > users2[j].ID
	})

	sort.Slice(users, func(i, j int) bool {
		return users[i].ID > users[j].ID
	})

	for idx, user := range users {
		// user
		CheckUser(t, user, users2[idx])
		if users2[idx].Manager == nil {

	rulesCase8 := make(Rules)
	rulesCase8.Add(NewPattern("2010*", ""), TargetID{"1", "webhook"})

	testCases := []struct {
		rules          Rules
		pattern        string
		targetID       TargetID
		expectedResult int
	}{
		{rulesCase1, NewPattern("*", ""), TargetID{"1", "webhook"}, 1},
		{rulesCase2, NewPattern("*", ""), TargetID{"2", "amqp"}, 2},
		{rulesCase3, NewPattern("2010*", ""), TargetID{"1", "webhook"}, 1},

Les paramètres de la fonction seront reconnus comme tel :

* Si le paramètre est aussi déclaré dans le **chemin**, il sera utilisé comme paramètre de chemin.
* Si le paramètre est d'un **type singulier** (comme `int`, `float`, `str`, `bool`, etc.), il sera interprété comme un paramètre de **requête**.
* Si le paramètre est déclaré comme ayant pour type un **modèle Pydantic**, il sera interprété comme faisant partie du **corps** de la requête.

The function parameters will be recognized as follows:

* If the parameter is also declared in the **path**, it will be used as a path parameter.
* If the parameter is of a **singular type** (like `int`, `float`, `str`, `bool`, etc) it will be interpreted as a **query** parameter.
* If the parameter is declared to be of the type of a **Pydantic model**, it will be interpreted as a request **body**.

/// note

	Name  string
	Code  string
	Price int64
	Owner string
	Item  ProductItem
}

type ProductItem struct {
	gorm.Model
	Code               string
	Product4ID         uint
	AfterFindCallTimes int
}

func (pi ProductItem) BeforeCreate(*gorm.DB) error {
	if pi.Code == "invalid" {
		return errors.New("invalid item")
	}
	return nil
}

func (pi *ProductItem) AfterFind(*gorm.DB) error {

        }

        if (!reportSet.getReports().isEmpty()) {
            InputLocation location = reportSet.getLocation("reports");
            Xpp3Dom reports = new Xpp3Dom("reports", location);
            int n = 0;
            for (String report : reportSet.getReports()) {
                addDom(reports, "report", report, (location == null) ? null : location.getLocation(n++));
            }
            dom.addChild(reports);

        if (path != null) {
            sb.append(LS);
            sb.append(indentation);
            sb.append("Path to dependency: ");
            sb.append(LS);
            int num = 1;
            for (Iterator<String> i = path.iterator(); i.hasNext(); num++) {
                sb.append(indentation);
                sb.append('\t');
                sb.append(num);