[MNG-8764] Sort injected lists by @priority annotation (#2425)

When injecting List<T> dependencies, the DI container now sorts the
bindings by their @priority annotation value in descending order
(highest priority first) to ensure deterministic ordering.

This change ensures that components with higher priority values
appear first in injected lists, providing predictable behavior
for dependency injection scenarios where order matters.

- Modified InjectorImpl.doGetCompiledBinding() to sort bindings
  by priority before creating supplier lists
- Added comprehensive tests for priority-based list ordering
- Includes tests for mixed priorities and default priority handling

Author: gnodet

impl/maven-di/src/main/java/org/apache/maven/di/impl/InjectorImpl.java

@@ -220,7 +220,13 @@ public <Q> Supplier<Q> doGetCompiledBinding(Dependency<Q> dep) {
         if (key.getRawType() == List.class) {
             Set<Binding<Object>> res2 = getBindings(key.getTypeParameter(0));
             if (res2 != null) {
-                List<Supplier<Object>> list = res2.stream().map(this::compile).collect(Collectors.toList());
+                // Sort bindings by priority (highest first) for deterministic ordering
+                List<Binding<Object>> sortedBindings = new ArrayList<>(res2);
+                Comparator<Binding<Object>> comparing = Comparator.comparing(Binding::getPriority);
+                sortedBindings.sort(comparing.reversed());
+
+                List<Supplier<Object>> list =
+                        sortedBindings.stream().map(this::compile).collect(Collectors.toList());
                 //noinspection unchecked
                 return () -> (Q) list(list, Supplier::get);
             }

impl/maven-di/src/test/java/org/apache/maven/di/impl/InjectorImplTest.java

@@ -202,6 +202,20 @@ void injectListTest() {
         assertNotSame(services.get(0).getClass(), services.get(1).getClass());
     }
 
+    @Test
+    void injectListWithPriorityTest() {
+        Injector injector = Injector.create().bindImplicit(InjectListWithPriority.class);
+        List<InjectListWithPriority.MyService> services =
+                injector.getInstance(new Key<List<InjectListWithPriority.MyService>>() {});
+        assertNotNull(services);
+        assertEquals(3, services.size());
+
+        // Verify services are ordered by priority (highest first)
+        assertInstanceOf(InjectListWithPriority.HighPriorityServiceImpl.class, services.get(0));
+        assertInstanceOf(InjectListWithPriority.MediumPriorityServiceImpl.class, services.get(1));
+        assertInstanceOf(InjectListWithPriority.LowPriorityServiceImpl.class, services.get(2));
+    }
+
     static class InjectList {
 
         interface MyService {}
@@ -213,6 +227,23 @@ static class MyServiceImpl implements MyService {}
         static class AnotherServiceImpl implements MyService {}
     }
 
+    static class InjectListWithPriority {
+
+        interface MyService {}
+
+        @Named
+        @Priority(100)
+        static class HighPriorityServiceImpl implements MyService {}
+
+        @Named
+        @Priority(50)
+        static class MediumPriorityServiceImpl implements MyService {}
+
+        @Named
+        @Priority(10)
+        static class LowPriorityServiceImpl implements MyService {}
+    }
+
     @Test
     void injectMapTest() {
         Injector injector = Injector.create().bindImplicit(InjectMap.class);
@@ -392,6 +423,25 @@ void testCircularPriorityDependency() {
                 .hasMessageContaining("MyService");
     }
 
+    @Test
+    void testListInjectionWithMixedPriorities() {
+        Injector injector = Injector.create().bindImplicit(MixedPriorityTest.class);
+        List<MixedPriorityTest.MyService> services =
+                injector.getInstance(new Key<List<MixedPriorityTest.MyService>>() {});
+        assertNotNull(services);
+        assertEquals(4, services.size());
+
+        // Verify services are ordered by priority (highest first)
+        // Priority 200 (highest)
+        assertInstanceOf(MixedPriorityTest.VeryHighPriorityServiceImpl.class, services.get(0));
+        // Priority 100
+        assertInstanceOf(MixedPriorityTest.HighPriorityServiceImpl.class, services.get(1));
+        // Priority 50
+        assertInstanceOf(MixedPriorityTest.MediumPriorityServiceImpl.class, services.get(2));
+        // No priority annotation (default 0)
+        assertInstanceOf(MixedPriorityTest.DefaultPriorityServiceImpl.class, services.get(3));
+    }
+
     static class CircularPriorityTest {
         interface MyService {}
 
@@ -405,4 +455,24 @@ static class HighPriorityServiceImpl implements MyService {
             MyService defaultService; // This tries to inject the default implementation
         }
     }
+
+    static class MixedPriorityTest {
+
+        interface MyService {}
+
+        @Named
+        @Priority(200)
+        static class VeryHighPriorityServiceImpl implements MyService {}
+
+        @Named
+        @Priority(100)
+        static class HighPriorityServiceImpl implements MyService {}
+
+        @Named
+        @Priority(50)
+        static class MediumPriorityServiceImpl implements MyService {}
+
+        @Named
+        static class DefaultPriorityServiceImpl implements MyService {}
+    }
 }