How to use PanicAfter method of got Package

1/*2 *3 * Copyright 2017 gRPC authors.4 *5 * Licensed under the Apache License, Version 2.0 (the "License");6 * you may not use this file except in compliance with the License.7 * You may obtain a copy of the License at8 *9 *     http://www.apache.org/licenses/LICENSE-2.010 *11 * Unless required by applicable law or agreed to in writing, software12 * distributed under the License is distributed on an "AS IS" BASIS,13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.14 * See the License for the specific language governing permissions and15 * limitations under the License.16 *17 */18package grpc19import (20	"context"21	"errors"22	"fmt"23	"net"24	"strings"25	"testing"26	"time"27	"google.golang.org/grpc/balancer"28	"google.golang.org/grpc/codes"29	"google.golang.org/grpc/resolver"30	"google.golang.org/grpc/resolver/manual"31	"google.golang.org/grpc/serviceconfig"32	"google.golang.org/grpc/status"33)34// The target string with unknown scheme should be kept unchanged and passed to35// the dialer.36func (s) TestDialParseTargetUnknownScheme(t *testing.T) {37	for _, test := range []struct {38		targetStr string39		want      string40	}{41		{"/unix/socket/address", "/unix/socket/address"},42		// Special test for "unix:///".43		{"unix:///unix/socket/address", "unix:///unix/socket/address"},44		// For known scheme.45		{"passthrough://a.server.com/google.com", "google.com"},46	} {47		dialStrCh := make(chan string, 1)48		cc, err := Dial(test.targetStr, WithInsecure(), WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {49			select {50			case dialStrCh <- addr:51			default:52			}53			return nil, fmt.Errorf("test dialer, always error")54		}))55		if err != nil {56			t.Fatalf("Failed to create ClientConn: %v", err)57		}58		got := <-dialStrCh59		cc.Close()60		if got != test.want {61			t.Errorf("Dial(%q), dialer got %q, want %q", test.targetStr, got, test.want)62		}63	}64}65func testResolverErrorPolling(t *testing.T, badUpdate func(*manual.Resolver), goodUpdate func(*manual.Resolver), dopts ...DialOption) {66	boIter := make(chan int)67	resolverBackoff := func(v int) time.Duration {68		boIter <- v69		return 070	}71	r, rcleanup := manual.GenerateAndRegisterManualResolver()72	defer rcleanup()73	rn := make(chan struct{})74	defer func() { close(rn) }()75	r.ResolveNowCallback = func(resolver.ResolveNowOptions) { rn <- struct{}{} }76	defaultDialOptions := []DialOption{77		WithInsecure(),78		withResolveNowBackoff(resolverBackoff),79	}80	cc, err := Dial(r.Scheme()+":///test.server", append(defaultDialOptions, dopts...)...)81	if err != nil {82		t.Fatalf("Dial(_, _) = _, %v; want _, nil", err)83	}84	defer cc.Close()85	badUpdate(r)86	panicAfter := time.AfterFunc(5*time.Second, func() { panic("timed out polling resolver") })87	defer panicAfter.Stop()88	// Ensure ResolveNow is called, then Backoff with the right parameter, several times89	for i := 0; i < 7; i++ {90		<-rn91		if v := <-boIter; v != i {92			t.Errorf("Backoff call %v uses value %v", i, v)93		}94	}95	// UpdateState will block if ResolveNow is being called (which blocks on96	// rn), so call it in a goroutine.97	goodUpdate(r)98	// Wait awhile to ensure ResolveNow and Backoff stop being called when the99	// state is OK (i.e. polling was cancelled).100	for {101		t := time.NewTimer(50 * time.Millisecond)102		select {103		case <-rn:104			// ClientConn is still calling ResolveNow105			<-boIter106			time.Sleep(5 * time.Millisecond)107			continue108		case <-t.C:109			// ClientConn stopped calling ResolveNow; success110		}111		break112	}113}114const happyBalancerName = "happy balancer"115func init() {116	// Register a balancer that never returns an error from117	// UpdateClientConnState, and doesn't do anything else either.118	fb := &funcBalancer{119		updateClientConnState: func(s balancer.ClientConnState) error {120			return nil121		},122	}123	balancer.Register(&funcBalancerBuilder{name: happyBalancerName, instance: fb})124}125// TestResolverErrorPolling injects resolver errors and verifies ResolveNow is126// called with the appropriate backoff strategy being consulted between127// ResolveNow calls.128func (s) TestResolverErrorPolling(t *testing.T) {129	testResolverErrorPolling(t, func(r *manual.Resolver) {130		r.CC.ReportError(errors.New("res err"))131	}, func(r *manual.Resolver) {132		// UpdateState will block if ResolveNow is being called (which blocks on133		// rn), so call it in a goroutine.134		go r.CC.UpdateState(resolver.State{})135	},136		WithDefaultServiceConfig(fmt.Sprintf(`{ "loadBalancingConfig": [{"%v": {}}] }`, happyBalancerName)))137}138// TestServiceConfigErrorPolling injects a service config error and verifies139// ResolveNow is called with the appropriate backoff strategy being consulted140// between ResolveNow calls.141func (s) TestServiceConfigErrorPolling(t *testing.T) {142	testResolverErrorPolling(t, func(r *manual.Resolver) {143		badsc := r.CC.ParseServiceConfig("bad config")144		r.UpdateState(resolver.State{ServiceConfig: badsc})145	}, func(r *manual.Resolver) {146		// UpdateState will block if ResolveNow is being called (which blocks on147		// rn), so call it in a goroutine.148		go r.CC.UpdateState(resolver.State{})149	},150		WithDefaultServiceConfig(fmt.Sprintf(`{ "loadBalancingConfig": [{"%v": {}}] }`, happyBalancerName)))151}152// TestResolverErrorInBuild makes the resolver.Builder call into the ClientConn153// during the Build call. We use two separate mutexes in the code which make154// sure there is no data race in this code path, and also that there is no155// deadlock.156func (s) TestResolverErrorInBuild(t *testing.T) {157	r, rcleanup := manual.GenerateAndRegisterManualResolver()158	defer rcleanup()159	r.InitialState(resolver.State{ServiceConfig: &serviceconfig.ParseResult{Err: errors.New("resolver build err")}})160	cc, err := Dial(r.Scheme()+":///test.server", WithInsecure())161	if err != nil {162		t.Fatalf("Dial(_, _) = _, %v; want _, nil", err)163	}164	defer cc.Close()165	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)166	defer cancel()167	var dummy int168	const wantMsg = "error parsing service config"169	const wantCode = codes.Unavailable170	if err := cc.Invoke(ctx, "/foo/bar", &dummy, &dummy); status.Code(err) != wantCode || !strings.Contains(status.Convert(err).Message(), wantMsg) {171		t.Fatalf("cc.Invoke(_, _, _, _) = %v; want status.Code()==%v, status.Message() contains %q", err, wantCode, wantMsg)172	}173}174func (s) TestServiceConfigErrorRPC(t *testing.T) {175	r, rcleanup := manual.GenerateAndRegisterManualResolver()176	defer rcleanup()177	cc, err := Dial(r.Scheme()+":///test.server", WithInsecure())178	if err != nil {179		t.Fatalf("Dial(_, _) = _, %v; want _, nil", err)180	}181	defer cc.Close()182	badsc := r.CC.ParseServiceConfig("bad config")183	r.UpdateState(resolver.State{ServiceConfig: badsc})184	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)185	defer cancel()186	var dummy int187	const wantMsg = "error parsing service config"188	const wantCode = codes.Unavailable189	if err := cc.Invoke(ctx, "/foo/bar", &dummy, &dummy); status.Code(err) != wantCode || !strings.Contains(status.Convert(err).Message(), wantMsg) {190		t.Fatalf("cc.Invoke(_, _, _, _) = %v; want status.Code()==%v, status.Message() contains %q", err, wantCode, wantMsg)191	}192}...

1import "got"2func main() {3got.PanicAfter(100)4}5import "got"6func main() {7got.PanicAfter(100)8}9./2.go:6: imported and not used: "got"10func main() {11  println(a)12}13func main() {14  println(a)15}16func main() {17  println(b)18}

1import "got"2func main() {3    got.PanicAfter(5)4}5func PanicAfter(n int) {6    for i := 0; i < n; i++ {7        println(i)8    }9    panic("Panic after " + n)10}11import "testing"12func TestPanicAfter(t *testing.T) {13    defer func() {14        if err := recover(); err != nil {15            t.Error(err)16        }17    }()18    PanicAfter(5)19}20import "testing"21func TestPanicAfter(t *testing.T) {22    defer func() {23        if err := recover(); err != nil {24            t.Error(err)25        }26    }()27    PanicAfter(5)28}29import (30func TestPanicAfter(t *testing.T) {31    assert.Panics(t, func() { PanicAfter(5) })32}

1import (2func main() {3	got := NewGot()4	got.PanicAfter(time.Second)5	fmt.Println("Hello, playground")6}7import (8func main() {9	got := NewGot()10	got.PanicAfter(time.Second)11	fmt.Println("Hello, playground")12}13import (14func main() {15	got := NewGot()16	got.PanicAfter(time.Second)17	fmt.Println("Hello, playground")18}19import (20func main() {21	got := NewGot()22	got.PanicAfter(time.Second)23	fmt.Println("Hello, playground")24}25import (26func main() {27	got := NewGot()28	got.PanicAfter(time.Second)29	fmt.Println("Hello, playground")30}31import (32func main() {33	got := NewGot()34	got.PanicAfter(time.Second)35	fmt.Println("Hello, playground")36}37import (38func main() {39	got := NewGot()40	got.PanicAfter(time.Second)41	fmt.Println("Hello, playground")42}43import (44func main() {45	got := NewGot()46	got.PanicAfter(time.Second)47	fmt.Println("Hello, playground")48}49import (50func main() {51	got := NewGot()52	got.PanicAfter(time.Second)53	fmt.Println("Hello, playground")54}

1import (2func main() {3	fmt.Println("Hello, playground")4	got := new(Got)5	got.PanicAfter()6}7import (8func main() {9	fmt.Println("Hello, playground")10	got := new(Got)11	got.PanicAfter()12}13import (14func main() {15	fmt.Println("Hello, playground")16	got := new(Got)17	got.PanicAfter()18}19import (20func main() {21	fmt.Println("Hello, playground")22	got := new(Got)23	got.PanicAfter()24}25import (26func main() {27	fmt.Println("Hello, playground")28	got := new(Got)29	got.PanicAfter()30}31import (32func main() {33	fmt.Println("Hello, playground")34	got := new(Got)35	got.PanicAfter()36}37import (38func main() {39	fmt.Println("Hello, playground")40	got := new(Got)41	got.PanicAfter()42}43import (44func main() {45	fmt.Println("Hello, playground")46	got := new(Got)47	got.PanicAfter()48}49import (50func main() {51	fmt.Println("Hello, playground")52	got := new(Got)53	got.PanicAfter()54}55import (56func main() {57	fmt.Println("Hello, playground")58	got := new(Got)

1import (2func main() {3    got := NewGot()4    got.PanicAfter(3 * time.Second)5    fmt.Println("Hello World")6}7import (8type Got struct {9}10func NewGot() *Got {11    return &Got{}12}13func (g *Got) PanicAfter(d time.Duration) {14    go func() {15        time.Sleep(d)16        panic(fmt.Sprintf("Panic after %s", d))17    }()18}19func (g *Got) PanicAfterFunc(d time.Duration, f func()) {20    time.AfterFunc(d, f)21}22import (23func TestGot_PanicAfter(t *testing.T) {24    got := NewGot()25    got.PanicAfter(3 * time.Second)26    time.Sleep(4 * time.Second)27    t.Log("Done")28}29func TestGot_PanicAfterFunc(t *testing.T) {30    got := NewGot()31    got.PanicAfterFunc(3*time.Second, func() {32        t.Log("Panic after 3 seconds")33    })34    time.Sleep(4 * time.Second)35    t.Log("Done")36}37--- FAIL: TestGot_PanicAfter (3.00s)38testing.tRunner.func1(0xc0000b0000)39panic(0x444a80, 0xc00000e0e0)40main.(*Got).PanicAfter(0xc0000a0000, 0x3b9aca00)41main.TestGot_PanicAfter(0xc0000b0000)

1import (2func main() {3	g.PanicAfter(2 * time.Second)4	fmt.Println("Hello World")5}6import (7type got struct{}8func (g *got) PanicAfter(d time.Duration) {9	go func() {10		time.Sleep(d)11		panic("timeout")12	}()13}14func main() {15	g.PanicAfter(2 * time.Second)16	fmt.Println("Hello World")17}

1import "fmt"2func main() {3    got.PanicAfter(10)4    fmt.Println("hello world")5}6main.main()7import "fmt"8func main() {9    got.PanicAfter(10, "Panic after 10 seconds")10    fmt.Println("hello world")11}12main.main()13import "fmt"14func main() {15    got.PanicAfter(10, "Panic after 10 seconds")16    fmt.Println("hello world")17}18main.main()19import "fmt"20func main() {21    got.PanicAfter(10, "Panic after 10 seconds")22    fmt.Println("hello world")23}24main.main()25import "fmt"26func main() {27    got.PanicAfter(10

1import (2func main() {3	got.PanicAfter(3, "I am panicking after 3 seconds")4	fmt.Println("Hello World")5}6main.main()7runtime.goexit()8github.com/pankajsoni19/got.PanicAfter.func1()9github.com/pankajsoni19/got.PanicAfter.func1()10github.com/pankajsoni19/got.PanicAfter.func1()11github.com/pankajsoni19/got.PanicAfter.func1()

1import (2func main() {3    g := got.NewGot()4    g.PanicAfter(5)5    g.Start()6    g.Wait(10)7    g.Stop()8}9import (10func main() {11    g := got.NewGot()12    g.PanicAfter(5)13    g.Start()14    g.Wait(10)15    g.Stop()16}17import (18func main() {19    g := got.NewGot()20    g.PanicAfter(5)21    g.Start()22    g.Wait(10)23    g.Stop()24}25import (26func main() {27    g := got.NewGot()28    g.PanicAfter(5)29    g.Start()30    g.Wait(10)31    g.Stop()32}33import (34func main() {