How to use mockName method of main Package

...5	"strconv"6	"strings"7)8// This generates some basic scaffold that looks like:9// type mockName struct {10//   ut.CallTracker11// }12// func NewmockName(t *testing.T) *mockName {13//   return &mockName{ut.NewCallRecords(t)}14// }15// func (m *mockName) AddCall(name string, params ...interface{}) ut.CallTracker {16//   m.CallTracker.AddCall(name, params)17//   return m18// }19// func (m *mockName) SetReturns(params ...interface{}) ut.CallTracker {20//   m.CallTracker.SetReturns(params)21//   return m22// }23func genBasicDecls(mockName string, methodNames []string) []ast.Decl {24	return []ast.Decl{25		&ast.GenDecl{26			Tok: token.TYPE,27			Specs: []ast.Spec{28				&ast.TypeSpec{29					Name: ast.NewIdent(mockName),30					Type: &ast.StructType{31						Fields: &ast.FieldList{32							List: []*ast.Field{{Type: &ast.SelectorExpr{X: ast.NewIdent("ut"), Sel: ast.NewIdent("CallTracker")}}},33						},34					},35				},36			},37		},38		&ast.FuncDecl{39			Name: ast.NewIdent(constructorName(mockName)),40			Type: &ast.FuncType{41				Params: &ast.FieldList{42					List: []*ast.Field{43						{44							Names: []*ast.Ident{ast.NewIdent("t")},45							Type: &ast.StarExpr{46								X: &ast.SelectorExpr{47									X:   ast.NewIdent("testing"),48									Sel: ast.NewIdent("T"),49								},50							},51						},52					},53				},54				Results: &ast.FieldList{55					List: []*ast.Field{56						{57							Type: &ast.StarExpr{58								X: ast.NewIdent(mockName),59							},60						},61					},62				},63			},64			Body: &ast.BlockStmt{65				List: []ast.Stmt{66					&ast.ReturnStmt{67						Results: []ast.Expr{68							&ast.UnaryExpr{69								Op: token.AND,70								X: &ast.CompositeLit{71									Type: ast.NewIdent(mockName),72									Elts: []ast.Expr{73										&ast.CallExpr{74											Fun: &ast.SelectorExpr{75												X:   ast.NewIdent("ut"),76												Sel: ast.NewIdent("NewCallRecords"),77											},78											Args: []ast.Expr{79												ast.NewIdent("t"),80											},81										},82									},83								},84							},85						},86					},87				},88			},89		},90		&ast.FuncDecl{91			Recv: &ast.FieldList{92				List: []*ast.Field{93					{94						Names: []*ast.Ident{95							ast.NewIdent("m"),96						},97						Type: &ast.StarExpr{98							X: ast.NewIdent(mockName),99						},100					},101				},102			},103			Name: ast.NewIdent("AddCall"),104			Type: &ast.FuncType{105				Params: &ast.FieldList{106					List: []*ast.Field{107						{108							Names: []*ast.Ident{109								ast.NewIdent("name"),110							},111							Type: ast.NewIdent("string"),112						},113						{114							Names: []*ast.Ident{115								ast.NewIdent("params"),116							},117							Type: &ast.Ellipsis{118								Elt: ast.NewIdent("interface{}"),119							},120						},121					},122				},123				Results: &ast.FieldList{124					List: []*ast.Field{125						{126							Type: &ast.SelectorExpr{127								X:   ast.NewIdent("ut"),128								Sel: ast.NewIdent("CallTracker"),129							},130						},131					},132				},133			},134			Body: &ast.BlockStmt{135				List: []ast.Stmt{136					&ast.SwitchStmt{137						Tag: &ast.Ident{138							Name: "name",139						},140						Body: &ast.BlockStmt{141							List: []ast.Stmt{142								&ast.CaseClause{143									List: stringLiteralList(methodNames),144									Body: []ast.Stmt{145										&ast.BranchStmt{146											Tok: token.BREAK,147										},148									},149								},150								&ast.CaseClause{151									List: nil, // Default case.152									Body: []ast.Stmt{153										&ast.ExprStmt{154											X: &ast.CallExpr{155												Fun: &ast.Ident{Name: "panic"},156												Args: []ast.Expr{157													&ast.CallExpr{158														Fun: &ast.SelectorExpr{159															X:   &ast.Ident{Name: "fmt"},160															Sel: &ast.Ident{Name: "Errorf"},161														},162														Args: []ast.Expr{163															&ast.BasicLit{164																Kind:  token.STRING,165																Value: strconv.Quote("AddCall: %T has no method %s"),166															},167															&ast.Ident{Name: "m"},168															&ast.Ident{Name: "name"},169														},170													},171												},172											},173										},174									},175								},176							},177						},178					},179					&ast.ExprStmt{180						X: &ast.CallExpr{181							Fun: &ast.SelectorExpr{182								X: &ast.SelectorExpr{183									X:   ast.NewIdent("m"),184									Sel: ast.NewIdent("CallTracker"),185								},186								Sel: ast.NewIdent("AddCall"),187							},188							Args: []ast.Expr{189								ast.NewIdent("name"),190								ast.NewIdent("params..."),191							},192						},193					},194					&ast.ReturnStmt{195						Results: []ast.Expr{196							ast.NewIdent("m"),197						},198					},199				},200			},201		},202		&ast.FuncDecl{203			Recv: &ast.FieldList{204				List: []*ast.Field{205					{206						Names: []*ast.Ident{207							ast.NewIdent("m"),208						},209						Type: &ast.StarExpr{210							X: ast.NewIdent(mockName),211						},212					},213				},214			},215			Name: ast.NewIdent("SetReturns"),216			Type: &ast.FuncType{217				Params: &ast.FieldList{218					List: []*ast.Field{219						{220							Names: []*ast.Ident{221								ast.NewIdent("params"),222							},223							Type: &ast.Ellipsis{224								Elt: ast.NewIdent("interface{}"),...

...30}31func isContentValid(content string) bool {32	return (strings.Contains(content, "Applied Biosystems 7300 Real-Time PCR System") && strings.Contains(content, "SDS v1.4"))33}34func (e *Experiment) computeTargetGenes(mockName string) {35	endoControlMock := e.EndogenousControls[mockName]36	e.computeMocks(mockName, endoControlMock)37	for detectorName, detector := range e.Detectors {38		for targetGeneName, targetGene := range detector {39			if targetGeneName != mockName {40				targetGeneMock := e.Detectors[detectorName][mockName]41				targetGene.mergeRawValues()42				targetGene.Mean, targetGene.StdDev = meanAndStdDev(targetGene.Values)43				targetGene.DCt = targetGene.Mean - endoControlMock.Mean44				targetGene.DdCt = targetGene.DCt - targetGeneMock.DCt45				targetGene.DdCtErr = math.Sqrt((2 * (endoControlMock.StdDev * endoControlMock.StdDev)) + (2 * (targetGene.StdDev * targetGene.StdDev)))46				targetGene.RQ = math.Pow(2, (-1) * targetGene.DdCt)47				targetGene.RQErr = math.Sqrt(targetGene.RQ * targetGene.RQ * math.Ln2 * math.Ln2 * targetGene.DdCtErr * targetGene.DdCtErr)48				e.Detectors[detectorName][targetGeneName] = targetGene49			}50		}51	}52}53func (e *Experiment) computeMocks(mockName string, endoControlMock EndoTargetGene) {54	for detectorName, detector := range e.Detectors {55		if _, found := detector[mockName]; found == true {56			targetGene := detector[mockName]57			targetGene.mergeRawValues()58			targetGene.Mean, targetGene.StdDev = meanAndStdDev(targetGene.Values)59			targetGene.DCt = targetGene.Mean - endoControlMock.Mean60			targetGene.DdCt = 0.061			targetGene.DdCtErr = math.Sqrt((2 * (endoControlMock.StdDev * endoControlMock.StdDev)) + (2 * (targetGene.StdDev * targetGene.StdDev)))62			targetGene.RQ = 1.063			targetGene.RQErr = math.Sqrt(math.Ln2 * math.Ln2)64			e.Detectors[detectorName][mockName] = targetGene65		} else {66			log.Printf("[ab7300] mock for detector '%s' not found!\n", detectorName)67		}68	}69}70func (e *Experiment) parseRow(line *string) {71	rowValues := strings.Split(*line, ",")72	if len(rowValues) == 22 {73		name, detector, task, value := rowValues[3], rowValues[4], rowValues[5], rowValues[6]74		switch task {75		case "ENDO":76			e.addEndogenousControlTargetGeneValue(name, detector, value)77		case "Target":78			e.addDetectorTargetGeneValue(name, detector, value)...

...28		return nil, err29	} else {30		mockDecls := make([]*gen.MockDecl, len(mocks)-offset)31		for i := offset; i < len(mocks); i++ {32			mockName := gen.GetMockName(mocks[i])33			if typeObj := pkg.Types.Scope().Lookup(mockName.TypeName()); typeObj == nil {34				return nil, fmt.Errorf("type %s is not found in %s", mockName.TypeName(), wd)35			} else if structType, ok := typeObj.Type().Underlying().(*types.Struct); !ok {36				return nil, fmt.Errorf("type %s is not a struct", mockName.TypeName())37			} else {38				fields := make([]*gen.FieldDecl, 0)39				for j := 0; j < structType.NumFields(); j++ {40					field := structType.Field(j)41					// TODO: maybe in the future process recursively42					if field.Embedded() {43						continue44					}45					fields = append(fields, gen.NewFieldDecl(46						field.Name(),47						loader.GetTypeDeclaration(field.Type()),48					))49				}50				mockDecls[i-offset] = gen.NewMockDecl(51					mockName,52					fields,53				)54			}55		}56		if file, err := gen.GenerateMocks(wd, pkg.Name, mockDecls); err != nil {57			return nil, err58		} else {59			res := &execResult{60				file:    file,61				pkgName: pkg.Name,62			}63			return res, nil64		}65	}...

...11		When:  "both data are valid",12		Then:  "return get name",13	}.Construct(), func(t *testing.T) {14		mockPerson := personMocks.NewMockClient(gomock.NewController(t))15		mockName := "John Doe"16		mockPerson.EXPECT().SetName(mockName).Return()17		mockPerson.EXPECT().GetName().Return(mockName)18		actual := Do(mockPerson, mockName)19		expected := "John Doe"20		tt.Equal(t, expected, actual)21	})22}...

1import (2func TestMockName(t *testing.T) {3    name := mockName()4    if name != "mock" {5        t.Errorf("mockName() = %s; want mock", name)6    }7}8import (9func main() {10    fmt.Println(mockName())11}12func mockName() string {13}

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

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

1import "testing"2func TestMockName(t *testing.T) {3	mockName := mockName()4	if mockName != "mock" {5		t.Error("Expected mock, got ", mockName)6	}7}8--- PASS: TestMockName (0.00s)

1import (2func TestMockName(t *testing.T) {3    mock := MockEmployee{mockName, mockAge, mockSalary, mockAddress}4    assert.Equal(t, mockName, mock.Name(), "They should be equal")5}6import (7func TestMockAge(t *testing.T) {8    mock := MockEmployee{mockName, mockAge, mockSalary, mockAddress}9    assert.Equal(t, mockAge, mock.Age(), "They should be equal")10}11import (12func TestMockSalary(t *testing.T) {13    mock := MockEmployee{mockName, mockAge, mockSalary, mockAddress}14    assert.Equal(t, mockSalary, mock.Salary(), "They should be equal")15}16import (17func TestMockAddress(t *testing.T) {18    mock := MockEmployee{mockName, mockAge, mockSalary, mockAddress}19    assert.Equal(t, mockAddress, mock.Address(), "They should be equal")20}21--- PASS: TestMockName (0.00s)

1import (2func TestMockName(t *testing.T) {3    var actual string = mockName()4    if expected != actual {5        t.Errorf("Expected %s, but got %s", expected, actual)6    }7}8func mockName() string {9}10import (11func TestMockName(t *testing.T) {12    var actual string = mockName()13    if expected != actual {14        t.Errorf("Expected %s, but got %s", expected, actual)15    }16}17func mockName() string {18}19import (20func main() {21    file, err := os.Open("test.txt")22    if err != nil {23        fmt.Println("Error:", err)24    }25    defer file.Close()26    newFile, err := os.Create("newTest.txt")27    if err != nil {28        fmt.Println("Error:", err)29    }30    defer newFile.Close()31    bytes, err := io.Copy(newFile, file)32    if err != nil {33        fmt.Println("Error:", err)34    }35    fmt.Println("Copied", bytes, "bytes.")36}37import (38func main() {39    file, err := os.Open("

1import (2func main() {3	fmt.Println(main.mockName())4}5func mockName() string {6}

1import (2func TestMockName(t *testing.T) {3	mockName := mocking.MockName{}4	mockName.Mock(mocking.NameMock{5	})6	if mockName.Name() != "Jon Snow" {7		t.Errorf("Name() = %v; want Jon Snow", mockName.Name())8	}9}10import (11func TestMockName(t *testing.T) {12	mockName := mocking.MockName{}13	mockName.Mock(mocking.NameMock{14	})15	if mockName.Name() != "John Snow" {16		t.Errorf("Name() = %v; want John Snow", mockName.Name())17	}18}19import (20func TestMockName(t *testing.T) {21	mockName := mocking.MockName{}22	mockName.Mock(mocking.NameMock{23	})24	if mockName.Name() != "Jon Snow" {25		t.Errorf("Name() = %v; want Jon Snow", mockName.Name())26	}27}28import (29func TestMockName(t *testing.T) {30	mockName := mocking.MockName{}31	mockName.Mock(mocking.NameMock{32	})33	if mockName.Name() != "John Snow" {34		t.Errorf("Name() = %v; want John Snow", mockName.Name())35	}36}37import (38func TestMockName(t *testing.T) {39	mockName := mocking.MockName{}40	mockName.Mock(mocking.NameMock{

1import (2func main() {3	fmt.Println(reflect.TypeOf(m))4	fmt.Println(m.mockName())5}6import (7func main() {8	fmt.Println(reflect.TypeOf(m))9	fmt.Println(m.mockName())10}11import (12func main() {13	fmt.Println(reflect.TypeOf(m))14	fmt.Println(m.mockName())15}16import (17func main() {18	fmt.Println(reflect.TypeOf(m))19	fmt.Println(m.mockName())20}21import (22func main() {23	fmt.Println(reflect.TypeOf(m))24	fmt.Println(m.mockName())25}26import (27func main() {28	fmt.Println(reflect.TypeOf(m))29	fmt.Println(m.mockName())30}31import (32func main() {33	fmt.Println(reflect.TypeOf(m))34	fmt.Println(m

1import "testing"2import "fmt"3func TestMyMethod(t *testing.T) {4    fmt.Println("Testing")5    main := new(Main)6    main.mockName()7    if main.Name != "Mock" {8        t.Error("Expected Mock, got ", main.Name)9    }10}11import "testing"12import "fmt"13func TestMyMethod(t *testing.T) {14    fmt.Println("Testing")15    main := new(Main)16    main.mockName()17    if main.Name != "Mock" {18        t.Error("Expected Mock, got ", main.Name)19    }20}21func TestMyMethod1(t *testing.T) {22    fmt.Println("Testing")23    main := new(Main)24    main.mockName()25    if main.Name != "Mock" {26        t.Error("Expected Mock, got ", main.Name)27    }28}29func TestMyMethod2(t *testing.T) {30    fmt.Println("Testing")31    main := new(Main)32    main.mockName()33    if main.Name != "Mock" {34        t.Error("Expected Mock, got ", main.Name)35    }36}