package main

import "net/http"

var s = http.Server{}
var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$|unexported field or method|s.doneChan undefined"
var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$|undefined field or method"

	}
	f.doneChan = nil // ERROR "f.doneChan undefined .cannot refer to unexported field or method doneChan."
	f.DoneChan = nil // ERROR "f.DoneChan undefined .type f1.Foo has no field or method DoneChan."
	f.name = nil     // ERROR "f.name undefined .type f1.Foo has no field or method name, but does have Name."

	_ = f.doneChan // ERROR "f.doneChan undefined .cannot refer to unexported field or method doneChan."

		tc.fake.logger = logger
		sync := New(&tc.fake, &tc.fake, &tc.fake, tc.mode, "node1", cidr)
		doneChan := make(chan struct{})

		// Do a single step of the loop.
		go sync.Loop(logger, doneChan)
		sync.Update(tc.node)
		close(sync.opChan)
		<-doneChan
		tc.fake.dumpTrace()

		if !reflect.DeepEqual(tc.fake.events, tc.events) {

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package f1

type Foo struct {
	doneChan chan bool
	Name     string
	fOO      int
	hook     func()
}

func (f *Foo) Exported() {
}

func (f *Foo) unexported() {

			pf, err := New(dialer, test.ports, stopChan, readyChan, os.Stdout, os.Stderr)
			if err != nil {
				t.Fatalf("%s: unexpected error calling New: %v", testName, err)
			}

			doneChan := make(chan error)
			go func() {
				doneChan <- pf.ForwardPorts()
			}()
			<-pf.Ready

			forwardedPorts, err := pf.GetPorts()
			if err != nil {
				t.Fatal(err)
			}

			remoteToLocalMap := map[int32]int32{}

	{"simple", "run", "", "atexit_sleep_ms=0", `
package main
import "time"
var xptr *int
var donechan chan bool
func main() {
	done := make(chan bool)
	x := 0
	startRacer(&x, done)
	store(&x, 43)
	<-done
}
func store(x *int, v int) {
	*x = v
}
func startRacer(x *int, done chan bool) {
	xptr = x
	donechan = done
	go racer()
}
func racer() {
	time.Sleep(10*time.Millisecond)
	store(xptr, 42)

			if t.Failed() {
				t.Logf("OpenSSL output:\n\n%s", stdout.all)
			}
		}()
	} else {
		clientConn, serverConn = localPipe(t)
	}

	doneChan := make(chan bool)
	defer func() {
		clientConn.Close()
		<-doneChan
	}()
	go func() {
		defer close(doneChan)

		config := test.config
		if config == nil {
			config = testConfig
		}
		client := Client(clientConn, config)
		defer client.Close()

nsw.edu.au
nt.edu.au
qld.edu.au
sa.edu.au
tas.edu.au
vic.edu.au
wa.edu.au
// act.gov.au  Bug 984824 - Removed at request of Greg Tankard
// nsw.gov.au  Bug 547985 - Removed at request of <Shae.Donelan@services.nsw.gov.au>
// nt.gov.au  Bug 940478 - Removed at request of Greg Connors <******@****.***>
qld.gov.au
sa.gov.au
tas.gov.au
vic.gov.au
wa.gov.au
// 4LDs