@cryptotaxi247 / kubo / commits / b9d055c04

remove context from godeps, its in gx now

License: MIT Signed-off-by: Jeromy <jeromyj@gmail.com>

Jeromy committed Feb 8, 2016 at 16:29 UTC b9d055c0481006cd4b194d50a418144e45be12b1

4 files changed +5 -1048

Godeps/_workspace/src/golang.org/x/net/context/context.go deleted

-447

@@ -1,447 +0,0 @@

2 -// Use of this source code is governed by a BSD-style

3 -// license that can be found in the LICENSE file.

4 -

5 -// Package context defines the Context type, which carries deadlines,

6 -// cancelation signals, and other request-scoped values across API boundaries

7 -// and between processes.

8 -//

9 -// Incoming requests to a server should create a Context, and outgoing calls to

10 -// servers should accept a Context. The chain of function calls between must

11 -// propagate the Context, optionally replacing it with a modified copy created

12 -// using WithDeadline, WithTimeout, WithCancel, or WithValue.

13 -//

14 -// Programs that use Contexts should follow these rules to keep interfaces

15 -// consistent across packages and enable static analysis tools to check context

16 -// propagation:

17 -//

18 -// Do not store Contexts inside a struct type; instead, pass a Context

19 -// explicitly to each function that needs it. The Context should be the first

20 -// parameter, typically named ctx:

21 -//

22 -// func DoSomething(ctx context.Context, arg Arg) error {

23 -// // ... use ctx ...

24 -// }

25 -//

26 -// Do not pass a nil Context, even if a function permits it. Pass context.TODO

27 -// if you are unsure about which Context to use.

28 -//

29 -// Use context Values only for request-scoped data that transits processes and

30 -// APIs, not for passing optional parameters to functions.

31 -//

32 -// The same Context may be passed to functions running in different goroutines;

33 -// Contexts are safe for simultaneous use by multiple goroutines.

34 -//

35 -// See http://blog.golang.org/context for example code for a server that uses

36 -// Contexts.

37 -package context

38 -

39 -import (

40 - "errors"

41 - "fmt"

42 - "sync"

43 - "time"

44 -)

45 -

46 -// A Context carries a deadline, a cancelation signal, and other values across

47 -// API boundaries.

48 -//

49 -// Context's methods may be called by multiple goroutines simultaneously.

50 -type Context interface {

51 - // Deadline returns the time when work done on behalf of this context

52 - // should be canceled. Deadline returns ok==false when no deadline is

53 - // set. Successive calls to Deadline return the same results.

54 - Deadline() (deadline time.Time, ok bool)

55 -

56 - // Done returns a channel that's closed when work done on behalf of this

57 - // context should be canceled. Done may return nil if this context can

58 - // never be canceled. Successive calls to Done return the same value.

59 - //

60 - // WithCancel arranges for Done to be closed when cancel is called;

61 - // WithDeadline arranges for Done to be closed when the deadline

62 - // expires; WithTimeout arranges for Done to be closed when the timeout

63 - // elapses.

64 - //

65 - // Done is provided for use in select statements:

66 - //

67 - // // Stream generates values with DoSomething and sends them to out

68 - // // until DoSomething returns an error or ctx.Done is closed.

69 - // func Stream(ctx context.Context, out <-chan Value) error {

70 - // for {

71 - // v, err := DoSomething(ctx)

72 - // if err != nil {

73 - // return err

74 - // }

75 - // select {

76 - // case <-ctx.Done():

77 - // return ctx.Err()

78 - // case out <- v:

79 - // }

80 - // }

81 - // }

82 - //

83 - // See http://blog.golang.org/pipelines for more examples of how to use

84 - // a Done channel for cancelation.

85 - Done() <-chan struct{}

86 -

87 - // Err returns a non-nil error value after Done is closed. Err returns

88 - // Canceled if the context was canceled or DeadlineExceeded if the

89 - // context's deadline passed. No other values for Err are defined.

90 - // After Done is closed, successive calls to Err return the same value.

91 - Err() error

92 -

93 - // Value returns the value associated with this context for key, or nil

94 - // if no value is associated with key. Successive calls to Value with

95 - // the same key returns the same result.

96 - //

97 - // Use context values only for request-scoped data that transits

98 - // processes and API boundaries, not for passing optional parameters to

99 - // functions.

100 - //

101 - // A key identifies a specific value in a Context. Functions that wish

102 - // to store values in Context typically allocate a key in a global

103 - // variable then use that key as the argument to context.WithValue and

104 - // Context.Value. A key can be any type that supports equality;

105 - // packages should define keys as an unexported type to avoid

106 - // collisions.

107 - //

108 - // Packages that define a Context key should provide type-safe accessors

109 - // for the values stores using that key:

110 - //

111 - // // Package user defines a User type that's stored in Contexts.

112 - // package user

113 - //

114 - // import "golang.org/x/net/context"

115 - //

116 - // // User is the type of value stored in the Contexts.

117 - // type User struct {...}

118 - //

119 - // // key is an unexported type for keys defined in this package.

120 - // // This prevents collisions with keys defined in other packages.

121 - // type key int

122 - //

123 - // // userKey is the key for user.User values in Contexts. It is

124 - // // unexported; clients use user.NewContext and user.FromContext

125 - // // instead of using this key directly.

126 - // var userKey key = 0

127 - //

128 - // // NewContext returns a new Context that carries value u.

129 - // func NewContext(ctx context.Context, u *User) context.Context {

130 - // return context.WithValue(ctx, userKey, u)

131 - // }

132 - //

133 - // // FromContext returns the User value stored in ctx, if any.

134 - // func FromContext(ctx context.Context) (*User, bool) {

135 - // u, ok := ctx.Value(userKey).(*User)

136 - // return u, ok

137 - // }

138 - Value(key interface{}) interface{}

139 -}

140 -

141 -// Canceled is the error returned by Context.Err when the context is canceled.

142 -var Canceled = errors.New("context canceled")

143 -

144 -// DeadlineExceeded is the error returned by Context.Err when the context's

145 -// deadline passes.

146 -var DeadlineExceeded = errors.New("context deadline exceeded")

147 -

148 -// An emptyCtx is never canceled, has no values, and has no deadline. It is not

149 -// struct{}, since vars of this type must have distinct addresses.

150 -type emptyCtx int

151 -

152 -func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {

153 - return

154 -}

155 -

156 -func (*emptyCtx) Done() <-chan struct{} {

157 - return nil

158 -}

159 -

160 -func (*emptyCtx) Err() error {

161 - return nil

162 -}

163 -

164 -func (*emptyCtx) Value(key interface{}) interface{} {

165 - return nil

166 -}

167 -

168 -func (e *emptyCtx) String() string {

169 - switch e {

170 - case background:

171 - return "context.Background"

172 - case todo:

173 - return "context.TODO"

174 - }

175 - return "unknown empty Context"

176 -}

177 -

178 -var (

179 - background = new(emptyCtx)

180 - todo = new(emptyCtx)

181 -)

182 -

183 -// Background returns a non-nil, empty Context. It is never canceled, has no

184 -// values, and has no deadline. It is typically used by the main function,

185 -// initialization, and tests, and as the top-level Context for incoming

186 -// requests.

187 -func Background() Context {

188 - return background

189 -}

190 -

191 -// TODO returns a non-nil, empty Context. Code should use context.TODO when

192 -// it's unclear which Context to use or it's is not yet available (because the

193 -// surrounding function has not yet been extended to accept a Context

194 -// parameter). TODO is recognized by static analysis tools that determine

195 -// whether Contexts are propagated correctly in a program.

196 -func TODO() Context {

197 - return todo

198 -}

199 -

200 -// A CancelFunc tells an operation to abandon its work.

201 -// A CancelFunc does not wait for the work to stop.

202 -// After the first call, subsequent calls to a CancelFunc do nothing.

203 -type CancelFunc func()

204 -

205 -// WithCancel returns a copy of parent with a new Done channel. The returned

206 -// context's Done channel is closed when the returned cancel function is called

207 -// or when the parent context's Done channel is closed, whichever happens first.

208 -//

209 -// Canceling this context releases resources associated with it, so code should

210 -// call cancel as soon as the operations running in this Context complete.

211 -func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {

212 - c := newCancelCtx(parent)

213 - propagateCancel(parent, &c)

214 - return &c, func() { c.cancel(true, Canceled) }

215 -}

216 -

217 -// newCancelCtx returns an initialized cancelCtx.

218 -func newCancelCtx(parent Context) cancelCtx {

219 - return cancelCtx{

220 - Context: parent,

221 - done: make(chan struct{}),

222 - }

223 -}

224 -

225 -// propagateCancel arranges for child to be canceled when parent is.

226 -func propagateCancel(parent Context, child canceler) {

227 - if parent.Done() == nil {

228 - return // parent is never canceled

229 - }

230 - if p, ok := parentCancelCtx(parent); ok {

231 - p.mu.Lock()

232 - if p.err != nil {

233 - // parent has already been canceled

234 - child.cancel(false, p.err)

235 - } else {

236 - if p.children == nil {

237 - p.children = make(map[canceler]bool)

238 - }

239 - p.children[child] = true

240 - }

241 - p.mu.Unlock()

242 - } else {

243 - go func() {

244 - select {

245 - case <-parent.Done():

246 - child.cancel(false, parent.Err())

247 - case <-child.Done():

248 - }

249 - }()

250 - }

251 -}

252 -

253 -// parentCancelCtx follows a chain of parent references until it finds a

254 -// *cancelCtx. This function understands how each of the concrete types in this

255 -// package represents its parent.

256 -func parentCancelCtx(parent Context) (*cancelCtx, bool) {

257 - for {

258 - switch c := parent.(type) {

259 - case *cancelCtx:

260 - return c, true

261 - case *timerCtx:

262 - return &c.cancelCtx, true

263 - case *valueCtx:

264 - parent = c.Context

265 - default:

266 - return nil, false

267 - }

268 - }

269 -}

270 -

271 -// removeChild removes a context from its parent.

272 -func removeChild(parent Context, child canceler) {

273 - p, ok := parentCancelCtx(parent)

274 - if !ok {

275 - return

276 - }

277 - p.mu.Lock()

278 - if p.children != nil {

279 - delete(p.children, child)

280 - }

281 - p.mu.Unlock()

282 -}

283 -

284 -// A canceler is a context type that can be canceled directly. The

285 -// implementations are *cancelCtx and *timerCtx.

286 -type canceler interface {

287 - cancel(removeFromParent bool, err error)

288 - Done() <-chan struct{}

289 -}

290 -

291 -// A cancelCtx can be canceled. When canceled, it also cancels any children

292 -// that implement canceler.

293 -type cancelCtx struct {

294 - Context

295 -

296 - done chan struct{} // closed by the first cancel call.

297 -

298 - mu sync.Mutex

299 - children map[canceler]bool // set to nil by the first cancel call

300 - err error // set to non-nil by the first cancel call

301 -}

302 -

303 -func (c *cancelCtx) Done() <-chan struct{} {

304 - return c.done

305 -}

306 -

307 -func (c *cancelCtx) Err() error {

308 - c.mu.Lock()

309 - defer c.mu.Unlock()

310 - return c.err

311 -}

312 -

313 -func (c *cancelCtx) String() string {

314 - return fmt.Sprintf("%v.WithCancel", c.Context)

315 -}

316 -

317 -// cancel closes c.done, cancels each of c's children, and, if

318 -// removeFromParent is true, removes c from its parent's children.

319 -func (c *cancelCtx) cancel(removeFromParent bool, err error) {

320 - if err == nil {

321 - panic("context: internal error: missing cancel error")

322 - }

323 - c.mu.Lock()

324 - if c.err != nil {

325 - c.mu.Unlock()

326 - return // already canceled

327 - }

328 - c.err = err

329 - close(c.done)

330 - for child := range c.children {

331 - // NOTE: acquiring the child's lock while holding parent's lock.

332 - child.cancel(false, err)

333 - }

334 - c.children = nil

335 - c.mu.Unlock()

336 -

337 - if removeFromParent {

338 - removeChild(c.Context, c)

339 - }

340 -}

341 -

342 -// WithDeadline returns a copy of the parent context with the deadline adjusted

343 -// to be no later than d. If the parent's deadline is already earlier than d,

344 -// WithDeadline(parent, d) is semantically equivalent to parent. The returned

345 -// context's Done channel is closed when the deadline expires, when the returned

346 -// cancel function is called, or when the parent context's Done channel is

347 -// closed, whichever happens first.

348 -//

349 -// Canceling this context releases resources associated with it, so code should

350 -// call cancel as soon as the operations running in this Context complete.

351 -func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {

352 - if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {

353 - // The current deadline is already sooner than the new one.

354 - return WithCancel(parent)

355 - }

356 - c := &timerCtx{

357 - cancelCtx: newCancelCtx(parent),

358 - deadline: deadline,

359 - }

360 - propagateCancel(parent, c)

361 - d := deadline.Sub(time.Now())

362 - if d <= 0 {

363 - c.cancel(true, DeadlineExceeded) // deadline has already passed

364 - return c, func() { c.cancel(true, Canceled) }

365 - }

366 - c.mu.Lock()

367 - defer c.mu.Unlock()

368 - if c.err == nil {

369 - c.timer = time.AfterFunc(d, func() {

370 - c.cancel(true, DeadlineExceeded)

371 - })

372 - }

373 - return c, func() { c.cancel(true, Canceled) }

374 -}

375 -

376 -// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to

377 -// implement Done and Err. It implements cancel by stopping its timer then

378 -// delegating to cancelCtx.cancel.

379 -type timerCtx struct {

380 - cancelCtx

381 - timer *time.Timer // Under cancelCtx.mu.

382 -

383 - deadline time.Time

384 -}

385 -

386 -func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {

387 - return c.deadline, true

388 -}

389 -

390 -func (c *timerCtx) String() string {

391 - return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))

392 -}

393 -

394 -func (c *timerCtx) cancel(removeFromParent bool, err error) {

395 - c.cancelCtx.cancel(false, err)

396 - if removeFromParent {

397 - // Remove this timerCtx from its parent cancelCtx's children.

398 - removeChild(c.cancelCtx.Context, c)

399 - }

400 - c.mu.Lock()

401 - if c.timer != nil {

402 - c.timer.Stop()

403 - c.timer = nil

404 - }

405 - c.mu.Unlock()

406 -}

407 -

408 -// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).

409 -//

410 -// Canceling this context releases resources associated with it, so code should

411 -// call cancel as soon as the operations running in this Context complete:

412 -//

413 -// func slowOperationWithTimeout(ctx context.Context) (Result, error) {

414 -// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)

415 -// defer cancel() // releases resources if slowOperation completes before timeout elapses

416 -// return slowOperation(ctx)

417 -// }

418 -func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {

419 - return WithDeadline(parent, time.Now().Add(timeout))

420 -}

421 -

422 -// WithValue returns a copy of parent in which the value associated with key is

423 -// val.

424 -//

425 -// Use context Values only for request-scoped data that transits processes and

426 -// APIs, not for passing optional parameters to functions.

427 -func WithValue(parent Context, key interface{}, val interface{}) Context {

428 - return &valueCtx{parent, key, val}

429 -}

430 -

431 -// A valueCtx carries a key-value pair. It implements Value for that key and

432 -// delegates all other calls to the embedded Context.

433 -type valueCtx struct {

434 - Context

435 - key, val interface{}

436 -}

437 -

438 -func (c *valueCtx) String() string {

439 - return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)

440 -}

441 -

442 -func (c *valueCtx) Value(key interface{}) interface{} {

443 - if c.key == key {

444 - return c.val

445 - }

446 - return c.Context.Value(key)

447 -}

Godeps/_workspace/src/golang.org/x/net/context/context_test.go deleted

-575

@@ -1,575 +0,0 @@

2 -// Use of this source code is governed by a BSD-style

3 -// license that can be found in the LICENSE file.

4 -

5 -package context

6 -

7 -import (

8 - "fmt"

9 - "math/rand"

10 - "runtime"

11 - "strings"

12 - "sync"

13 - "testing"

14 - "time"

15 -)

16 -

17 -// otherContext is a Context that's not one of the types defined in context.go.

18 -// This lets us test code paths that differ based on the underlying type of the

19 -// Context.

20 -type otherContext struct {

21 - Context

22 -}

23 -

24 -func TestBackground(t *testing.T) {

25 - c := Background()

26 - if c == nil {

27 - t.Fatalf("Background returned nil")

28 - }

29 - select {

30 - case x := <-c.Done():

31 - t.Errorf("<-c.Done() == %v want nothing (it should block)", x)

32 - default:

33 - }

34 - if got, want := fmt.Sprint(c), "context.Background"; got != want {

35 - t.Errorf("Background().String() = %q want %q", got, want)

36 - }

37 -}

38 -

39 -func TestTODO(t *testing.T) {

40 - c := TODO()

41 - if c == nil {

42 - t.Fatalf("TODO returned nil")

43 - }

44 - select {

45 - case x := <-c.Done():

46 - t.Errorf("<-c.Done() == %v want nothing (it should block)", x)

47 - default:

48 - }

49 - if got, want := fmt.Sprint(c), "context.TODO"; got != want {

50 - t.Errorf("TODO().String() = %q want %q", got, want)

51 - }

52 -}

53 -

54 -func TestWithCancel(t *testing.T) {

55 - c1, cancel := WithCancel(Background())

56 -

57 - if got, want := fmt.Sprint(c1), "context.Background.WithCancel"; got != want {

58 - t.Errorf("c1.String() = %q want %q", got, want)

59 - }

60 -

61 - o := otherContext{c1}

62 - c2, _ := WithCancel(o)

63 - contexts := []Context{c1, o, c2}

64 -

65 - for i, c := range contexts {

66 - if d := c.Done(); d == nil {

67 - t.Errorf("c[%d].Done() == %v want non-nil", i, d)

68 - }

69 - if e := c.Err(); e != nil {

70 - t.Errorf("c[%d].Err() == %v want nil", i, e)

71 - }

72 -

73 - select {

74 - case x := <-c.Done():

75 - t.Errorf("<-c.Done() == %v want nothing (it should block)", x)

76 - default:

77 - }

78 - }

79 -

80 - cancel()

81 - time.Sleep(100 * time.Millisecond) // let cancelation propagate

82 -

83 - for i, c := range contexts {

84 - select {

85 - case <-c.Done():

86 - default:

87 - t.Errorf("<-c[%d].Done() blocked, but shouldn't have", i)

88 - }

89 - if e := c.Err(); e != Canceled {

90 - t.Errorf("c[%d].Err() == %v want %v", i, e, Canceled)

91 - }

92 - }

93 -}

94 -

95 -func TestParentFinishesChild(t *testing.T) {

96 - // Context tree:

97 - // parent -> cancelChild

98 - // parent -> valueChild -> timerChild

99 - parent, cancel := WithCancel(Background())

100 - cancelChild, stop := WithCancel(parent)

101 - defer stop()

102 - valueChild := WithValue(parent, "key", "value")

103 - timerChild, stop := WithTimeout(valueChild, 10000*time.Hour)

104 - defer stop()

105 -

106 - select {

107 - case x := <-parent.Done():

108 - t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)

109 - case x := <-cancelChild.Done():

110 - t.Errorf("<-cancelChild.Done() == %v want nothing (it should block)", x)

111 - case x := <-timerChild.Done():

112 - t.Errorf("<-timerChild.Done() == %v want nothing (it should block)", x)

113 - case x := <-valueChild.Done():

114 - t.Errorf("<-valueChild.Done() == %v want nothing (it should block)", x)

115 - default:

116 - }

117 -

118 - // The parent's children should contain the two cancelable children.

119 - pc := parent.(*cancelCtx)

120 - cc := cancelChild.(*cancelCtx)

121 - tc := timerChild.(*timerCtx)

122 - pc.mu.Lock()

123 - if len(pc.children) != 2 || !pc.children[cc] || !pc.children[tc] {

124 - t.Errorf("bad linkage: pc.children = %v, want %v and %v",

125 - pc.children, cc, tc)

126 - }

127 - pc.mu.Unlock()

128 -

129 - if p, ok := parentCancelCtx(cc.Context); !ok || p != pc {

130 - t.Errorf("bad linkage: parentCancelCtx(cancelChild.Context) = %v, %v want %v, true", p, ok, pc)

131 - }

132 - if p, ok := parentCancelCtx(tc.Context); !ok || p != pc {

133 - t.Errorf("bad linkage: parentCancelCtx(timerChild.Context) = %v, %v want %v, true", p, ok, pc)

134 - }

135 -

136 - cancel()

137 -

138 - pc.mu.Lock()

139 - if len(pc.children) != 0 {

140 - t.Errorf("pc.cancel didn't clear pc.children = %v", pc.children)

141 - }

142 - pc.mu.Unlock()

143 -

144 - // parent and children should all be finished.

145 - check := func(ctx Context, name string) {

146 - select {

147 - case <-ctx.Done():

148 - default:

149 - t.Errorf("<-%s.Done() blocked, but shouldn't have", name)

150 - }

151 - if e := ctx.Err(); e != Canceled {

152 - t.Errorf("%s.Err() == %v want %v", name, e, Canceled)

153 - }

154 - }

155 - check(parent, "parent")

156 - check(cancelChild, "cancelChild")

157 - check(valueChild, "valueChild")

158 - check(timerChild, "timerChild")

159 -

160 - // WithCancel should return a canceled context on a canceled parent.

161 - precanceledChild := WithValue(parent, "key", "value")

162 - select {

163 - case <-precanceledChild.Done():

164 - default:

165 - t.Errorf("<-precanceledChild.Done() blocked, but shouldn't have")

166 - }

167 - if e := precanceledChild.Err(); e != Canceled {

168 - t.Errorf("precanceledChild.Err() == %v want %v", e, Canceled)

169 - }

170 -}

171 -

172 -func TestChildFinishesFirst(t *testing.T) {

173 - cancelable, stop := WithCancel(Background())

174 - defer stop()

175 - for _, parent := range []Context{Background(), cancelable} {

176 - child, cancel := WithCancel(parent)

177 -

178 - select {

179 - case x := <-parent.Done():

180 - t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)

181 - case x := <-child.Done():

182 - t.Errorf("<-child.Done() == %v want nothing (it should block)", x)

183 - default:

184 - }

185 -

186 - cc := child.(*cancelCtx)

187 - pc, pcok := parent.(*cancelCtx) // pcok == false when parent == Background()

188 - if p, ok := parentCancelCtx(cc.Context); ok != pcok || (ok && pc != p) {

189 - t.Errorf("bad linkage: parentCancelCtx(cc.Context) = %v, %v want %v, %v", p, ok, pc, pcok)

190 - }

191 -

192 - if pcok {

193 - pc.mu.Lock()

194 - if len(pc.children) != 1 || !pc.children[cc] {

195 - t.Errorf("bad linkage: pc.children = %v, cc = %v", pc.children, cc)

196 - }

197 - pc.mu.Unlock()

198 - }

199 -

200 - cancel()

201 -

202 - if pcok {

203 - pc.mu.Lock()

204 - if len(pc.children) != 0 {

205 - t.Errorf("child's cancel didn't remove self from pc.children = %v", pc.children)

206 - }

207 - pc.mu.Unlock()

208 - }

209 -

210 - // child should be finished.

211 - select {

212 - case <-child.Done():

213 - default:

214 - t.Errorf("<-child.Done() blocked, but shouldn't have")

215 - }

216 - if e := child.Err(); e != Canceled {

217 - t.Errorf("child.Err() == %v want %v", e, Canceled)

218 - }

219 -

220 - // parent should not be finished.

221 - select {

222 - case x := <-parent.Done():

223 - t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)

224 - default:

225 - }

226 - if e := parent.Err(); e != nil {

227 - t.Errorf("parent.Err() == %v want nil", e)

228 - }

229 - }

230 -}

231 -

232 -func testDeadline(c Context, wait time.Duration, t *testing.T) {

233 - select {

234 - case <-time.After(wait):

235 - t.Fatalf("context should have timed out")

236 - case <-c.Done():

237 - }

238 - if e := c.Err(); e != DeadlineExceeded {

239 - t.Errorf("c.Err() == %v want %v", e, DeadlineExceeded)

240 - }

241 -}

242 -

243 -func TestDeadline(t *testing.T) {

244 - c, _ := WithDeadline(Background(), time.Now().Add(100*time.Millisecond))

245 - if got, prefix := fmt.Sprint(c), "context.Background.WithDeadline("; !strings.HasPrefix(got, prefix) {

246 - t.Errorf("c.String() = %q want prefix %q", got, prefix)

247 - }

248 - testDeadline(c, 200*time.Millisecond, t)

249 -

250 - c, _ = WithDeadline(Background(), time.Now().Add(100*time.Millisecond))

251 - o := otherContext{c}

252 - testDeadline(o, 200*time.Millisecond, t)

253 -

254 - c, _ = WithDeadline(Background(), time.Now().Add(100*time.Millisecond))

255 - o = otherContext{c}

256 - c, _ = WithDeadline(o, time.Now().Add(300*time.Millisecond))

257 - testDeadline(c, 200*time.Millisecond, t)

258 -}

259 -

260 -func TestTimeout(t *testing.T) {

261 - c, _ := WithTimeout(Background(), 100*time.Millisecond)

262 - if got, prefix := fmt.Sprint(c), "context.Background.WithDeadline("; !strings.HasPrefix(got, prefix) {

263 - t.Errorf("c.String() = %q want prefix %q", got, prefix)

264 - }

265 - testDeadline(c, 200*time.Millisecond, t)

266 -

267 - c, _ = WithTimeout(Background(), 100*time.Millisecond)

268 - o := otherContext{c}

269 - testDeadline(o, 200*time.Millisecond, t)

270 -

271 - c, _ = WithTimeout(Background(), 100*time.Millisecond)

272 - o = otherContext{c}

273 - c, _ = WithTimeout(o, 300*time.Millisecond)

274 - testDeadline(c, 200*time.Millisecond, t)

275 -}

276 -

277 -func TestCanceledTimeout(t *testing.T) {

278 - c, _ := WithTimeout(Background(), 200*time.Millisecond)

279 - o := otherContext{c}

280 - c, cancel := WithTimeout(o, 400*time.Millisecond)

281 - cancel()

282 - time.Sleep(100 * time.Millisecond) // let cancelation propagate

283 - select {

284 - case <-c.Done():

285 - default:

286 - t.Errorf("<-c.Done() blocked, but shouldn't have")

287 - }

288 - if e := c.Err(); e != Canceled {

289 - t.Errorf("c.Err() == %v want %v", e, Canceled)

290 - }

291 -}

292 -

293 -type key1 int

294 -type key2 int

295 -

296 -var k1 = key1(1)

297 -var k2 = key2(1) // same int as k1, different type

298 -var k3 = key2(3) // same type as k2, different int

299 -

300 -func TestValues(t *testing.T) {

301 - check := func(c Context, nm, v1, v2, v3 string) {

302 - if v, ok := c.Value(k1).(string); ok == (len(v1) == 0) || v != v1 {

303 - t.Errorf(`%s.Value(k1).(string) = %q, %t want %q, %t`, nm, v, ok, v1, len(v1) != 0)

304 - }

305 - if v, ok := c.Value(k2).(string); ok == (len(v2) == 0) || v != v2 {

306 - t.Errorf(`%s.Value(k2).(string) = %q, %t want %q, %t`, nm, v, ok, v2, len(v2) != 0)

307 - }

308 - if v, ok := c.Value(k3).(string); ok == (len(v3) == 0) || v != v3 {

309 - t.Errorf(`%s.Value(k3).(string) = %q, %t want %q, %t`, nm, v, ok, v3, len(v3) != 0)

310 - }

311 - }

312 -

313 - c0 := Background()

314 - check(c0, "c0", "", "", "")

315 -

316 - c1 := WithValue(Background(), k1, "c1k1")

317 - check(c1, "c1", "c1k1", "", "")

318 -

319 - if got, want := fmt.Sprint(c1), `context.Background.WithValue(1, "c1k1")`; got != want {

320 - t.Errorf("c.String() = %q want %q", got, want)

321 - }

322 -

323 - c2 := WithValue(c1, k2, "c2k2")

324 - check(c2, "c2", "c1k1", "c2k2", "")

325 -

326 - c3 := WithValue(c2, k3, "c3k3")

327 - check(c3, "c2", "c1k1", "c2k2", "c3k3")

328 -

329 - c4 := WithValue(c3, k1, nil)

330 - check(c4, "c4", "", "c2k2", "c3k3")

331 -

332 - o0 := otherContext{Background()}

333 - check(o0, "o0", "", "", "")

334 -

335 - o1 := otherContext{WithValue(Background(), k1, "c1k1")}

336 - check(o1, "o1", "c1k1", "", "")

337 -

338 - o2 := WithValue(o1, k2, "o2k2")

339 - check(o2, "o2", "c1k1", "o2k2", "")

340 -

341 - o3 := otherContext{c4}

342 - check(o3, "o3", "", "c2k2", "c3k3")

343 -

344 - o4 := WithValue(o3, k3, nil)

345 - check(o4, "o4", "", "c2k2", "")

346 -}

347 -

348 -func TestAllocs(t *testing.T) {

349 - bg := Background()

350 - for _, test := range []struct {

351 - desc string

352 - f func()

353 - limit float64

354 - gccgoLimit float64

355 - }{

356 - {

357 - desc: "Background()",

358 - f: func() { Background() },

359 - limit: 0,

360 - gccgoLimit: 0,

361 - },

362 - {

363 - desc: fmt.Sprintf("WithValue(bg, %v, nil)", k1),

364 - f: func() {

365 - c := WithValue(bg, k1, nil)

366 - c.Value(k1)

367 - },

368 - limit: 3,

369 - gccgoLimit: 3,

370 - },

371 - {

372 - desc: "WithTimeout(bg, 15*time.Millisecond)",

373 - f: func() {

374 - c, _ := WithTimeout(bg, 15*time.Millisecond)

375 - <-c.Done()

376 - },

377 - limit: 8,

378 - gccgoLimit: 13,

379 - },

380 - {

381 - desc: "WithCancel(bg)",

382 - f: func() {

383 - c, cancel := WithCancel(bg)

384 - cancel()

385 - <-c.Done()

386 - },

387 - limit: 5,

388 - gccgoLimit: 8,

389 - },

390 - {

391 - desc: "WithTimeout(bg, 100*time.Millisecond)",

392 - f: func() {

393 - c, cancel := WithTimeout(bg, 100*time.Millisecond)

394 - cancel()

395 - <-c.Done()

396 - },

397 - limit: 8,

398 - gccgoLimit: 25,

399 - },

400 - } {

401 - limit := test.limit

402 - if runtime.Compiler == "gccgo" {

403 - // gccgo does not yet do escape analysis.

404 - // TOOD(iant): Remove this when gccgo does do escape analysis.

405 - limit = test.gccgoLimit

406 - }

407 - if n := testing.AllocsPerRun(100, test.f); n > limit {

408 - t.Errorf("%s allocs = %f want %d", test.desc, n, int(limit))

409 - }

410 - }

411 -}

412 -

413 -func TestSimultaneousCancels(t *testing.T) {

414 - root, cancel := WithCancel(Background())

415 - m := map[Context]CancelFunc{root: cancel}

416 - q := []Context{root}

417 - // Create a tree of contexts.

418 - for len(q) != 0 && len(m) < 100 {

419 - parent := q[0]

420 - q = q[1:]

421 - for i := 0; i < 4; i++ {

422 - ctx, cancel := WithCancel(parent)

423 - m[ctx] = cancel

424 - q = append(q, ctx)

425 - }

426 - }

427 - // Start all the cancels in a random order.

428 - var wg sync.WaitGroup

429 - wg.Add(len(m))

430 - for _, cancel := range m {

431 - go func(cancel CancelFunc) {

432 - cancel()

433 - wg.Done()

434 - }(cancel)

435 - }

436 - // Wait on all the contexts in a random order.

437 - for ctx := range m {

438 - select {

439 - case <-ctx.Done():

440 - case <-time.After(1 * time.Second):

441 - buf := make([]byte, 10<<10)

442 - n := runtime.Stack(buf, true)

443 - t.Fatalf("timed out waiting for <-ctx.Done(); stacks:\n%s", buf[:n])

444 - }

445 - }

446 - // Wait for all the cancel functions to return.

447 - done := make(chan struct{})

448 - go func() {

449 - wg.Wait()

450 - close(done)

451 - }()

452 - select {

453 - case <-done:

454 - case <-time.After(1 * time.Second):

455 - buf := make([]byte, 10<<10)

456 - n := runtime.Stack(buf, true)

457 - t.Fatalf("timed out waiting for cancel functions; stacks:\n%s", buf[:n])

458 - }

459 -}

460 -

461 -func TestInterlockedCancels(t *testing.T) {

462 - parent, cancelParent := WithCancel(Background())

463 - child, cancelChild := WithCancel(parent)

464 - go func() {

465 - parent.Done()

466 - cancelChild()

467 - }()

468 - cancelParent()

469 - select {

470 - case <-child.Done():

471 - case <-time.After(1 * time.Second):

472 - buf := make([]byte, 10<<10)

473 - n := runtime.Stack(buf, true)

474 - t.Fatalf("timed out waiting for child.Done(); stacks:\n%s", buf[:n])

475 - }

476 -}

477 -

478 -func TestLayersCancel(t *testing.T) {

479 - testLayers(t, time.Now().UnixNano(), false)

480 -}

481 -

482 -func TestLayersTimeout(t *testing.T) {

483 - testLayers(t, time.Now().UnixNano(), true)

484 -}

485 -

486 -func testLayers(t *testing.T, seed int64, testTimeout bool) {

487 - rand.Seed(seed)

488 - errorf := func(format string, a ...interface{}) {

489 - t.Errorf(fmt.Sprintf("seed=%d: %s", seed, format), a...)

490 - }

491 - const (

492 - timeout = 200 * time.Millisecond

493 - minLayers = 30

494 - )

495 - type value int

496 - var (

497 - vals []*value

498 - cancels []CancelFunc

499 - numTimers int

500 - ctx = Background()

501 - )

502 - for i := 0; i < minLayers || numTimers == 0 || len(cancels) == 0 || len(vals) == 0; i++ {

503 - switch rand.Intn(3) {

504 - case 0:

505 - v := new(value)

506 - ctx = WithValue(ctx, v, v)

507 - vals = append(vals, v)

508 - case 1:

509 - var cancel CancelFunc

510 - ctx, cancel = WithCancel(ctx)

511 - cancels = append(cancels, cancel)

512 - case 2:

513 - var cancel CancelFunc

514 - ctx, cancel = WithTimeout(ctx, timeout)

515 - cancels = append(cancels, cancel)

516 - numTimers++

517 - }

518 - }

519 - checkValues := func(when string) {

520 - for _, key := range vals {

521 - if val := ctx.Value(key).(*value); key != val {

522 - errorf("%s: ctx.Value(%p) = %p want %p", when, key, val, key)

523 - }

524 - }

525 - }

526 - select {

527 - case <-ctx.Done():

528 - errorf("ctx should not be canceled yet")

529 - default:

530 - }

531 - if s, prefix := fmt.Sprint(ctx), "context.Background."; !strings.HasPrefix(s, prefix) {

532 - t.Errorf("ctx.String() = %q want prefix %q", s, prefix)

533 - }

534 - t.Log(ctx)

535 - checkValues("before cancel")

536 - if testTimeout {

537 - select {

538 - case <-ctx.Done():

539 - case <-time.After(timeout + timeout/10):

540 - errorf("ctx should have timed out")

541 - }

542 - checkValues("after timeout")

543 - } else {

544 - cancel := cancels[rand.Intn(len(cancels))]

545 - cancel()

546 - select {

547 - case <-ctx.Done():

548 - default:

549 - errorf("ctx should be canceled")

550 - }

551 - checkValues("after cancel")

552 - }

553 -}

554 -

555 -func TestCancelRemoves(t *testing.T) {

556 - checkChildren := func(when string, ctx Context, want int) {

557 - if got := len(ctx.(*cancelCtx).children); got != want {

558 - t.Errorf("%s: context has %d children, want %d", when, got, want)

559 - }

560 - }

561 -

562 - ctx, _ := WithCancel(Background())

563 - checkChildren("after creation", ctx, 0)

564 - _, cancel := WithCancel(ctx)

565 - checkChildren("with WithCancel child ", ctx, 1)

566 - cancel()

567 - checkChildren("after cancelling WithCancel child", ctx, 0)

568 -

569 - ctx, _ = WithCancel(Background())

570 - checkChildren("after creation", ctx, 0)

571 - _, cancel = WithTimeout(ctx, 60*time.Minute)

572 - checkChildren("with WithTimeout child ", ctx, 1)

573 - cancel()

574 - checkChildren("after cancelling WithTimeout child", ctx, 0)

575 -}

Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go deleted

-26

@@ -1,26 +0,0 @@

2 -// Use of this source code is governed by a BSD-style

3 -// license that can be found in the LICENSE file.

4 -

5 -package context_test

6 -

7 -import (

8 - "fmt"

9 - "time"

10 -

11 - "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"

12 -)

13 -

14 -func ExampleWithTimeout() {

15 - // Pass a context with a timeout to tell a blocking function that it

16 - // should abandon its work after the timeout elapses.

17 - ctx, _ := context.WithTimeout(context.Background(), 100*time.Millisecond)

18 - select {

19 - case <-time.After(200 * time.Millisecond):

20 - fmt.Println("overslept")

21 - case <-ctx.Done():

22 - fmt.Println(ctx.Err()) // prints "context deadline exceeded"

23 - }

24 - // Output:

25 - // context deadline exceeded

26 -}

package.json

@@ -11,6 +11,11 @@

11 "name": "go-libp2p",

12 "hash": "QmUBogf4nUefBjmYjn6jfsfPJRkmDGSeMhNj4usRKq69f4",

13 "version": "1.0.0"

14 + },

15 + {

16 + "name": "go-net",

17 + "hash": "QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt",

18 + "version": "0.0.0"

19 }

20 ],

21 "language": "go",