We shouldn't use jdk.internal types.
                
                com.beust and org.testng.collections has classes that look like Guava.

                We prefer to import javax.annotation and fully-qualify references to org.jetbrains.annotations.
            -->
            <property name="illegalPkgs" value="jdk.internal,com.beust,org.testng.collections,org.jetbrains.annotations"/>

         </artifact>
      </component>
      <component group="com.beust" name="jcommander" version="1.35">
         <artifact name="jcommander-1.35.jar">
            <pgp value="F60DB6893AB3825459528EADCC54B93C018511A4"/>
         </artifact>
      </component>
      <component group="com.beust" name="jcommander" version="1.72">
         <artifact name="jcommander-1.72.jar">

BQJCk6EBAhsMAAoJEMe/JtC7YXhmy98AnRHs7OqylRv6FAvdrO1lHHwN3gznAKCB
8rz92M8BU9vWD9WXUWwcNBZl6A==
=XgGN
-----END PGP PUBLIC KEY BLOCK-----

pub    A8538F26D55EA9A3
uid    Cedric Beust <cedric@beust.com>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG v1.68

mQENBE5oy/QBCAC13zHI9hc3L9b+d+idNwivCOh8T7ZbHXHRXwyhbmfxLryu56Y5
gpsYKGIaWWBzPJLtiLMx5IuZz7stzu/gBXLezFkqJxa0Y7e50yDMSbqUMQAtzZpy

        def candidate1 = candidate("best", "best", "best")
        def candidate2 = candidate("best", "best", "compatible")
        def candidate3 = candidate("best", "compatible", "compatible")
        def candidate4 = candidate("compatible", "best", "best")
        def candidate5 = candidate("compatible", "compatible", "best")
        def candidate6 = candidate("compatible", "compatible", "compatible")

			expected: v1.PodQOSGuaranteed,
		},
		{
			pod: newPod("best-effort-best-effort", []v1.Container{
				newContainer("best-effort", getResourceList("", ""), getResourceList("", "")),
				newContainer("best-effort", getResourceList("", ""), getResourceList("", "")),
			}),
			expected: v1.PodQOSBestEffort,
		},
		{
			pod: newPod("best-effort", []v1.Container{
				newContainer("best-effort", getResourceList("", ""), getResourceList("", "")),

      } else {
        return position[a] < position[b];  // preserve order
      }
    };

    Operation* best = nullptr;
    for (Operation* op : ready) {
      if (best == nullptr || better(op, best)) {
        best = op;
      }
    }

    if (!best) {
      assert(ready.empty());
      return result;  // happens for unused results for ops in the todo list
    }

	// Quadratic dynamic programming algorithm for line wrapping problem.
	// best[i] tracks the best score possible for words[:i],
	// assuming that for i < len(words) the line breaks after those words.
	// bestleft[i] tracks the previous line break for best[i].
	best := make([]int64, len(words)+1)
	bestleft := make([]int, len(words)+1)
	best[0] = 0
	for i, w := range words {
		if utf8.RuneCountInString(w) >= max {

                    }
                    best = best != null ? best : moduleResolution;
                    break;
                default:
                    throw new IllegalStateException("Unexpected state for resolution: " + metaDataResolveResult.getState());
            }
        }

        return best;
    }

        schema.accept(other, "requested", "best")
        schema.prefer(other, "best")

        def candidate1 = attributes(usage: "best", other: "compatible")
        def candidate2 = attributes(usage: "no match", other: "no match")
        def candidate3 = attributes(usage: "compatible", other: "best")
        def candidate4 = attributes()
        def candidate5 = attributes(usage: "best", other: "best")

        def candidates = [value1, value2] as Set

        when:
        def best = schema.matcher().selectionSchema.disambiguate(attr, flavor('requested'), candidates)

        then:
        best == [value1] as Set

        when:
        best = schema.matcher().selectionSchema.disambiguate(attr, value2, candidates)

        then:
        best == [value1] as Set
    }