["*.foo.*"]              | "com.foo.bar.BarTest"     | "aaaa"                | true
        ["*.foo.*"]              | "foo.Test"                | "aaaa"                | false
        ["*.foo.*"]              | "fooTest"                 | "aaaa"                | false
        ["*.foo.*"]              | "foo"                     | "aaaa"                | false
    }

	var a [5]string
	var c [5]string

	for i := 0; i < 5; i++ {
		a[i] = "aaaa"
		c[i] = "cccc"
	}

	for j := 0; j < b.N; j++ {
		_ = a == c
	}
}

func BenchmarkEqArrayOfStrings64(b *testing.B) {
	var a [64]string
	var c [64]string

	for i := 0; i < 64; i++ {
		a[i] = "aaaa"
		c[i] = "cccc"
	}

	for j := 0; j < b.N; j++ {
		_ = a == c
	}
}

		answers[i] = r
	}
	return answers
}

// aaaa takes a slice of ip string and returns a slice of AAAA RRs.
func aaaa(host string, ips []netip.Addr) []dns.RR {
	answers := make([]dns.RR, len(ips))
	for i, ip := range ips {
		r := new(dns.AAAA)
		r.Hdr = dns.RR_Header{Name: host, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: defaultTTLInSeconds}
		r.AAAA = ip.AsSlice()
		answers[i] = r
	}
	return answers
}

					A:   net.ParseIP(fmt.Sprintf("10.0.0.%d", c)),
				})
			case dns.TypeAAAA:
				// set a long TTL for AAAA
				msg.Answer = append(msg.Answer, &dns.AAAA{
					Hdr:  dns.RR_Header{Name: domain, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: s.ttl * 10},
					AAAA: net.ParseIP(fmt.Sprintf("fd00::%x", c)),
				})
			// simulate behavior of some public/cloud DNS like Cloudflare or DigitalOcean

func TestMax() {
	s1 := []int{1, 2, 3, -5}
	if got, want := a.SliceMax(s1), 3; got != want {
		panic(fmt.Sprintf("a.Max(%v) = %d, want %d", s1, got, want))
	}

	s2 := []string{"aaa", "a", "aa", "aaaa"}
	if got, want := a.SliceMax(s2), "aaaa"; got != want {
		panic(fmt.Sprintf("a.Max(%v) = %q, want %q", s2, got, want))
	}

	if got, want := a.SliceMax(s2[:0]), ""; got != want {

        try {
            settings.badword().add("aaaa");
            assertTrue(true);
        } catch (IllegalArgumentException e) {
            fail();
        }

        try {
            settings.badword().add("");
            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }

        try {
            settings.badword().add("aaaa bbb");
            fail();

			req.dnsServer += ":53"
		}
	}
	req.hostname = u.Host
	req.query = qp.Get("query")
	if err := checkIn(req.query, "", "A", "AAAA"); err != nil {
		return req, err
	}
	return req, nil
}

func (c *dnsProtocol) makeRequest(ctx context.Context, cfg *Config, requestID int) (string, error) {
	req, err := parseRequest(cfg.Request.Url)

        !trie.find("ccc")
    }

    def "can find prefix match"() {
        def trie = Trie.from("aaa", "bbb")
        expect:
        !trie.find("a")
        !trie.find("aa")
        trie.find("aaaa")
        trie.find("aaab")
    }

		},
		{
			name:      "success: TypeAAAA query returns AAAA records only",
			host:      "dual.localhost.",
			queryAAAA: true,
			expected:  aaaa("dual.localhost.", []netip.Addr{netip.MustParseAddr("2001:db8:0:0:0:ff00:42:8329")}),
		},
		{
			// This is not a NXDOMAIN, but empty response
			name: "success: Error response if only AAAA records exist for typeA",
			host: "ipv6.localhost.",
		},
		{

	mtime         time.Time     // time of resolv.conf modification
	soffset       uint32        // used by serverOffset
	singleRequest bool          // use sequential A and AAAA queries instead of parallel queries
	useTCP        bool          // force usage of TCP for DNS resolutions
	trustAD       bool          // add AD flag to queries
	noReload      bool          // do not check for config file updates