ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);
    // Array length is highest character value + 1
    assertEquals('z' + 1, fem.getReplacementArray().length);
  }

  public void testMapping() {
    Map<Character, String> map =
        ImmutableMap.of(
            '\0', "zero",
            'a', "first",
            'b', "second",
            'z', "last",
            '\uFFFF', "biggest");

    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);
    // Array length is highest character value + 1
    assertEquals('z' + 1, fem.getReplacementArray().length);
  }

  public void testMapping() {
    Map<Character, String> map =
        ImmutableMap.of(
            '\0', "zero",
            'a', "first",
            'b', "second",
            'z', "last",
            '\uFFFF', "biggest");

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package http

import (
	"cmp"
	"fmt"
	"slices"
	"strconv"
	"testing"
)

func TestMapping(t *testing.T) {
	var m mapping[int, string]
	for i := 0; i < maxSlice; i++ {
		m.add(i, strconv.Itoa(i))
	}
	if m.m != nil {
		t.Fatal("m.m != nil")
	}
	for i := 0; i < maxSlice; i++ {
		g, _ := m.find(i)

			}
		}
	}

	t.Run("Normal", func(t *testing.T) {
		f(t, profSelfMapsTests)
	})

	t.Run("WithDeletedFile", func(t *testing.T) {
		f(t, profSelfMapsTestsWithDeleted)
	})
}

// TestMapping checks the mapping section of CPU profiles
// has the HasFunctions field set correctly. If all PCs included
// in the samples are successfully symbolized, the corresponding

		fixedRESTMapper{mappings: []*RESTMapping{mapping1}},
		fixedRESTMapper{mappings: []*RESTMapping{mapping2}},
		fixedRESTMapper{mappings: []*RESTMapping{mapping3}},
	}
	tcs := []struct {
		name string

		mapper PriorityRESTMapper
		input  schema.GroupKind
		result *RESTMapping
		err    error
	}{
		{
			name:   "empty",
			mapper: PriorityRESTMapper{Delegate: MultiRESTMapper{}},

		}
	}
}

func TestMultiRESTMapperRESTMappings(t *testing.T) {
	mapping1, mapping2 := &RESTMapping{}, &RESTMapping{}
	tcs := []struct {
		name string

		mapper    MultiRESTMapper
		groupKind schema.GroupKind
		versions  []string
		result    []*RESTMapping
		err       error
	}{
		{
			name:      "empty with no versions",
			mapper:    MultiRESTMapper{},

}

// RESTMapping provides the REST mapping for the resource based on the
// kind and version. This implementation supports multiple REST schemas and
// return the first match.
func (m MultiRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*RESTMapping, error) {
	allMappings := []*RESTMapping{}
	errors := []error{}

	for _, t := range m {

	ResourcesFor(input schema.GroupVersionResource) ([]schema.GroupVersionResource, error)

	// RESTMapping identifies a preferred resource mapping for the provided group kind.
	RESTMapping(gk schema.GroupKind, versions ...string) (*RESTMapping, error)
	// RESTMappings returns all resource mappings for the provided group kind if no

}

// RESTMapping provides the REST mapping for the resource based on the
// kind and version. This implementation supports multiple REST schemas and
// return the first match.
func (m FirstHitRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*RESTMapping, error) {
	errors := []error{}
	for _, t := range m.MultiRESTMapper {
		ret, err := t.RESTMapping(gk, versions...)
		if err == nil {

	}
	return o.mapper.ResourcesFor(input)
}

func (o *lazyObject) RESTMapping(gk schema.GroupKind, versions ...string) (*RESTMapping, error) {
	if err := o.init(); err != nil {
		return nil, err
	}
	return o.mapper.RESTMapping(gk, versions...)
}

func (o *lazyObject) RESTMappings(gk schema.GroupKind, versions ...string) ([]*RESTMapping, error) {
	if err := o.init(); err != nil {
		return nil, err
	}