}
}

func TestLCP(t *testing.T) {
	testCases := []struct {
		prefixes     []string
		commonPrefix string
	}{
		{[]string{"", ""}, ""},
		{[]string{"a", "b"}, ""},
		{[]string{"a", "a"}, "a"},
		{[]string{"a/", "a/"}, "a/"},
		{[]string{"abcd/", ""}, ""},
		{[]string{"abcd/foo/", "abcd/bar/"}, "abcd/"},
		{[]string{"abcd/foo/bar/", "abcd/foo/bar/zoo"}, "abcd/foo/bar/"},
	}

        @ParameterizedTest(name = "for {0}")
        @ValueSource(strings = {"4.0.0", "4.1.0", "4.2.0"})
        @DisplayName("should detect model version")
        void shouldDetectModelVersionFromNamespace(String targetVersion) throws Exception {
            String pomXml = PomBuilder.create()
                    .namespace("http://maven.apache.org/POM/" + targetVersion)
                    .modelVersion(targetVersion)

     *
     * @see ArtifactCoordinatesFactory#create(Session, String, String, String, String, String, String)
     */
    @Nonnull
    ArtifactCoordinates createArtifactCoordinates(
            String groupId, String artifactId, String version, String classifier, String extension, String type);

    /**
     * Shortcut for {@code getService(ArtifactFactory.class).create(...)}.
     *

	clear(m)
	return &m
}

// NewMSSWith returns a new MSS with the given map.
func NewMSSWith(m map[string]string) *MSS {
	m2 := MSS(m)
	return &m2
}

var mssPool = bpool.Pool[map[string]string]{
	New: func() map[string]string {
		return make(map[string]string, 5)
	},
}

// Recycle the underlying map.
func (m *MSS) Recycle() {
	if m != nil && *m != nil {
		mssPool.Put(*m)

	Preload(association string, query func(db PreloadBuilder) error) ChainInterface[T]
	Select(query string, args ...interface{}) CreateInterface[T]
	Omit(columns ...string) CreateInterface[T]
	MapColumns(m map[string]string) ChainInterface[T]
	Distinct(args ...interface{}) ChainInterface[T]
	Group(name string) ChainInterface[T]
	Having(query interface{}, args ...interface{}) ChainInterface[T]

			t.Errorf("%v: expected %v, got %v", c.values, c.key, key)
		}
	}
}

func TestContains(t *testing.T) {
	containsTests := []struct {
		name  string
		elems []string
		elem  string
		out   bool
	}{
		{"exists", []string{"1", "2", "3"}, "1", true},
		{"not exists", []string{"1", "2", "3"}, "4", false},
	}
	for _, test := range containsTests {
		t.Run(test.name, func(t *testing.T) {

			// does not match
			if recursive && !strings.HasPrefix(rule.Prefix(), prefix) && !strings.HasPrefix(prefix, rule.Prefix()) {
				continue
			}
		}
		return true
	}
	return false
}

// FilterTargetArns returns a slice of distinct target arns in the config
func (c Config) FilterTargetArns(obj ObjectOpts) []string {
	var arns []string

	tgtsMap := make(map[string]struct{})
	rules := c.FilterActionableRules(obj)

func FilterObjectLockMetadata(metadata map[string]string, filterRetention, filterLegalHold bool) map[string]string {
	// Copy on write
	dst := metadata
	var copied bool
	delKey := func(key string) {
		key = strings.ToLower(key)
		if _, ok := metadata[key]; !ok {
			return
		}
		if !copied {
			dst = make(map[string]string, len(metadata))
			maps.Copy(dst, metadata)
			copied = true
		}

        }

        @Override
        public String toString() {
            return value.toString();
        }
    }

    /**
     * Represents a string in the version item list, usually a qualifier.
     */
    private static class StringItem implements Item {
        private static final List<String> QUALIFIERS =

type metricDisplay struct {
	Name   string   `json:"name"`
	Help   string   `json:"help"`
	Type   string   `json:"type"`
	Labels []string `json:"labels"`
}

func (md metricDisplay) String() string {
	return fmt.Sprintf("Name: %s\nType: %s\nHelp: %s\nLabels: {%s}\n", md.Name, md.Type, md.Help, strings.Join(md.Labels, ","))
}

func (md metricDisplay) TableRow() string {
	labels := strings.Join(md.Labels, ",")
	if labels == "" {