func (m *xposmap) clear() {
	for _, l := range m.maps {
		if l != nil {
			l.clear()
		}
	}
	m.lastIndex = -1
	m.lastMap = nil
}

// mapFor returns the line range map for a given file index.
func (m *xposmap) mapFor(index int32) *biasedSparseMap {
	if index == m.lastIndex {
		return m.lastMap
	}
	mf := m.maps[index]
	m.lastIndex = index
	m.lastMap = mf
	return mf
}

import org.gradle.tooling.model.DomainObjectSet
import spock.lang.Specification

class CollectionMapperTest extends Specification {
    final def mapper = new CollectionMapper()

    def "maps collection types"() {
        expect:
        def collection = mapper.createEmptyCollection(sourceType)
        collection.class == collectionType

        where:
        sourceType      | collectionType

        given:
        def comparisonFailure = new CustomComparisonFailure("message", "expected", "actual")
        def mapper = new JUnitComparisonTestFailureMapper()

        when:
        def supports = mapper.supports(comparisonFailure.class)
        then:
        supports

        when:
        def failure = mapper.map(comparisonFailure, null)
        then:
        failure.details.expected == "expected"

	mapper, err := plug.NewBlockVolumeMapper(
		spec,
		&api.Pod{ObjectMeta: metav1.ObjectMeta{UID: testPodUID, Namespace: testns, Name: testPod}},
		volume.VolumeOptions{},
	)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("failed to make a new Mapper: %w", err)
	}
	csiMapper := mapper.(*csiBlockMapper)
	return csiMapper, spec, pv, nil
}

			// cap (deny) action.
			v := rctlblk_get_value(unsafe.Pointer(rblk))
			if capval == 0 || capval > v {
				capval = v
			}
		}

		// Swap the blocks around so that we can fetch the next value
		t := rblk
		rblk = rblkprev
		rblkprev = t
		flag = _RCTL_NEXT
	}

	return capval
}

func getncpu() int32 {
	n := int32(sysconf(__SC_NPROCESSORS_ONLN))
	if n < 1 {
		return 1
	}

    // SUT
    def mapper = new AssertjMultipleAssertionsErrorMapper()

    // Our error being mapped
    def error = new MultipleAssertionsError(
        [
            new MockFailure(1),
            new MockFailure(2),
            new MockFailure(3)
        ]
    )

    // Simple root mapper that just wraps the assertion failure

func (b *Builder) Local() *Builder {
	b.local = true
	return b
}

func (b *Builder) isLocal() bool {
	return b.local
}

// Mapper returns a copy of the current mapper.
func (b *Builder) Mapper() *mapper {
	mapper := *b.mapper
	return &mapper
}

// URL accepts a number of URLs directly.
func (b *Builder) URL(httpAttemptCount int, urls ...*url.URL) *Builder {
	for _, u := range urls {

    // SUT
    def mapper = new OpenTestMultipleFailuresErrorMapper()

    // Our error being mapped
    def error = new MultipleFailuresError(
        "Multiple Failures",
        [
            new MockFailure(1),
            new MockFailure(2),
            new MockFailure(3)
        ]
    )

    // Simple root mapper that just wraps the assertion failure

	if wantsRESTMapperAdmission.mapper == nil {
		t.Errorf("Expected REST mapper to be initialized but found nil")
	}
}

type WantsRESTMapperAdmissionPlugin struct {
	doNothingAdmission
	doNothingPluginInitialization
	mapper meta.RESTMapper
}

func (p *WantsRESTMapperAdmissionPlugin) SetRESTMapper(mapper meta.RESTMapper) {
	p.mapper = mapper
}

type doNothingRESTMapper struct{}

// returning a new slice of the results.
func mapper[F, T any](s []F, f func(F) T) []T {
	r := make([]T, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r
}

func main() {
	got := mapper([]int{1, 2, 3}, strconv.Itoa)
	want := []string{"1", "2", "3"}
	if !reflect.DeepEqual(got, want) {
		panic(fmt.Sprintf("got %s, want %s", got, want))
	}

	fgot := mapper([]float64{2.5, 2.3, 3.5}, func(f float64) string {