}
			case ch&bss != 0:
				sym.Code = 'B'
			}
			sym.Addr += imageBase + uint64(sect.VirtualAddress)
		}
		syms = append(syms, sym)
		addrs = append(addrs, sym.Addr)
	}

	sort.Sort(uint64s(addrs))
	for i := range syms {
		j := sort.Search(len(addrs), func(x int) bool { return addrs[x] > syms[i].Addr })
		if j < len(addrs) {
			syms[i].Size = int64(addrs[j] - syms[i].Addr)
		}
	}

	return syms, nil
}

		}
		if r.StatusProtoPackage != "" {
			e.StatusType = statName
		}
		entries = append(entries, e)
	}

	sort.Slice(entries, func(i, j int) bool {
		return strings.Compare(entries[i].Resource.Identifier, entries[j].Resource.Identifier) < 0
	})

	// Single instance and sort names
	names := sets.New[string]()

	for _, r := range m.Resources {
		if r.ProtoPackage != "" {
			names.Insert(r.ProtoPackage)

        rhs.parameterTypes >> [String, Number]

        expect:
        comparator.compare(lhs, rhs) == -1
        comparator.compare(rhs, lhs) == 1
    }

    def "can sort a list of constructors"() {
        def first = Stub(ClassGenerator.GeneratedConstructor)
        first.parameterTypes >> [String]
        def second = Stub(ClassGenerator.GeneratedConstructor)

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
	"sort"
	"strings"
	"testing"

	"gopkg.in/yaml.v2"
)

func TestCreateConstantString(t *testing.T) {
	s1 := createConstantString([]string{"lab-el1", "label2"})

		s.acc.sort(numas, s.acc.details.CPUsInNUMANodes)
		result = append(result, numas...)
	}
	return result
}

// If sockets are higher in the memory hierarchy than NUMA nodes, then just
// sort the sockets directly, and return them.
func (s *socketsFirst) sortAvailableSockets() []int {
	sockets := s.acc.details.Sockets().UnsortedList()
	s.acc.sort(sockets, s.acc.details.CPUsInSockets)

		}
		if len(txt) == 0 {
			t.Fatalf("no results")
		}
		expected, err := nslookupTXT(server)
		if err != nil {
			t.Skipf("skipping failed nslookup %s test: %s", server, err)
		}
		slices.Sort(expected)
		slices.Sort(txt)
		if !reflect.DeepEqual(expected, txt) {
			t.Errorf("different results %s:\texp:%v\tgot:%v", server, toJson(expected), toJson(txt))
		}
	})
}

func TestLookupLocalPTR(t *testing.T) {

import java.util.Comparator;

/**
 * Sorts GeneratedConstructors based on the number of parameters.
 *
 * When two constructors have the same number of parameters, we settle on a stable sort by looking at the names of the
 * types of the parameters.
 *
 */
public class ConstructorComparator implements Comparator<ClassGenerator.GeneratedConstructor<?>> {
    @Override

        File newFile = new File(args[1])
        PerformanceTestScenarioDefinition oldJson = new ObjectMapper().readValue(oldFile, PerformanceTestScenarioDefinition).sort()
        PerformanceTestScenarioDefinition newJson = new ObjectMapper().readValue(newFile, PerformanceTestScenarioDefinition).sort()
        if (oldJson != newJson) {
            int size = Math.min(oldJson.performanceTests.size(), newJson.performanceTests.size())

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package echo

import (
	"errors"
	"sort"

	"github.com/hashicorp/go-multierror"

	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/framework/components/cluster"
)

var _ Target = Instances{}

	if path == "toolchain" {
		return Compare(maybeToolchainVersion(x), maybeToolchainVersion(y))
	}
	return semver.Compare(x, y)
}

// ModSort is like module.Sort but understands the "go" and "toolchain"
// modules and their version ordering.
func ModSort(list []module.Version) {
	sort.Slice(list, func(i, j int) bool {
		mi := list[i]
		mj := list[j]
		if mi.Path != mj.Path {
			return mi.Path < mj.Path
		}