for _, m := range test.matches {
		want = append(want, root+FromSlash(m))
	}
	slices.Sort(want)
	return want
}

func (test *globTest) globAbs(root, rootPattern string) error {
	p := FromSlash(rootPattern + `\` + test.pattern)
	have, err := Glob(p)
	if err != nil {
		return err
	}
	slices.Sort(have)
	want := test.buildWant(root + `\`)
	if strings.Join(want, "_") == strings.Join(have, "_") {

	"istio.io/istio/pkg/config"
	"istio.io/istio/pkg/config/constants"
	"istio.io/istio/pkg/config/schema/kind"
	"istio.io/istio/pkg/kube/krt"
	"istio.io/istio/pkg/log"
	"istio.io/istio/pkg/slices"
	"istio.io/istio/pkg/workloadapi"
)

func (a *index) ServicesCollection(
	Services krt.Collection[*v1.Service],
	ServiceEntries krt.Collection[*networkingclient.ServiceEntry],
	Waypoints krt.Collection[Waypoint],

// See the License for the specific language governing permissions and
// limitations under the License.

package krt

import (
	"istio.io/istio/pkg/slices"
)

// BatchedEventFilter allows an event handler to have alternative event suppression mechanics to filter out unnecessary events.

	x[5] = uint8(certificateOctets >> 8)
	x[6] = uint8(certificateOctets)

	y := x[7:]
	for _, slice := range m.certificates {
		y[0] = uint8(len(slice) >> 16)
		y[1] = uint8(len(slice) >> 8)
		y[2] = uint8(len(slice))
		copy(y[3:], slice)
		y = y[3+len(slice):]
	}

	return x, nil
}

func (m *certificateMsg) unmarshal(data []byte) bool {
	if len(data) < 7 {

            line1
            line2
            line3""")

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"
    }

    def "input-ending eoln is ignored"() {
        given:
        def logFile = log("""\
            line1
            line2
            line3
        """)

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"
    }

    def "returns at most n lines"() {

package monitoring

import (
	"context"
	"sync"

	"go.opentelemetry.io/otel/attribute"
	api "go.opentelemetry.io/otel/metric"

	"istio.io/istio/pkg/log"
	"istio.io/istio/pkg/slices"
)

type derivedGauge struct {
	mu    sync.RWMutex
	attrs map[attribute.Set]func() float64

	name string
}

var _ DerivedMetric = &derivedGauge{}

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fs_test

import (
	. "io/fs"
	"os"
	"path"
	"slices"
	"strings"
	"testing"
)

var globTests = []struct {
	fs              FS
	pattern, result string
}{
	{os.DirFS("."), "glob.go", "glob.go"},
	{os.DirFS("."), "gl?b.go", "glob.go"},

}

func TestEqual(t *testing.T) {
	tests := []struct {
		name string
		s1   []int
		s2   []int
		want bool
	}{
		{"Empty Slices", []int{}, []int{}, true},
		{"Equal Slices", []int{1, 2, 3}, []int{1, 2, 3}, true},
		{"Unequal Slices", []int{1, 2, 3}, []int{3, 2, 1}, false},
		{"One Empty Slice", []int{}, []int{1, 2, 3}, false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := Equal(tt.s1, tt.s2)

func (v *Map) addKey(key string) {
	v.keysMu.Lock()
	defer v.keysMu.Unlock()
	// Using insertion sort to place key into the already-sorted v.keys.
	i, found := slices.BinarySearch(v.keys, key)
	if found {
		return
	}
	v.keys = slices.Insert(v.keys, i, key)
}

func (v *Map) Get(key string) Var {
	i, _ := v.m.Load(key)
	av, _ := i.(Var)
	return av
}

func (v *Map) Set(key string, av Var) {

	for ix, test := range runeMergeTests {
		merged, next := mergeRuneSets(&test.left, &test.right, test.leftPC, test.rightPC)
		if !slices.Equal(merged, test.merged) {
			t.Errorf("mergeRuneSet :%d (%v, %v) merged\n have\n%v\nwant\n%v", ix, test.left, test.right, merged, test.merged)
		}
		if !slices.Equal(next, test.next) {
			t.Errorf("mergeRuneSet :%d(%v, %v) next\n have\n%v\nwant\n%v", ix, test.left, test.right, next, test.next)
		}
	}