results    []string // expected results of reads
	}{
		{12, 15, []string{"0123456789", "ab\x00\x00\x00fghij", "klmn"}},                              // within one read
		{8, 21, []string{"01234567\x00\x00", "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", "\x00lmn"}}, // across multiple reads
		{10, 20, []string{"0123456789", "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", "klmn"}},         // a whole read

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno
"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop
#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq
$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr
%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs

	_, _, m, err := createTestRuntimeManager()
	require.NoError(t, err)
	pod := newTestPod()

	expectedLogDirectory := filepath.Join(testPodLogsDirectory, pod.Namespace+"_"+pod.Name+"_12345678")
	expectedLabels := map[string]string{
		"io.kubernetes.pod.name":      pod.Name,
		"io.kubernetes.pod.namespace": pod.Namespace,
		"io.kubernetes.pod.uid":       string(pod.UID),
	}

        def fileEmpty = new File("empty")
        def fileStates = [:]
        fileStates.put(fileEmpty, compilationFileState(TestHashCodes.hashCodeFrom(0x12345678), []))

        def fileTwo = new File("two")
        def stateTwo = compilationFileState(TestHashCodes.hashCodeFrom(0x23456789), ["ONE", "TWO"])
        fileStates.put(fileTwo, stateTwo)
        def state = compilationState(fileStates)

        then:

package crypto_test

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rc4"
	"testing"
)

func TestRC4OutOfBoundsWrite(t *testing.T) {
	// This cipherText is encrypted "0123456789"
	cipherText := []byte{238, 41, 187, 114, 151, 2, 107, 13, 178, 63}
	cipher, err := rc4.NewCipher([]byte{0})
	if err != nil {
		panic(err)
	}
	test(t, "RC4", cipherText, cipher.XORKeyStream)
}

func _() {
	// 0-octals
	assert(0_123 == 0123)
	assert(0123_456 == 0123456)

	// decimals
	assert(1_234 == 1234)
	assert(1_234_567 == 1234567)

	// hexadecimals
	assert(0X_0 == 0)
	assert(0X_1234 == 0x1234)
	assert(0X_CAFE_f00d == 0xcafef00d)

	// octals
	assert(0o0 == 0)
	assert(0o1234 == 01234)
	assert(0o01234567 == 01234567)

	assert(0O0 == 0)
	assert(0O1234 == 01234)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build cgo

package main

// void f(int *p) { *p = 0x12345678; }
import "C"

func main() {
	var x C.int
	func() {
		defer C.f(&x)
	}()
	if x != 0x12345678 {
		panic("FAIL")
	}

	"io"
	"strings"
	"sync"
	"testing"
)

func TestReader(t *testing.T) {
	r := strings.NewReader("0123456789")
	tests := []struct {
		off     int64
		seek    int
		n       int
		want    string
		wantpos int64
		readerr error
		seekerr string
	}{
		{seek: io.SeekStart, off: 0, n: 20, want: "0123456789"},
		{seek: io.SeekStart, off: 1, n: 1, want: "1"},
		{seek: io.SeekCurrent, off: 1, wantpos: 3, n: 2, want: "34"},

	SHA256ROUND0(5, 0x59f111f1, 3, 4, 5, 6, 7, 0, 1, 2)
	SHA256ROUND0(6, 0x923f82a4, 2, 3, 4, 5, 6, 7, 0, 1)
	SHA256ROUND0(7, 0xab1c5ed5, 1, 2, 3, 4, 5, 6, 7, 0)
	SHA256ROUND0(8, 0xd807aa98, 0, 1, 2, 3, 4, 5, 6, 7)
	SHA256ROUND0(9, 0x12835b01, 7, 0, 1, 2, 3, 4, 5, 6)
	SHA256ROUND0(10, 0x243185be, 6, 7, 0, 1, 2, 3, 4, 5)
	SHA256ROUND0(11, 0x550c7dc3, 5, 6, 7, 0, 1, 2, 3, 4)
	SHA256ROUND0(12, 0x72be5d74, 4, 5, 6, 7, 0, 1, 2, 3)

			in:   "1",
			want: 1,
		},
		{
			desc: "numeric-zero",
			in:   "0",
			want: 0,
		},
		{
			desc: "numeric-large",
			in:   "12345678",
			want: 12345678,
		},
		{
			desc: "numeric-negative",
			in:   "-12345678",
			want: -12345678,
		},
		{
			desc: "float",
			in:   "1.23456",
			want: 1.23456,
		},
		{
			desc: "float-zero",
			in:   "0.00",
			want: 0.00,
		},