"reflect"
	"testing"
)

var testNetrc = `
machine incomplete
password none

machine api.github.com
  login user
  password pwd

machine incomlete.host
  login justlogin

machine test.host
login user2
password pwd2

machine oneline login user3 password pwd3

machine ignore.host macdef ignore
  login nobody
  password nothing

        when:
        repository.asMappingAction().execute(mapping)

        then:
        _ * mapping.requested >> selector
        1 * mapping.from(spec)
        0 * mapping._

        when:
        repository.asMappingAction().execute(mapping)

        then:
        _ * mapping.requested >> other
        0 * mapping._
    }

// Machine is found in Header.Machine.
type Machine uint16

const (
	EM_NONE          Machine = 0   /* Unknown machine. */
	EM_M32           Machine = 1   /* AT&T WE32100. */
	EM_SPARC         Machine = 2   /* Sun SPARC. */
	EM_386           Machine = 3   /* Intel i386. */
	EM_68K           Machine = 4   /* Motorola 68000. */
	EM_88K           Machine = 5   /* Motorola 88000. */

            variantResolver.delegate == componentResolver
        }
    }

    def "returns project-only resolver when dependency mapping and version mapping are disabled"() {
        given:
        def variant = resolutionBacked(false, null)
        def versionMappingStrategy = versionMappingStrategy(false)

        expect:

	return &Selector{
		Client:        client,
		Mapping:       mapping,
		Namespace:     namespace,
		LabelSelector: labelSelector,
		FieldSelector: fieldSelector,
		LimitChunks:   limitChunks,
	}
}

// Visit implements Visitor and uses request chunking by default.
func (r *Selector) Visit(fn VisitorFunc) error {
	helper := NewHelper(r.Client, r.Mapping)
	initialOpts := metav1.ListOptions{
		LabelSelector: r.LabelSelector,

    <dispatcher>INCLUDE</dispatcher>
  </filter-mapping>

  <filter-mapping>
    <filter-name>corsFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>

  <filter-mapping>
    <filter-name>webApiFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>

  <filter-mapping>

			continue
		}
		// Swap what we guess is main to position 0.
		p.Mapping[0], p.Mapping[i] = p.Mapping[i], p.Mapping[0]
		break
	}

	// Keep the mapping IDs neatly sorted
	for i, m := range p.Mapping {
		m.ID = uint64(i + 1)
	}
}

// adjacent returns whether two mapping entries represent the same
// mapping that has been split into two. Check that their addresses are adjacent,

     *
     * @param mapping map containing the light elements ([KtLightElement]) for each callable declaration in this class.
     */
    public fun KtClassOrObject.calculateMetadata(mapping: Multimap<KtElement, PsiElement>): Metadata =
        withValidityAssertion { analysisSession.metadataCalculator.calculateMetadata(this, mapping) }

    /**

		if err != nil {
			return nil, err
		}
		mapping, err := restMapper.RESTMapping(gvk.GroupKind(), gvk.Version)
		if err != nil {
			return nil, fmt.Errorf("unable to recognize %v", err)
		}
		ret.Mapping = mapping

		client, err := m.clientFn(gvk.GroupVersion())
		if err != nil {
			return nil, fmt.Errorf("unable to connect to a server to handle %q: %v", mapping.Resource, err)
		}
		ret.Client = client
	}

        getVersion() >> "version"
    }
    def mapping = new DefaultCacheScopeMapping(userHomeCaches, gradleVersion)

    def "null base dir maps to user home directory"() {
        expect:
        mapping.getBaseDirectory(null, "key", VersionStrategy.CachePerVersion) == userHomeCaches.file("version/key")
        mapping.getBaseDirectory(null, "key", VersionStrategy.SharedCache) == userHomeCaches.file("key")
    }