[MNG-8764] Sort injected lists by @Priority annotation

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 {}
+    }
 }