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

	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
}

        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"

			// 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 {

	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{}

    // 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

// license that can be found in the LICENSE file.

//go:build ignore

package main

import (
	"expvar"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"sync"
)

// hello world, the web server
var helloRequests = expvar.NewInt("hello-requests")

func HelloServer(w http.ResponseWriter, req *http.Request) {
	helloRequests.Add(1)