out.Resolver = newResolver(common.ConnectionTimeout, "", "")
	}
	return out
}

func newResolver(timeout time.Duration, protocol, dnsServer string) *net.Resolver {
	return &net.Resolver{
		PreferGo: true,
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			d := net.Dialer{
				Timeout: timeout,
			}
			nt := protocol
			if nt == "" {
				nt = network
			}

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"reflect"
	"slices"
	"testing"
	"time"

	"golang.org/x/net/dns/dnsmessage"
)

func TestResolverDialFunc(t *testing.T) {
	r := &Resolver{
		PreferGo: true,
		Dial: newResolverDialFunc(&resolverDialHandler{
			StartDial: func(network, address string) error {
				t.Logf("StartDial(%q, %q) ...", network, address)
				return nil
			},

			var name string
			if def {
				name = "default/"
			} else {
				name = "go/"
			}
			t.Run(name+server, func(t *testing.T) {
				t.Parallel()
				r := DefaultResolver
				if !def {
					r = &Resolver{PreferGo: true}
				}
				fn(t, r, server)
			})
		}
	}
}

func TestNSLookupMX(t *testing.T) {
	testenv.MustHaveExternalNetwork(t)

	testLookup(t, func(t *testing.T, r *Resolver, server string) {

        and:
        sort([prefer30, prefer10, prefer20, require20, require30]) == [require30, require20, prefer30, prefer20, prefer10]

        and:
        sort([prefer30, dynamic1, prefer10]) == [prefer30, prefer10, dynamic1]

        and:
        sort([dynamic1, prefer10, fromLock, dynamic2]) == [fromLock, prefer10, dynamic1, dynamic2]

        and:

		return preferDA
	}
	if !SourceDA.IsValid() {
		return preferDB
	}

	// Rule 2: Prefer matching scope.
	// If Scope(DA) = Scope(Source(DA)) and Scope(DB) <> Scope(Source(DB)),
	// then prefer DA.  Similarly, if Scope(DA) <> Scope(Source(DA)) and
	// Scope(DB) = Scope(Source(DB)), then prefer DB.
	if attrDA.Scope == attrSourceDA.Scope && attrDB.Scope != attrSourceDB.Scope {
		return preferDA
	}

        version.rejectedVersions == ['1.0.1', '1.0.2']
    }

    def "calling 'prefers' resets the list of rejects"() {
        given:
        def version = new DefaultMutableVersionConstraint('1.0')
        version.reject('1.0.1')

        when:
        version.prefer('1.1')

        then:
        version.requiredVersion == '1.0'
        version.preferredVersion == '1.1'

        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module('org:main:1.0')
            }
        }
    }

    def "prefers Gradle metadata if published and marker is present"() {
        given:
        createIvyFile(true)

        buildFile << """
            dependencies {
                api "org:main:1.0"
            }
        """

        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module('org:main:1.0')
            }
        }
    }

    def "prefers Gradle metadata if published and marker is present"() {
        given:
        createPomFile(true)

        buildFile << """
            dependencies {
                api "org:main:1.0"
            }
        """

                    "version": {
                        "prefers": "3.2.2"
                    }
                },
                {
                    "group": "org.springframework",
                    "module": "spring-core",
                    "version": {
                        "prefers": "2.5.6"
                    },
                    "excludes": [
                        {

  1090
  # this lint warns when shellcheck cannot find a sourced file
  # this wouldn't be a bad idea to warn on, but it fails on lots of path
  # dependent sourcing, so just disable enforcing it
  1091
  # this lint prefers command -v to which, they are not the same
  2230
)
# comma separate for passing to shellcheck
join_by() {
  local IFS="$1";
  shift;
  echo "$*";
}
SHELLCHECK_DISABLED="$(join_by , "${disabled[@]}")"