Helpers.testComparator(comparator, ordered);
  }

  public void testSort() {
    testSort(new long[] {}, new long[] {});
    testSort(new long[] {2}, new long[] {2});
    testSort(new long[] {2, 1, 0}, new long[] {0, 1, 2});
    testSort(new long[] {2, GREATEST, 1, LEAST}, new long[] {LEAST, 1, 2, GREATEST});
  }

  static void testSort(long[] input, long[] expected) {
    input = Arrays.copyOf(input, input.length);

      }
    }
  }

  public void testSort() {
    testSort(new byte[] {}, new byte[] {});
    testSort(new byte[] {2}, new byte[] {2});
    testSort(new byte[] {2, 1, 0}, new byte[] {0, 1, 2});
    testSort(new byte[] {2, GREATEST, 1, LEAST}, new byte[] {LEAST, 1, 2, GREATEST});
  }

  static void testSort(byte[] input, byte[] expected) {
    input = Arrays.copyOf(input, input.length);

		}
		t.Fatalf("%v", errList)
	}
	estCost, err := env.EstimateCost(compiled, est)
	if err != nil {
		t.Fatalf("%v", err)
	}
	if estCost.Min != expectEsimatedCost.Min || estCost.Max != expectEsimatedCost.Max {
		t.Errorf("Expected estimated cost of %d..%d but got %d..%d", expectEsimatedCost.Min, expectEsimatedCost.Max, estCost.Min, estCost.Max)
	}
	prog, err := env.Program(compiled, cel.CostTracking(est))

package test

import (
	"internal/testenv"
	"os"
	"path/filepath"
	"regexp"
	"testing"
)

// TestInst tests that only one instantiation of Sort is created, even though generic
// Sort is used for multiple pointer types across two packages.
func TestInst(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveGoRun(t)

	// Build ptrsort.go, which uses package mysort.
	var output []byte

				}
				typ := inst.Inst.Type

				testInst := test.instances[ii]
				if got := inst.Name.Value; got != testInst.name {
					t.Fatalf("got name %s, want %s", got, testInst.name)
				}

				if len(targs) != len(testInst.targs) {
					t.Fatalf("got %d type arguments; want %d", len(targs), len(testInst.targs))
				}
				for i, targ := range targs {

/**
 * Returns a fixed set of test classes from testlist.txt, skipping any not found in the
 * current classpath.  The IDE runs with less classes to avoid conflicting module ownership.
 */
fun testSelectors(inputFile: File? = null): List<DiscoverySelector> {
  val sampleTestClass = SampleTest::class.java

  val lines =
    inputFile?.readLines() ?: sampleTestClass.getResource("/testlist.txt").readText().lines()

  val flatClassnameList =

	test.TestGet(validNewVolumeAttributesClass("foo"))
}

func TestList(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestList(validNewVolumeAttributesClass("foo"))
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)

package org.gradle.shared;

import junit.framework.TestCase;

import java.io.IOException;
import java.util.Properties;

public class PersonTest extends TestCase {
    public void testTest() {
        assertTrue(true);
    }

package org.gradle.shared;

import junit.framework.TestCase;

import java.io.IOException;
import java.util.Properties;

public class PersonTest extends TestCase {
    public void testTest() {
        assertTrue(true);
    }

				typ := inst.Inst.Type

				testInst := test.instances[ii]
				if got := inst.Ident.Name; got != testInst.name {
					t.Fatalf("got name %s, want %s", got, testInst.name)
				}
				if len(targs) != len(testInst.targs) {
					t.Fatalf("got %d type arguments; want %d", len(targs), len(testInst.targs))
				}
				for i, targ := range targs {
					if got := targ.String(); got != testInst.targs[i] {