How to use Bar method of bugreport Package

1// Copyright 2020 The Fuchsia Authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4package main5import (6	"context"7	"fmt"8	"io"9	"strings"10	"testing"11	"go.fuchsia.dev/fuchsia/tools/build/lib"12	"go.fuchsia.dev/fuchsia/tools/integration/testsharder/lib"13	"go.fuchsia.dev/fuchsia/tools/net/sshutil"14	"go.fuchsia.dev/fuchsia/tools/testing/runtests"15	tap "go.fuchsia.dev/fuchsia/tools/testing/tap/lib"16	"go.fuchsia.dev/fuchsia/tools/testing/testrunner/lib"17)18const (19	testFunc         = "Test"20	copySinksFunc    = "CopySinks"21	runBugreportFunc = "RunBugreport"22)23type fakeTester struct {24	testErr   error25	runTest   func(testsharder.Test, io.Writer, io.Writer)26	funcCalls []string27}28func (t *fakeTester) Test(_ context.Context, test testsharder.Test, stdout, stderr io.Writer) (runtests.DataSinkReference, error) {29	t.funcCalls = append(t.funcCalls, testFunc)30	if t.runTest != nil {31		t.runTest(test, stdout, stderr)32	}33	return nil, t.testErr34}35func (t *fakeTester) Close() error {36	return nil37}38func (t *fakeTester) CopySinks(_ context.Context, _ []runtests.DataSinkReference) error {39	t.funcCalls = append(t.funcCalls, copySinksFunc)40	return nil41}42func (t *fakeTester) RunBugreport(_ context.Context, _ string) error {43	t.funcCalls = append(t.funcCalls, runBugreportFunc)44	return nil45}46func assertEqual(t1, t2 *testrunner.TestResult) bool {47	return (t1.Name == t2.Name &&48		t1.Result == t2.Result &&49		t1.RunIndex == t2.RunIndex &&50		string(t1.Stdio) == string(t2.Stdio))51}52func TestValidateTest(t *testing.T) {53	cases := []struct {54		name      string55		test      testsharder.Test56		expectErr bool57	}{58		{59			name: "missing name",60			test: testsharder.Test{61				Test: build.Test{62					OS:   "linux",63					Path: "/foo/bar",64				},65				Runs: 1,66			},67			expectErr: true,68		}, {69			name: "missing OS",70			test: testsharder.Test{71				Test: build.Test{72					Name: "test1",73					Path: "/foo/bar",74				},75				Runs: 1,76			},77			expectErr: true,78		}, {79			name: "spurious package URL",80			test: testsharder.Test{81				Test: build.Test{82					Name:       "test1",83					OS:         "linux",84					PackageURL: "fuchsia-pkg://test1",85				},86				Runs: 1,87			},88			expectErr: true,89		},90		{91			name: "missing required path",92			test: testsharder.Test{93				Test: build.Test{94					Name: "test1",95					OS:   "linux",96				},97				Runs: 1,98			},99			expectErr: true,100		},101		{102			name: "missing required package_url or path",103			test: testsharder.Test{104				Test: build.Test{105					Name: "test1",106					OS:   "fuchsia",107				},108				Runs: 1,109			},110			expectErr: true,111		}, {112			name: "missing runs",113			test: testsharder.Test{114				Test: build.Test{115					Name: "test1",116					OS:   "linux",117					Path: "/foo/bar",118				},119			},120			expectErr: true,121		}, {122			name: "valid test with path",123			test: testsharder.Test{124				Test: build.Test{125					Name: "test1",126					OS:   "linux",127					Path: "/foo/bar",128				},129				Runs: 1,130			},131			expectErr: false,132		}, {133			name: "valid test with packageurl",134			test: testsharder.Test{135				Test: build.Test{136					Name:       "test1",137					OS:         "fuchsia",138					PackageURL: "fuchsia-pkg://test1",139				},140				Runs: 5,141			},142			expectErr: false,143		},144	}145	for _, c := range cases {146		t.Run(c.name, func(t *testing.T) {147			err := validateTest(c.test)148			if c.expectErr != (err != nil) {149				t.Errorf("got error: %v, expectErr: %v", err, c.expectErr)150			}151		})152	}153}154func TestRunTest(t *testing.T) {155	cases := []struct {156		name           string157		test           build.Test158		runs           int159		testErr        error160		runTestFunc    func(testsharder.Test, io.Writer, io.Writer)161		expectedErr    error162		expectedResult []*testrunner.TestResult163	}{164		{165			name: "host test pass",166			test: build.Test{167				Name: "bar",168				Path: "/foo/bar",169				OS:   "linux",170			},171			testErr: nil,172			expectedResult: []*testrunner.TestResult{{173				Name:   "bar",174				Result: runtests.TestSuccess,175			}},176		},177		{178			name: "fuchsia test pass",179			test: build.Test{180				Name:       "bar",181				Path:       "/foo/bar",182				OS:         "fuchsia",183				PackageURL: "fuchsia-pkg://foo/bar",184			},185			testErr: nil,186			expectedResult: []*testrunner.TestResult{{187				Name:   "bar",188				Result: runtests.TestSuccess,189			}},190		},191		{192			name: "fuchsia test fail",193			test: build.Test{194				Name:       "bar",195				Path:       "/foo/bar",196				OS:         "fuchsia",197				PackageURL: "fuchsia-pkg://foo/bar",198			},199			testErr: fmt.Errorf("test failed"),200			expectedResult: []*testrunner.TestResult{{201				Name:   "bar",202				Result: runtests.TestFailure,203			}},204		},205		{206			name: "fuchsia test ssh connection fail",207			test: build.Test{208				Name:       "bar",209				Path:       "/foo/bar",210				OS:         "fuchsia",211				PackageURL: "fuchsia-pkg://foo/bar",212			},213			testErr:        sshutil.ConnectionError{},214			expectedErr:    sshutil.ConnectionError{},215			expectedResult: nil,216		},217		{218			name: "multiplier test gets unique index",219			test: build.Test{220				Name:       "bar (2)",221				Path:       "/foo/bar",222				OS:         "fuchsia",223				PackageURL: "fuchsia-pkg://foo/bar",224			},225			runs:    2,226			testErr: nil,227			expectedResult: []*testrunner.TestResult{{228				Name:   "bar (2)",229				Result: runtests.TestSuccess,230			}, {231				Name:     "bar (2)",232				Result:   runtests.TestSuccess,233				RunIndex: 1,234			}},235		}, {236			name: "combines stdio and stdout in chronological order",237			test: build.Test{238				Name:       "fuchsia-pkg://foo/bar",239				OS:         "fuchsia",240				PackageURL: "fuchsia-pkg://foo/bar",241			},242			expectedResult: []*testrunner.TestResult{{243				Name:   "fuchsia-pkg://foo/bar",244				Result: runtests.TestSuccess,245				Stdio:  []byte("stdout stderr stdout"),246			}},247			runTestFunc: func(t testsharder.Test, stdout, stderr io.Writer) {248				stdout.Write([]byte("stdout "))249				stderr.Write([]byte("stderr "))250				stdout.Write([]byte("stdout"))251			},252		},253	}254	for _, c := range cases {255		t.Run(c.name, func(t *testing.T) {256			tester := &fakeTester{257				testErr: c.testErr,258				runTest: c.runTestFunc,259			}260			if c.runs == 0 {261				c.runs = 1262			}263			for i := 0; i < c.runs; i++ {264				result, err := runTest(context.Background(), testsharder.Test{c.test, c.runs}, i, tester)265				if err != c.expectedErr {266					t.Errorf("got error: %v, expected: %v", err, c.expectedErr)267				}268				if err == nil {269					if !assertEqual(result, c.expectedResult[i]) {270						t.Errorf("got result: %v, expected: %v", result, c.expectedResult[i])271					}272				}273			}274		})275	}276}277func TestRunTests(t *testing.T) {278	tests := []testsharder.Test{279		{280			build.Test{281				Name:       "bar",282				OS:         "fuchsia",283				PackageURL: "fuchsia-pkg://foo/bar",284			}, 2,285		}, {286			build.Test{287				Name:       "baz",288				Path:       "/foo/baz",289				OS:         "fuchsia",290				PackageURL: "fuchsia-pkg://foo/baz",291			}, 1,292		},293	}294	tester := &fakeTester{}295	err := runTests(context.Background(), tests, tester, &testOutputs{tap: &tap.Producer{}})296	if err != nil {297		t.Errorf("got error: %v", err)298	}299	funcCalls := strings.Join(tester.funcCalls, ",")300	testCount := strings.Count(funcCalls, testFunc)301	copySinksCount := strings.Count(funcCalls, copySinksFunc)302	bugreportCount := strings.Count(funcCalls, runBugreportFunc)303	if testCount != 3 {304		t.Errorf("ran %d tests, expected: 3", testCount)305	}306	if copySinksCount != 1 {307		t.Errorf("ran CopySinks %d times, expected: 1", copySinksCount)308	}309	if bugreportCount != 1 {310		t.Errorf("ran RunBugreport %d times, expected: 1", bugreportCount)311	}312	// Ensure CopySinks and RunBugreport are run after all calls to Test.313	lastCalls := strings.Join(tester.funcCalls[len(tester.funcCalls)-2:], ",")314	if !strings.Contains(lastCalls, copySinksFunc) || !strings.Contains(lastCalls, runBugreportFunc) {315		t.Errorf("expected last calls to include %v, actual: %v", []string{runBugreportFunc, copySinksFunc}, lastCalls)316	}317}...

1package dagcmd2import (3	"errors"4	"fmt"5	"io"6	"os"7	"time"8	"github.com/cheggaaa/pb"9	cid "github.com/ipfs/go-cid"10	"github.com/ipfs/go-ipfs/core/commands/cmdenv"11	ipld "github.com/ipfs/go-ipld-format"12	mdag "github.com/ipfs/go-merkledag"13	cmds "github.com/ipfs/go-ipfs-cmds"14	gocar "github.com/ipld/go-car"15)16func dagExport(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {17	c, err := cid.Decode(req.Arguments[0])18	if err != nil {19		return fmt.Errorf(20			"unable to parse root specification (currently only bare CIDs are supported): %s",21			err,22		)23	}24	api, err := cmdenv.GetApi(env, req)25	if err != nil {26		return err27	}28	// Code disabled until descent-issue in go-ipld-prime is fixed29	// https://github.com/ribasushi/gip-muddle-up30	//31	// sb := gipselectorbuilder.NewSelectorSpecBuilder(gipfree.NodeBuilder())32	// car := gocar.NewSelectiveCar(33	// 	req.Context,34	// 	<needs to be fixed to take format.NodeGetter as well>,35	// 	[]gocar.Dag{gocar.Dag{36	// 		Root: c,37	// 		Selector: sb.ExploreRecursive(38	// 			gipselector.RecursionLimitNone(),39	// 			sb.ExploreAll(sb.ExploreRecursiveEdge()),40	// 		).Node(),41	// 	}},42	// )43	// ...44	// if err := car.Write(pipeW); err != nil {}45	pipeR, pipeW := io.Pipe()46	errCh := make(chan error, 2) // we only report the 1st error47	go func() {48		defer func() {49			if err := pipeW.Close(); err != nil {50				errCh <- fmt.Errorf("stream flush failed: %s", err)51			}52			close(errCh)53		}()54		if err := gocar.WriteCar(55			req.Context,56			mdag.NewSession(57				req.Context,58				api.Dag(),59			),60			[]cid.Cid{c},61			pipeW,62		); err != nil {63			errCh <- err64		}65	}()66	if err := res.Emit(pipeR); err != nil {67		pipeR.Close() // ignore the error if any68		return err69	}70	err = <-errCh71	// minimal user friendliness72	if err != nil &&73		err == ipld.ErrNotFound {74		explicitOffline, _ := req.Options["offline"].(bool)75		if explicitOffline {76			err = fmt.Errorf("%s (currently offline, perhaps retry without the offline flag)", err)77		} else {78			node, envErr := cmdenv.GetNode(env)79			if envErr == nil && !node.IsOnline {80				err = fmt.Errorf("%s (currently offline, perhaps retry after attaching to the network)", err)81			}82		}83	}84	return err85}86func finishCLIExport(res cmds.Response, re cmds.ResponseEmitter) error {87	var showProgress bool88	val, specified := res.Request().Options[progressOptionName]89	if !specified {90		// default based on TTY availability91		errStat, _ := os.Stderr.Stat()92		if 0 != (errStat.Mode() & os.ModeCharDevice) {93			showProgress = true94		}95	} else if val.(bool) {96		showProgress = true97	}98	// simple passthrough, no progress99	if !showProgress {100		return cmds.Copy(re, res)101	}102	bar := pb.New64(0).SetUnits(pb.U_BYTES)103	bar.Output = os.Stderr104	bar.ShowSpeed = true105	bar.ShowElapsedTime = true106	bar.RefreshRate = 500 * time.Millisecond107	bar.Start()108	var processedOneResponse bool109	for {110		v, err := res.Next()111		if err == io.EOF {112			// We only write the final bar update on success113			// On error it looks too weird114			bar.Finish()115			return re.Close()116		} else if err != nil {117			return re.CloseWithError(err)118		} else if processedOneResponse {119			return re.CloseWithError(errors.New("unexpected multipart response during emit, please file a bugreport"))120		}121		r, ok := v.(io.Reader)122		if !ok {123			// some sort of encoded response, this should not be happening124			return errors.New("unexpected non-stream passed to PostRun: please file a bugreport")125		}126		processedOneResponse = true127		if err := re.Emit(bar.NewProxyReader(r)); err != nil {128			return err129		}130	}131}...

1import "bugreport"2func main() {3    br.Bar()4}5import "bugreport"6func main() {7    br.Foo()8}9type BugReport struct {}10func (br *BugReport) Foo() {11}12func (br *BugReport) Bar() {13}14import "bugreport"15func main() {16    br.Bar()17}18import "bugreport"19func main() {20    br.Foo()21}22type BugReport struct {}23func (br *BugReport) Foo() {24}25func (br *BugReport) Bar() {26}

1import "fmt"2import "github.com/bugreport"3func main() {4    bugreport.Bar()5}6import "fmt"7import "github.com/bugreport"8func main() {9    bugreport.Foo()10}11import "fmt"12import "github.com/bugreport"13func main() {14    bugreport.Foo()15}

1import "bugreport"2func main() {3    bugreport.Bar()4}5import "fmt"6func Bar() {7    fmt.Println("Hello world")8}9import "testing"10func TestBug(t *testing.T) {11    Bar()12}

1import (2func main() {3	fmt.Println("Hello, playground")4	bugreport.Bar()5}6import "fmt"7func Bar() {8	fmt.Println("Bar")9}10import "fmt"11func Bar() {12	fmt.Println("Bar")13}14import "fmt"15func Bar() {16	fmt.Println("Bar")17}18import "fmt"19func Bar() {20	fmt.Println("Bar")21}22import "fmt"23func Bar() {24	fmt.Println("Bar")25}26import "fmt"27func Bar() {28	fmt.Println("Bar")29}30import "fmt"31func Bar() {32	fmt.Println("Bar")33}34import "fmt"35func Bar() {36	fmt.Println("Bar")37}38import "fmt"39func Bar() {40	fmt.Println("Bar")41}42import "fmt"43func Bar() {44	fmt.Println("Bar")45}46import "fmt"47func Bar() {48	fmt.Println("Bar")49}50import "fmt"51func Bar() {52	fmt.Println("Bar")53}54import "fmt"55func Bar() {56	fmt.Println("Bar")57}58import "fmt"59func Bar() {60	fmt.Println("Bar")61}62import "fmt"63func Bar() {64	fmt.Println("Bar")65}66import "fmt"67func Bar() {68	fmt.Println("Bar")69}70import "fmt"71func Bar() {72	fmt.Println("Bar")73}74import "fmt"75func Bar() {76	fmt.Println("Bar")77}78import "fmt"

1import (2func main() {3    bugreport.Bar()4    fmt.Println("Hello")5}6import (7func main() {8    bugreport.Foo()9    fmt.Println("Hello")10}11import (12func main() {13    bugreport.Foo()14    bugreport.Bar()15    fmt.Println("Hello")16}17import (18func main() {19    bugreport.Bar()20    bugreport.Foo()21    fmt.Println("Hello")22}23import (24func main() {25    bugreport.Bar()26    bugreport.Bar()27    bugreport.Foo()28    fmt.Println("Hello")29}30import (31func main() {32    bugreport.Foo()33    bugreport.Bar()34    bugreport.Bar()35    fmt.Println("Hello")36}37import (

1import "fmt"2import "bugreport"3func main() {4    b.Bar()5    fmt.Println("Hello, playground")6}7import "fmt"8import "bugreport"9func main() {10    b.Foo()11    fmt.Println("Hello, playground")12}13type BugReport struct {}14func (b *BugReport) Bar() {}15func (b *BugReport) Foo() {}16The -I flag is a shortcut for the -importpath flag. So, you can also run:17go run -importpath bugreport 1.go 2.go18The -I flag is a shortcut for the -importpath flag. So, you can also run:19go run -importpath bugreport 1.go 2.go20The -I flag is a shortcut for the -importpath flag. So, you can also run:21go run -importpath bugreport 1.go 2.go22The -I flag is a shortcut for the -importpath flag. So, you can also run:23go run -importpath bugreport 1.go 2.go24The -I flag is a shortcut for the -importpath flag. So, you can also run:25go run -importpath bugreport 1.go 2.go26The -I flag is a shortcut for the -importpath flag. So, you can also run:27go run -importpath bugreport 1

1import "fmt"2import "github.com/bugreport"3func main() {4    bugreport.Bar()5    fmt.Println("1.go")6}7import "fmt"8import "github.com/bugreport"9func main() {10    bugreport.Foo()11    fmt.Println("2.go")12}13import "fmt"14import "github.com/bugreport"15func main() {16    bugreport.Foo()17    fmt.Println("3.go")18}19import "fmt"20import "github.com/bugreport"21func main() {22    bugreport.Foo()23    fmt.Println("4.go")24}25import "fmt"26import "github.com/bugreport"27func main() {28    bugreport.Foo()29    fmt.Println("5.go")30}31import "fmt"32import "github.com/bugreport"33func main() {34    bugreport.Foo()35    fmt.Println("6.go")36}37import "fmt"38import "github.com/bugreport"39func main() {40    bugreport.Foo()41    fmt.Println("7.go")42}43import "fmt"44import "github.com/bugreport"45func main() {46    bugreport.Foo()47    fmt.Println("8.go")48}49import "fmt"50import "github.com/bugreport"51func main() {52    bugreport.Foo()53    fmt.Println("9.go")54}55import "fmt"56import "github.com/bugreport"57func main() {58    bugreport.Foo()59    fmt.Println("10.go")60}

1import (2func main() {3	bar := bugreport.Bar()4	fmt.Println(bar)5}6import (7func main() {8	foo := bugreport.Foo()9	fmt.Println(foo)10}