die("raise");
	}

	if (verbose) {
		printf("waiting for sigioSeen\n");
	}

	// Wait until the signal has been delivered.
	i = 0;
	while (!sigioSeen) {
		ts.tv_sec = 0;
		ts.tv_nsec = 1000000;
		nanosleep(&ts, NULL);
		i++;
		if (i > 5000) {
			fprintf(stderr, "looping too long waiting for signal\n");
			exit(EXIT_FAILURE);
		}
	}

	sigioSeen = 0;

// This test makes sure that t.s = t.s[0:x] doesn't write
// either the slice pointer or the capacity.
// See issue #14855.

package main

import "testing"

const N = 1000000

type X struct {
	s []int
}

func TestSlice(t *testing.T) {
	done := make(chan struct{})
	a := make([]int, N+10)

	x := &X{a}

	go func() {
		for i := 0; i < N; i++ {
			x.s = x.s[1:9]

        assertEquals("1,000,000", FessFunctions.formatNumber(1000000, "###,###"));
    }

    public void test_formatFileSize() {
        assertEquals("0", FessFunctions.formatFileSize(0));
        assertEquals("1000", FessFunctions.formatFileSize(1000));
        assertEquals("976.6K", FessFunctions.formatFileSize(1000000));
        assertEquals("953.7M", FessFunctions.formatFileSize(1000000000));

	template := x509.Certificate{
		SerialNumber: big.NewInt(1),
		Subject: pkix.Name{
			CommonName:   "test",
			Organization: []string{"Σ Acme Co"},
		},
		NotBefore: time.Unix(1000, 0),
		NotAfter:  time.Unix(100000, 0),
		KeyUsage:  x509.KeyUsageCertSign,
	}

	if _, err = x509.CreateCertificate(rand.Reader, &template, &template, &rsaPriv.PublicKey, rsaPriv); err != nil {

logging:
  flushFrequency: 5s
  format: text
  options:
    json:
      infoBufferSize: "0"
    text:
      infoBufferSize: "0"
  verbosity: 0
makeIPTablesUtilChains: true
maxOpenFiles: 1000000
maxPods: 110
memoryManagerPolicy: None
memorySwap: {}
memoryThrottlingFactor: 0.9
nodeLeaseDurationSeconds: 40
nodeStatusMaxImages: 50
nodeStatusReportFrequency: 5m0s
nodeStatusUpdateFrequency: 10s

// Test communication operations including select.

package main

import "os"
import "runtime"
import "sync"

var randx int

func nrand(n int) int {
	randx += 10007
	if randx >= 1000000 {
		randx -= 1000000
	}
	return randx % n
}

type Chan struct {
	sc, rc chan int // send and recv chan
	sv, rv int      // send and recv seq
}

var (
	nproc      int
	nprocLock  sync.Mutex

  %result_1 = tfrt_fallback_async.batch_function device("/device:CPU:0") @matmul_cpu (%a1, %b) {
      num_batch_threads = 1,
      max_batch_size = 4,
      allowed_batch_sizes = [4],
      batch_timeout_micros = 1000000,
      container = "container",
      shared_name = "shared_name",
      batching_queue = "batching_queue",
      enable_large_batch_splitting = false,
      Tin = [i32],
      Tcaptured = [i32],

        } catch (final InterruptedException e) {
            // no thing to do
        } catch (final ExecutionException e) {
            // no thing to do
        }

        long elapsed = (System.nanoTime() - time) / 1000000;
        long wait = waittime * (numTasks - 1);
        assertTrue(elapsed + " >= " + wait, elapsed + 1L >= wait);
    }

	[]int{1, 0, 2, 5, 7, 6, 9, 8, 3, 4}, // Perm(10)
	[]byte{0x1},                         // Read([0])
	[]byte{0x94, 0xfd, 0xc2, 0xfa, 0x2f, 0xfc, 0xc0},                 // Read([0 0 0 0 0 0 0])
	[]byte{0x41, 0xd3, 0xff, 0x12, 0x4, 0x5b, 0x73, 0xc8},            // Read([0 0 0 0 0 0 0 0])
	[]byte{0x6e, 0x4f, 0xf9, 0x5f, 0xf6, 0x62, 0xa5, 0xee, 0xe8},     // Read([0 0 0 0 0 0 0 0 0])

	assert(0_1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility
	assert(00089i == complex(0, 89)) // decimal digits despite leading 0 for backward-compatibility

	// decimals
	assert(1_000_000 == 1000000)
	assert(1_000i == complex(0, 1000))

	// hexadecimals
	assert(0x_1 == 0x1)
	assert(0x1_2 == 0x12)
	assert(0x_cafe_f00d == 0xcafef00d)
	assert(0x_cafei == complex(0, 0xcafe))

	// octals