}

// We expect this event to be received almost immediately, but let's wait 1 s to be sure

if eventsReceived == 0 {

t.Fatal("inotify event hasn't been received after 1 second")

}

select {

case <-done:

t.Log("event channel closed")

t.Fatal("event stream was not closed after 1 second")

}

}

done = true

}()

if !done {

t.Fatal("double Close() test failed: second Close() call didn't return")

}

}

if test.r == 0 {

// save for CharacterByCharacterTests

}

var buf [utf8.UTFMax]byte

sz := utf8.EncodeRune(buf[:], rune(r))

func CharacterByCharacterTests() {

tests := part[1].tests

for i := 0; i <= len(tests); i++ { // last one is special case

if i == len(tests) {

r = 0x2FA1E // Don't have to go to 0x10FFFF

} else {

norm.NFC.Append(nil, buf...)

success <- true

}()

select {

case <-success:

// test completed before the timeout

switch dv.Kind() {

case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

s := asString(src)

if err != nil {

return fmt.Errorf("converting string %q to a %s: %v", s, dv.Kind(), err)

}

dv.SetInt(i64)

return nil

case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:

s := asString(src)

if err != nil {

return fmt.Errorf("converting string %q to a %s: %v", s, dv.Kind(), err)

}

dv.SetUint(u64)

return nil

case reflect.Float32, reflect.Float64:

s := asString(src)

if err != nil {

return fmt.Errorf("converting string %q to a %s: %v", s, dv.Kind(), err)

}

dv.SetFloat(f64)

return nil

}

// Strings to integers

{s: "255", d: &scanuint8, wantuint: 255},

{s: "256", d: &scanuint16, wantuint: 256},

{s: "-1", d: &scanint, wantint: -1},

// True bools

{s: true, d: &scanbool, wantbool: true},

func (db *DB) conn() (driver.Conn, error) {

db.mu.Lock()

if db.closed {

return nil, errors.New("sql: database is closed")

}

if n := len(db.freeConn); n > 0 {

t.Fatalf("Commit = %v", err)

}

}

if err != nil {

break

}

switch packet[0] {

case msgChannelData:

if len(packet) < 9 {

peersId := uint32(packet[1])<<24 | uint32(packet[2])<<16 | uint32(packet[3])<<8 | uint32(packet[4])

if length := int(packet[5])<<24 | int(packet[6])<<16 | int(packet[7])<<8 | int(packet[8]); length > 0 {

packet = packet[9:]

}

case msgChannelExtendedData:

if len(packet) < 13 {

datatype := uint32(packet[5])<<24 | uint32(packet[6])<<16 | uint32(packet[7])<<8 | uint32(packet[8])

if length := int(packet[9])<<24 | int(packet[10])<<16 | int(packet[11])<<8 | int(packet[12]); length > 0 {

packet = packet[13:]

// for stderr on interactive sessions. Other data types are

// silently discarded.

if datatype == 1 {

}

}

default:

c.getChan(msg.PeersId).msg <- msg

case *channelCloseMsg:

ch := c.getChan(msg.PeersId)

close(ch.stdin.win)

c.chanlist.remove(msg.PeersId)

case *channelEOFMsg:

case *channelRequestSuccessMsg:

c.getChan(msg.PeersId).msg <- msg

case *channelRequestFailureMsg:

c.getChan(msg.PeersId).msg <- msg

case *windowAdjustMsg:

c.getChan(msg.PeersId).stdin.win <- int(msg.AdditionalBytes)

default:

fmt.Printf("mainLoop: unhandled message %T: %v\n", msg, msg)

}

}

}

// then initiates a SSH handshake, returning the resulting client connection.

func Dial(network, addr string, config *ClientConfig) (*ClientConn, error) {

conn, err := net.Dial(network, addr)

return Client(conn, config)

}

// been passed to an SSH function it must not be modified.

type ClientConfig struct {

// be used.

Rand io.Reader

// The username to authenticate.

User string

// of a particular RFC 4252 method will be used during authentication.

Auth []ClientAuth

return c.Rand

}

// over a single SSH connection.

type clientChan struct {

packetWriter

stdout *chanReader // receives the payload of channelData messages

stderr *chanReader // receives the payload of channelExtendedData messages

msg chan interface{} // incoming messages

}

// newClientChan returns a partially constructed *clientChan

// needs to be assigned once known.

func newClientChan(t *transport, id uint32) *clientChan {

c := &clientChan{

return c

}

func (c *clientChan) waitForChannelOpenResponse() error {

switch msg := (<-c.msg).(type) {

case *channelOpenConfirmMsg:

return errors.New("unexpected packet")

}

return c.writePacket(marshal(msgChannelClose, channelCloseMsg{

PeersId: c.peersId,

}))

}

// Thread safe channel list.

type chanlist struct {

// protects concurrent access to chans

}

func (w *chanWriter) Close() error {

}

// A chanReader represents stdout or stderr of a remote process.

// If writes to this channel block, they will block mainLoop, making

// it unable to receive new messages from the remote side.

data chan []byte // receives data from remote

clientChan *clientChan // the channel backing this reader

buf []byte

}

// Read reads data from the remote process's stdout or stderr.

func (r *chanReader) Read(data []byte) (int, error) {

var ok bool

// ClientConn functional tests.

// These tests require a running ssh server listening on port 22

// -ssh.user and -ssh.pass must be passed to gotest.

import (

SIGUSR2 Signal = "USR2"

)

// A Session represents a connection to a remote command or shell.

type Session struct {

// Stdin specifies the remote process's standard input.

return s.start()

}

func (s *Session) Run(cmd string) error {

err := s.Start(cmd)

if err != nil {

}

// Wait waits for the remote command to exit.

func (s *Session) Wait() error {

if !s.started {

return errors.New("ssh: session not started")

}

func (s *Session) wait() error {

case *channelRequestMsg:

switch msg.Request {

case "exit-status":

d := msg.RequestSpecificData

case "exit-signal":

default:

return fmt.Errorf("wait: unexpected channel request: %v", msg)

}

return fmt.Errorf("wait: unexpected packet %T received: %v", msg, msg)

}

}

}

func (s *Session) stdin() error {

clientChan: ch,

}, nil

}

"testing"

)

// dial constructs a new test server and returns a *ClientConn.

pw := password("tiger")

serverConfig.PasswordCallback = func(user, pass string) bool {

return user == "testuser" && pass == string(pw)

continue

}

ch.Accept()

}

t.Log("done")

}()

// Test a simple string is returned to session.Stdout.

func TestSessionShell(t *testing.T) {

defer conn.Close()

session, err := conn.NewSession()

if err != nil {

// Test a simple string is returned via StdoutPipe.

func TestSessionStdoutPipe(t *testing.T) {

defer conn.Close()

session, err := conn.NewSession()

if err != nil {

t.Fatalf("Remote shell did not return expected string: expected=golang, actual=%s", actual)

}

}

func (p *gcParser) init(filename, id string, src io.Reader, imports map[string]*ast.Object) {

p.scanner.Init(src)

p.scanner.Error = func(_ *scanner.Scanner, msg string) { p.error(msg) }

p.scanner.Whitespace = 1<<'\t' | 1<<' '

p.scanner.Filename = filename // for good error messages

p.next()

// Declare inserts a named object of the given kind in scope.

func (p *gcParser) declare(scope *ast.Scope, kind ast.ObjKind, name string) *ast.Object {

}

obj := ast.NewObj(kind, name)

if scope.Insert(obj) != nil {

p.errorf("already declared: %v %s", kind, obj.Name)

func (p *gcParser) expect(tok rune) string {

lit := p.lit

if p.tok != tok {

}

p.next()

return lit

}

func (p *gcParser) expectSpecial(tok string) {

i := 0

for i < len(tok) && p.tok == rune(tok[i]) && sep > ' ' {

sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token

func (p *gcParser) parseDotIdent() string {

ident := ""

if p.tok != scanner.Int {

for (p.tok == scanner.Ident || p.tok == scanner.Int || p.tok == '·') && sep > ' ' {

ident += p.lit

sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token

// Literal = bool_lit | int_lit | float_lit | complex_lit | string_lit .

// bool_lit = "true" | "false" .

// complex_lit = "(" float_lit "+" float_lit ")" .

// string_lit = `"` { unicode_char } `"` .

//

func (p *gcParser) parseConstDecl() {

typ = Float64.Underlying

}

case '(':

p.next()

re := p.parseNumber()

p.expect('+')

im := p.parseNumber()

p.expect(')')

x = Const{cmplx{re.val.(*big.Rat), im.val.(*big.Rat)}}

typ = Complex128.Underlying

case scanner.String:

// string_lit

x = MakeConst(token.STRING, p.lit)

p.next()

typ = String.Underlying

default:

}

if obj.Type == nil {

obj.Type = typ

// NewWatcher creates and returns a Watcher.

func NewWatcher() (*Watcher, error) {

port, e := syscall.CreateIoCompletionPort(syscall.InvalidHandle, 0, 0, 0)

return nil, os.NewSyscallError("CreateIoCompletionPort", e)

}

w := &Watcher{

func (w *Watcher) wakeupReader() error {

e := syscall.PostQueuedCompletionStatus(w.port, 0, 0, nil)

return os.NewSyscallError("PostQueuedCompletionStatus", e)

}

return nil

func getDir(pathname string) (dir string, err error) {

attr, e := syscall.GetFileAttributes(syscall.StringToUTF16Ptr(pathname))

return "", os.NewSyscallError("GetFileAttributes", e)

}

if attr&syscall.FILE_ATTRIBUTE_DIRECTORY != 0 {

syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE,

nil, syscall.OPEN_EXISTING,

syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OVERLAPPED, 0)

return nil, os.NewSyscallError("CreateFile", e)

}

var fi syscall.ByHandleFileInformation

syscall.CloseHandle(h)

return nil, os.NewSyscallError("GetFileInformationByHandle", e)

}

}

watchEntry := w.watches.get(ino)

if watchEntry == nil {

syscall.CloseHandle(ino.handle)

return os.NewSyscallError("CreateIoCompletionPort", e)

}

// Must run within the I/O thread.

func (w *Watcher) startRead(watch *watch) error {

w.Error <- os.NewSyscallError("CancelIo", e)

w.deleteWatch(watch)

}

mask |= toWindowsFlags(m)

}

if mask == 0 {

w.Error <- os.NewSyscallError("CloseHandle", e)

}

delete(w.watches[watch.ino.volume], watch.ino.index)

}

e := syscall.ReadDirectoryChanges(watch.ino.handle, &watch.buf[0],

uint32(unsafe.Sizeof(watch.buf)), false, mask, nil, &watch.ov, 0)

err := os.NewSyscallError("ReadDirectoryChanges", e)

if e == syscall.ERROR_ACCESS_DENIED && watch.mask&provisional == 0 {

// Watched directory was probably removed

}

}

var err error

err = os.NewSyscallError("CloseHandle", e)

}

close(w.Event)

default:

w.Error <- os.NewSyscallError("GetQueuedCompletionPort", e)

continue

}

var offset uint32

if event.Name != name || event.Mask != mask {

t.Fatal("did not receive expected event")

}

t.Fatal("timed out waiting for event")

}

}

done = true

}()

if !done {

t.Fatal("double Close() test failed: second Close() call didn't return")

}

os.Exit(1)

}

}

// global vars

func WndProc(hwnd syscall.Handle, msg uint32, wparam, lparam uintptr) (rc uintptr) {

switch msg {

case WM_CREATE:

// CreateWindowEx

bh, e = CreateWindowEx(

0,

WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON,

75, 70, 140, 25,

hwnd, 1, mh, 0)

abortErrNo("CreateWindowEx", e)

}

fmt.Printf("button handle is %x\n", bh)

switch syscall.Handle(lparam) {

case bh:

e := PostMessage(hwnd, WM_CLOSE, 0, 0)

abortErrNo("PostMessage", e)

}

default:

}

func rungui() int {

// GetModuleHandle

mh, e = GetModuleHandle(nil)

abortErrNo("GetModuleHandle", e)

}

// Get icon we're going to use.

myicon, e := LoadIcon(0, IDI_APPLICATION)

abortErrNo("LoadIcon", e)

}

// Get cursor we're going to use.

mycursor, e := LoadCursor(0, IDC_ARROW)

abortErrNo("LoadCursor", e)

}

wc.MenuName = nil

wc.ClassName = wcname

wc.IconSm = myicon

abortErrNo("RegisterClassEx", e)

}

WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, CW_USEDEFAULT, 300, 200,

0, 0, mh, 0)

abortErrNo("CreateWindowEx", e)

}

fmt.Printf("main window handle is %x\n", wh)

ShowWindow(wh, SW_SHOWDEFAULT)

// UpdateWindow

abortErrNo("UpdateWindow", e)

}

var m Msg

for {

r, e := GetMessage(&m, 0, 0, 0)

abortErrNo("GetMessage", e)

}

if r == 0 {

IDI_INFORMATION = IDI_ASTERISK

)

//sys DefWindowProc(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (lresult uintptr) = user32.DefWindowProcW

//sys PostQuitMessage(exitcode int32) = user32.PostQuitMessage

//sys ShowWindow(hwnd syscall.Handle, cmdshow int32) (wasvisible bool) = user32.ShowWindow

//sys TranslateMessage(msg *Msg) (done bool) = user32.TranslateMessage

//sys DispatchMessage(msg *Msg) (ret int32) = user32.DispatchMessageW

//sys SendMessage(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (lresult uintptr) = user32.SendMessageW

func MakeIntResource(id uint16) *uint16 {

return (*uint16)(unsafe.Pointer(uintptr(id)))

procPostMessageW = moduser32.NewProc("PostMessageW")

)

r0, _, e1 := syscall.Syscall(procGetModuleHandleW.Addr(), 1, uintptr(unsafe.Pointer(modname)), 0, 0)

handle = syscall.Handle(r0)

if handle == 0 {

if e1 != 0 {

} else {

}

}

return

}

r0, _, e1 := syscall.Syscall(procRegisterClassExW.Addr(), 1, uintptr(unsafe.Pointer(wndclass)), 0, 0)

atom = uint16(r0)

if atom == 0 {

if e1 != 0 {

} else {

}

}

return

}

r0, _, e1 := syscall.Syscall12(procCreateWindowExW.Addr(), 12, uintptr(exstyle), uintptr(unsafe.Pointer(classname)), uintptr(unsafe.Pointer(windowname)), uintptr(style), uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(wndparent), uintptr(menu), uintptr(instance), uintptr(param))

hwnd = syscall.Handle(r0)

if hwnd == 0 {

if e1 != 0 {

} else {

}

}

return

}

return

}

r1, _, e1 := syscall.Syscall(procDestroyWindow.Addr(), 1, uintptr(hwnd), 0, 0)

if int(r1) == 0 {

if e1 != 0 {

} else {

}

}

return

}

return

}

r1, _, e1 := syscall.Syscall(procUpdateWindow.Addr(), 1, uintptr(hwnd), 0, 0)

if int(r1) == 0 {

if e1 != 0 {

} else {

}

}

return

}

r0, _, e1 := syscall.Syscall6(procGetMessageW.Addr(), 4, uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax), 0, 0)

ret = int32(r0)

if ret == -1 {

if e1 != 0 {

} else {

}

}

return

}

return

}

r0, _, e1 := syscall.Syscall(procLoadIconW.Addr(), 2, uintptr(instance), uintptr(unsafe.Pointer(iconname)), 0)

icon = syscall.Handle(r0)

if icon == 0 {

if e1 != 0 {

} else {

}

}

return

}

r0, _, e1 := syscall.Syscall(procLoadCursorW.Addr(), 2, uintptr(instance), uintptr(unsafe.Pointer(cursorname)), 0)

cursor = syscall.Handle(r0)

if cursor == 0 {

if e1 != 0 {

} else {

}

}

return

}

r0, _, e1 := syscall.Syscall(procSetCursor.Addr(), 1, uintptr(cursor), 0, 0)

precursor = syscall.Handle(r0)

if precursor == 0 {

if e1 != 0 {

} else {

}

}

return

}

return

}

r1, _, e1 := syscall.Syscall6(procPostMessageW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)

if int(r1) == 0 {

if e1 != 0 {

} else {

}

}

return

}