cp stdout $WORK\exe-acl.txt
exec powershell -Command 'Get-Acl main.go | Select -expand AccessToString'
cp stdout $WORK\src-acl.txt
cd $TMP
exec powershell -Command 'Get-Acl main.exe | Select -expand AccessToString'
cp stdout $WORK\guest-acl.txt

cd $WORK

# The executable written to the source directory should have the same ACL as the source file.
cmp $WORK\exe-acl.txt $WORK\src-acl.txt

00000050  28 1c f8 42 e6                                    |(..B.|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 20 6f a9 ff 13 fb  |.......... o....|
00000010  85 fa e4 fc cd ca 74 59  21 cd 3c fd 73 43 a2 48  |......tY!.<.sC.H|
00000020  f5 cf cd f7 9b 24 1d db  8a 52 a6 17 03 03 00 1d  |.....$...R......|
00000030  63 25 92 b2 0c f7 d1 92  83 95 3c 13 ee 78 4c c1  |c%........<..xL.|

        assertEquals("jarArchiver", cr.getFieldName());

        ComponentDependency cd = pd.getDependencies().get(0);

        assertEquals("org.apache.maven", cd.getGroupId());
        assertEquals("maven-plugin-api", cd.getArtifactId());
        assertEquals("2.0.6", cd.getVersion());
        assertEquals("jar", cd.getType());

        md = pd.getMojos().get(1);

        assertEquals("war", md.getGoal());

package syntax

import "testing"

var simplifyTests = []struct {
	Regexp string
	Simple string
}{
	// Already-simple constructs
	{`a`, `a`},
	{`ab`, `ab`},
	{`a|b`, `[ab]`},
	{`ab|cd`, `ab|cd`},
	{`(ab)*`, `(ab)*`},
	{`(ab)+`, `(ab)+`},
	{`(ab)?`, `(ab)?`},
	{`.`, `(?s:.)`},
	{`^`, `(?m:^)`},
	{`$`, `(?m:$)`},
	{`[ac]`, `[ac]`},
	{`[^ac]`, `[^ac]`},

	// Posix character classes

000000e0  1d 00 20 2f e5 7d a3 47  cd 62 43 15 28 da ac 5f  |.. /.}.G.bC.(.._|
000000f0  bb 29 07 30 ff f6 84 af  c4 cf c2 ed 90 99 5f 58  |.).0.........._X|
00000100  cb 3b 74                                          |.;t|
>>> Flow 2 (server to client)
00000000  16 03 03 00 7a 02 00 00  76 03 03 3d 50 78 7e 02  |....z...v..=Px~.|
00000010  dc 79 3a 32 6b 6a 50 24  90 65 72 5e cd fc 96 18  |.y:2kjP$.er^....|

go env GOWORK
stdout '^'$GOPATH'[\\/]src[\\/]go.work$'
go env
stdout '^(set )?GOWORK=''?'$GOPATH'[\\/]src[\\/]go.work''?$'

cd ..
go env GOWORK
! stdout .
go env
stdout 'GOWORK=("")?'

cd src
go env GOWORK
stdout 'go.work'

env GOWORK='off'
go env GOWORK
stdout 'off'

! go env -w GOWORK=off
stderr '^go: GOWORK cannot be modified$'

-- go.work --
go 1.18

use a
-- a/go.mod --

# 'mod tidy' removed dependencies if the module root was
# within a directory named 'testdata' or '_foo'.

env GO111MODULE=on

# A module should be allowed in a directory named testdata.
cd $WORK/testdata
go mod init testdata.tld/foo

# Getting a package within that module should resolve its dependencies.
go get
grep 'rsc.io/quote' go.mod

# Tidying the module should preserve those dependencies.

}

//go:noinline
func spills(px *i4) {
}

//go:registerparams
//go:noinline
func F(x i4) i4 {
	ab := x.a + x.b
	bc := x.b + x.c
	cd := x.c + x.d
	ad := x.a + x.d
	ba := x.a - x.b
	cb := x.b - x.c
	dc := x.c - x.d
	da := x.a - x.d
	i := i4{ab*bc + da, cd*ad + cb, ba*cb + ad, dc*da + bc}
	spills(&i)
	return i
}

func main() {
	x := i4{1, 2, 3, 4}
	y := x
	z := F(x)

			inputFile:   "testdata/dump.json",
			wantConfigs: 27,
			wantErr:     false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cw := &ConfigWriter{}
			cd, _ := os.ReadFile(tt.inputFile)
			err := cw.Prime(cd)
			if cw.ztunnelDump == nil {
				if tt.wantConfigs != 0 {
					t.Errorf("wanted some configs loaded but config dump was nil")
				}
			} else if len(cw.ztunnelDump.Workloads) != tt.wantConfigs {

00000160  11 9d 5f 03 62 52 01 bb  69 77 45 19 ee 5b 11 8f  |.._.bR..iwE..[..|
00000170  75 65 49 e4 df cd 87 7c  ab c9 7d 0c 1c ed b0 08  |ueI....|..}.....|
00000180  c7 ba 08 2d a7 26 75 80  1d 1d 0c 7f 01 15 6f 82  |...-.&u.......o.|
00000190  bf 5a a3 84 cd ac 91 56  cb d2 17 78 a5 b0 22 bf  |.Z.....V...x..".|
000001a0  d2 f3 1e 9f 8f f7 66 b7  a0 ec 28 f1 c5 b6 4e 24  |......f...(...N$|