removed all the optimization parts and implemented only the core WRS logic

Signed-off-by: Jooho Lee <jlee@redhat.com>

Author: Jooho

pkg/epp/scheduling/framework/plugins/picker/picker_test.go

@@ -143,143 +143,80 @@ func TestPickWeightedRandomPicker(t *testing.T) {
 	pod4 := &types.PodMetrics{Pod: &backend.Pod{NamespacedName: k8stypes.NamespacedName{Name: "pod4"}}}
 	pod5 := &types.PodMetrics{Pod: &backend.Pod{NamespacedName: k8stypes.NamespacedName{Name: "pod5"}}}
 
+	// A-Res algorithm uses U^(1/w) transformation which introduces statistical variance
+	// beyond simple proportional sampling. Generous tolerance is required to prevent
+	// flaky tests in CI environments, especially for multi-tier weights.
 	tests := []struct {
 		name                 string
 		input                []*types.ScoredPod
 		maxPods              int                 // maxNumOfEndpoints for this test
 		iterations           int
 		expectedProbabilities map[string]float64 // pod name -> expected probability
 		tolerancePercent     float64             // acceptable deviation percentage
-		expectExactLength    int                 // expected exact length per iteration (0 means skip this check)
 	}{
-		{
-			name: "All pods requested - basic functionality",
-			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 10},
-				{Pod: pod2, Score: 20},
-				{Pod: pod3, Score: 30},
-			},
-			maxPods:           5, // Request more than available
-			iterations:        10,
-			expectExactLength: 3, // All 3 pods returned (maxPods >= totalPods, so use all)
-		},
 		{
 			name: "High weight dominance test",
 			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 10}, // 10/100 = 10%
-				{Pod: pod2, Score: 90}, // 90/100 = 90%
+				{Pod: pod1, Score: 10}, // Lower weight
+				{Pod: pod2, Score: 90}, // Higher weight (should dominate)
 			},
-			maxPods:    1, // special case: maxEndpoint=1, totalPods=2 → topN=2 (uses all)
+			maxPods:    1,
 			iterations: 2000,
 			expectedProbabilities: map[string]float64{
 				"pod1": 0.10,
 				"pod2": 0.90,
 			},
-			tolerancePercent: 20.0, // ±20% (more tolerant for statistical variance)
+			tolerancePercent: 20.0,
 		},
 		{
-			name: "Equal weights test with topN filtering",
+			name: "Equal weights test - A-Res uniform distribution",
 			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 50}, // Equal scores (will be in top 2 after sorting)
-				{Pod: pod2, Score: 50}, // Equal scores (will be in top 2 after sorting)
-				{Pod: pod3, Score: 50}, // Equal scores (will be filtered out)
+				{Pod: pod1, Score: 100}, // Equal weights (higher values for better numerical precision)
+				{Pod: pod2, Score: 100}, // Equal weights should yield uniform distribution
+				{Pod: pod3, Score: 100}, // Equal weights in A-Res
 			},
-			maxPods:    1, // ratio = 1/3 = 0.333 < 0.34, so topN = 1+1 = 2
+			maxPods:    1,
 			iterations: 1500,
 			expectedProbabilities: map[string]float64{
-				"pod1": 0.333, // Each pod has equal chance: 2/3 * 1/2 ≈ 0.333
-				"pod2": 0.333, // Each pod has equal chance: 2/3 * 1/2 ≈ 0.333
-				"pod3": 0.333, // Each pod has equal chance: 2/3 * 1/2 ≈ 0.333
-			},
-			tolerancePercent: 15.0, // ±15%
-		},
-		{
-			name: "Progressive weight test",
-			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 20}, // 20/60 = 33.3%
-				{Pod: pod2, Score: 40}, // 40/60 = 66.7%
-			},
-			maxPods:    1, // special case: maxEndpoint=1, totalPods=2 → topN=2 (uses all)
-			iterations: 1200,
-			expectedProbabilities: map[string]float64{
-				"pod1": 0.333,
-				"pod2": 0.667,
+				"pod1": 0.333, // Equal weights should yield uniform distribution
+				"pod2": 0.333, // A-Res maintains equal probability for equal weights
+				"pod3": 0.333, // Each pod has theoretically equal chance
 			},
-			tolerancePercent: 20.0, // ±20% (more tolerant for statistical variance)
+			tolerancePercent: 20.0,
 		},
 		{
-			name: "Zero weight exclusion test",
+			name: "Zero weight exclusion test - A-Res edge case",
 			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 30}, // 30/30 = 100%
-				{Pod: pod2, Score: 0},  // 0/30 = 0%
+				{Pod: pod1, Score: 30}, // Normal weight, should be selected
+				{Pod: pod2, Score: 0},  // Zero weight, never selected in A-Res
 			},
 			maxPods:    1,
 			iterations: 500,
 			expectedProbabilities: map[string]float64{
-				"pod1": 1.0,
-				"pod2": 0.0,
+				"pod1": 1.0, // Only pod with positive weight
+				"pod2": 0.0, // Zero weight pods are filtered out
 			},
-			tolerancePercent: 5.0, // ±5%
+			tolerancePercent: 5.0, // ±5% tolerance (should be exact for zero weights)
 		},
 		{
-			name: "Top N filtering - only top 2 pods with threshold",
+			name: "Multi-tier weighted test - A-Res complex distribution",
 			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 100}, // Highest probability
-				{Pod: pod2, Score: 90},  // Second highest probability
-				{Pod: pod3, Score: 50},  // Should be filtered out
-				{Pod: pod4, Score: 30},  // Should be filtered out
-				{Pod: pod5, Score: 10},  // Should be filtered out
+				{Pod: pod1, Score: 100}, // Highest weight
+				{Pod: pod2, Score: 90},  // High weight
+				{Pod: pod3, Score: 50},  // Medium weight
+				{Pod: pod4, Score: 30},  // Low weight
+				{Pod: pod5, Score: 20},  // Lowest weight
 			},
-			maxPods:    1, // ratio = 1/5 = 0.2 < 0.34, so topN = 1+1 = 2
-			iterations: 1000,
-			expectedProbabilities: map[string]float64{
-				"pod1": 0.526, // 100/(100+90) ≈ 52.6%
-				"pod2": 0.474, // 90/(100+90) ≈ 47.4%
-				"pod3": 0.0,   // Should never be selected
-				"pod4": 0.0,   // Should never be selected
-				"pod5": 0.0,   // Should never be selected
-			},
-			tolerancePercent: 15.0,
-		},
-		{
-			name: "Boundary test: ratio exactly at threshold (1/3 ≈ 0.33)",
-			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 100}, // Highest probability
-				{Pod: pod2, Score: 90},  // Second highest probability  
-				{Pod: pod3, Score: 50},  // Should be included (ratio < 0.34)
-			},
-			maxPods:    1, // ratio = 1/3 = 0.333 < 0.34, so topN = 1+1 = 2
+			maxPods:    1,
 			iterations: 1000,
 			expectedProbabilities: map[string]float64{
-				"pod1": 0.526, // 100/(100+90) ≈ 52.6%
-				"pod2": 0.474, // 90/(100+90) ≈ 47.4%
-				"pod3": 0.0,   // Should never be selected due to filtering
+				"pod1": 0.345, // Highest weight gets highest probability
+				"pod2": 0.310, // High weight gets high probability
+				"pod3": 0.172, // Medium weight gets medium probability
+				"pod4": 0.103, // Low weight gets low probability
+				"pod5": 0.069, // Lowest weight gets lowest probability
 			},
-			tolerancePercent: 15.0,
-		},
-		{
-			name: "No filtering: ratio above threshold (2/3 ≈ 0.67)",
-			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 100}, // Highest probability
-				{Pod: pod2, Score: 90},  // Second highest probability  
-				{Pod: pod3, Score: 50},  // Should be included (no filtering)
-			},
-			maxPods:           2, // ratio = 2/3 = 0.667 ≥ 0.34, so no topN filtering
-			iterations:        10,
-			expectExactLength: 2, // Should return exactly 2 pods per iteration
-		},
-		{
-			name: "Edge case: maxPods > filtered count, should use all pods",
-			input: []*types.ScoredPod{
-				{Pod: pod1, Score: 100},
-				{Pod: pod2, Score: 90},
-				{Pod: pod3, Score: 50},
-				{Pod: pod4, Score: 30},
-				{Pod: pod5, Score: 10},
-			},
-			maxPods:           5, // maxPods >= totalPods, so use all 5 pods
-			iterations:        10,
-			expectExactLength: 5, // All 5 pods should be returned
+			tolerancePercent: 25.0,
 		},
 	}
 
@@ -288,45 +225,25 @@ func TestPickWeightedRandomPicker(t *testing.T) {
 			picker := NewWeightedRandomPicker(test.maxPods)
 			selectionCounts := make(map[string]int)
 
-			// Initialize counters for simple pod names
+			// Initialize selection counters for each pod
 			for _, pod := range test.input {
 				podName := pod.GetPod().NamespacedName.Name
 				selectionCounts[podName] = 0
 			}
 
-			// Run multiple iterations to gather statistics
-			var totalLength int
+			// Run multiple iterations to gather statistical data
 			for i := 0; i < test.iterations; i++ {
-				// Create fresh copy of input for each iteration
-				inputCopy := make([]*types.ScoredPod, len(test.input))
-				for j, pod := range test.input {
-					inputCopy[j] = &types.ScoredPod{Pod: pod.Pod, Score: pod.Score}
-				}
+				result := picker.Pick(context.Background(), types.NewCycleState(), test.input)
 
-				result := picker.Pick(context.Background(), types.NewCycleState(), inputCopy)
-				totalLength += len(result.TargetPods)
-
-				// Count selections for probability distribution (when selecting 1 pod)
-				if test.maxPods == 1 && len(result.TargetPods) > 0 {
+				// Count selections for probability analysis
+				if len(result.TargetPods) > 0 {
 					selectedPodName := result.TargetPods[0].GetPod().NamespacedName.Name
 					selectionCounts[selectedPodName]++
 				}
 			}
 
-			// Check exact length if specified
-			if test.expectExactLength > 0 {
-				expectedTotalLength := test.expectExactLength * test.iterations
-				if totalLength != expectedTotalLength {
-					t.Errorf("Expected total length %d (avg %.1f), got %d (avg %.1f)", 
-						expectedTotalLength, float64(test.expectExactLength), 
-						totalLength, float64(totalLength)/float64(test.iterations))
-				} else {
-					t.Logf("Exact length test passed: %d pods selected per iteration ✓", test.expectExactLength)
-				}
-			}
-
-			// Verify probability distribution (only for single pod selection tests)
-			if test.expectedProbabilities != nil && test.maxPods == 1 {
+			// Verify probability distribution
+			if test.expectedProbabilities != nil {
 				for podName, expectedProb := range test.expectedProbabilities {
 					actualCount := selectionCounts[podName]
 					actualProb := float64(actualCount) / float64(test.iterations)