How to use reportEach method of internal Package

...1450							if err != nil {1451								c.JSON(http.StatusOK, restful.Fail("run failure", err))1452								return1453							}1454							reportEach := "{}"1455							reportEach, _ = sjson.Set(reportEach, "expected", callRet)1456							reportEach, _ = sjson.Set(reportEach, "actual", runRet)1457							reportEach, _ = sjson.Set(reportEach, "result", runRet.EqualValue(callRet))1458							problemReport, _ = sjson.SetRaw(problemReport, "cases.-1", reportEach)1459						}1460						// 채점 완료1461						report, _ = sjson.SetRaw(report, fmt.Sprintf("%s.%s", problemCode, student), problemReport)1462					case "short":1463						report, _ = sjson.Set(report, fmt.Sprintf("%s.%s", problemCode, student), nil)1464					case "multiple":1465						report, _ = sjson.Set(report, fmt.Sprintf("%s.%s", problemCode, student), nil)1466					}1467				} else {1468					c.JSON(http.StatusOK, restful.Fail("handscore fail to scan", err))1469					return1470				}1471			}1472		}1473		//1474		c.JSON(http.StatusOK, restful.Success(json.RawMessage(report)))1475	})1476	apisvr.GET("/assignment/:assignment_code/submission/:problem_code/read/:user_code", func(c *gin.Context) {1477		var (1478			param restful.APIReadSubmission1479			err   error1480		)1481		if err = c.ShouldBindUri(&param); err != nil {1482			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1483			return1484		}1485		row := db.QueryRow(`SELECT path, language FROM assignment_submission WHERE assignment_code=? and problem_code=? and user_code=?`, param.Assignment, param.Problem, param.User)1486		var (1487			pathFile string1488			lang     string1489		)1490		if err = row.Scan(&pathFile, &lang); err != nil {1491			c.JSON(http.StatusOK, restful.Fail("query fail", err))1492			return1493		}1494		data, err := ioutil.ReadFile(pathFile)1495		if err != nil {1496			c.JSON(http.StatusOK, restful.Fail("file error", err))1497			return1498		}1499		result := "{}"1500		result, _ = sjson.Set(result, "data", string(data))1501		result, _ = sjson.Set(result, "language", lang)1502		c.JSON(http.StatusOK, restful.Success(json.RawMessage(result)))1503	})1504	apisvr.PUT("/assignment/:assignment_code/submission/:problem_code/manual-score/:user_code", func(c *gin.Context) {1505		var (1506			param restful.APIEditScore1507			err   error1508		)1509		c.ShouldBindUri(&param)1510		if err = c.ShouldBind(&param); err != nil {1511			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1512			return1513		}1514		_, err = db.Exec(`INSERT INTO handscore VALUES(?, ?, ?, ?) ON DUPLICATE KEY UPDATE score=?`, param.Assignment, param.Problem, param.User, param.Score, param.Score)1515		if err != nil {1516			c.JSON(http.StatusOK, restful.Fail("db update fail", err))1517			return1518		}1519		c.JSON(http.StatusOK, restful.Success(nil))1520	})1521	//1522	apisvr.POST("/problem", levelAboveEqual(2), func(c *gin.Context) {1523		var (1524			param restful.APICreateProblem1525			err   error1526		)1527		if err = c.ShouldBind(&param); err != nil {1528			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1529			return1530		}1531		var (1532			nextCodeNumber int1533			nextCode       string1534		)1535		if err = db.QueryRow(`1536		SELECT max(CAST(TRIM(LEADING 'P' FROM code) AS INTEGER )) + 11537		FROM problem1538		`).Scan(&nextCodeNumber); err != nil {1539			panic(err)1540		}1541		nextCode = fmt.Sprintf("P%09d", nextCodeNumber)1542		// 문제 생성1543		_, err = db.Exec(1544			`1545		INSERT1546		INTO problem1547		VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)`,1548			nextCode,1549			param.Name,1550			param.Description,1551			param.Restriction,1552			param.Entry,1553			param.Parameters,1554			param.Return,1555			param.Type,1556			param.ParameterNames,1557		)1558		if err != nil {1559			c.JSON(http.StatusOK, restful.Fail("DB Insert fail", err))1560			return1561		}1562		c.JSON(http.StatusOK, restful.Success(nextCode))1563	})1564	apisvr.PUT("/problem/:problem_code", func(c *gin.Context) {1565		var (1566			param restful.APIEditProblem1567			err   error1568		)1569		c.ShouldBindUri(&param)1570		if err = c.ShouldBind(&param); err != nil {1571			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1572			return1573		}1574		// 문제 생성1575		_, err = db.Exec(1576			`1577		UPDATE problem p SET p.name=?, p.description=?, p.type=?, p.restriction=?, p.entry=?, p.parameters=?, p.return=? WHERE code=?`,1578			param.Name,1579			param.Description,1580			param.Type,1581			param.Restriction,1582			param.Entry,1583			param.Parameters,1584			param.Return,1585			param.Code,1586		)1587		if err != nil {1588			c.JSON(http.StatusOK, restful.Fail("DB Insert fail", err))1589			return1590		}1591		c.JSON(http.StatusOK, restful.Success(nil))1592	})1593	apisvr.DELETE("/problem/:problem_code", func(c *gin.Context) {1594		var (1595			param restful.APIDeleteProblem1596			err   error1597		)1598		//1599		if err = c.ShouldBindUri(&param); err != nil {1600			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1601			return1602		}1603		_, err = db.Exec(`DELETE FROM handscore WHERE problem_code=?`, param.Code)1604		if err != nil {1605			c.JSON(http.StatusOK, restful.Fail("delete fail", err))1606			return1607		}1608		_, err = db.Exec(`DELETE FROM package_content WHERE problem_code=?`, param.Code)1609		if err != nil {1610			c.JSON(http.StatusOK, restful.Fail("delete fail", err))1611			return1612		}1613		_, err = db.Exec(`DELETE FROM problem WHERE code=?`, param.Code)1614		if err != nil {1615			c.JSON(http.StatusOK, restful.Fail("delete fail", err))1616			return1617		}1618		c.JSON(http.StatusOK, restful.Success(nil))1619	})1620	apisvr.GET("/problem/:problem_code/signature/:language", func(c *gin.Context) {1621		var (1622			param restful.APISignatureProblem1623			err   error1624			row   *sql.Row1625		)1626		var (1627			entry         string1628			rawParams     string1629			rawRet        string1630			rawParamNames string1631			params        []coding.Type1632			ret           coding.Type1633			lang          coding.Language1634			paramNames    []string1635		)1636		if err = c.ShouldBindUri(&param); err != nil {1637			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1638			return1639		}1640		if row = db.QueryRow("SELECT p.entry, p.parameters, p.return, p.parameterNames FROM problem p WHERE p.code = ?", param.ProblemCode); row.Err() != nil {1641			c.JSON(http.StatusOK, restful.Fail("fail to problem", row.Err()))1642			return1643		}1644		if err = row.Scan(&entry, &rawParams, &rawRet, &rawParamNames); err != nil {1645			panic(err)1646		}1647		//1648		lang = coding.LoadLang(param.Language)1649		params = coding.ParseTypes(splitArr(rawParams)...)1650		ret = coding.ParseType(gjson.Parse(rawRet).String())1651		paramNames = splitArr(rawParamNames)1652		if lang == nil {1653			c.JSON(http.StatusOK, restful.Fail("no language", nil))1654			return1655		}1656		//1657		c.JSON(http.StatusOK, restful.Success(lang.Signature(entry, params, ret, paramNames)))1658	})1659	apisvr.POST("/problem/:problem_code/solve/:language", func(c *gin.Context) {1660		var (1661			param restful.APISolveProblem1662			err   error1663			row   *sql.Row1664		)1665		var (1666			entry     string1667			rawParams string1668			rawRet    string1669			params    []coding.Type1670			ret       coding.Type1671			lang      coding.Language1672		)1673		c.ShouldBindUri(&param)1674		if err = c.ShouldBind(&param); err != nil {1675			c.JSON(http.StatusOK, restful.Fail("invalid parameter", err))1676			return1677		}1678		if row = db.QueryRow("SELECT p.entry, p.parameters, p.return FROM problem p WHERE p.code = ?", param.ProblemCode); row.Err() != nil {1679			c.JSON(http.StatusOK, restful.Fail("fail to problem", row.Err()))1680			return1681		}1682		//1683		if err = row.Scan(&entry, &rawParams, &rawRet); err != nil {1684			panic(err)1685		}1686		//1687		lang = coding.LoadLang(param.Language)1688		params = coding.ParseTypes(splitArr(rawParams)...)1689		ret = coding.ParseType(gjson.Parse(rawRet).String())1690		if lang == nil {1691			c.JSON(http.StatusOK, restful.Fail("no language", nil))1692			return1693		}1694		//1695		var (1696			f    multipart.File1697			inst coding.Instance1698		)1699		f, err = param.Source.Open()1700		if err != nil {1701			c.JSON(http.StatusOK, restful.Fail("unexpected error", err))1702			return1703		}1704		defer f.Close()1705		inst, err = lang.Build(f, entry, params, ret)1706		if err != nil {1707			c.JSON(http.StatusOK, restful.Fail("unexpected error", err))1708			return1709		}1710		defer inst.Close()1711		//1712		idx, _ := restful.ParseIndexing("~")1713		ios := gjson.ParseBytes(selectIORange(param.ProblemCode, idx[0], idx[1]))1714		length := ios.Get("#").Int()1715		//1716		report := "{}"1717		total := true1718		for i := int64(0); i < length; i++ {1719			tmp := ios.Get(strconv.FormatInt(i, 10))1720			callParams := coding.ParseValues(params, splitArr(tmp.Get("input").String())...)1721			callRet := coding.ParseValue(ret, tmp.Get("output").String())1722			runRet, err := inst.Run(callParams)1723			if err != nil {1724				c.JSON(http.StatusOK, restful.Fail("run failure", err))1725				return1726			}1727			reportEach := "{}"1728			reportEach, _ = sjson.Set(reportEach, "expected", callRet)1729			reportEach, _ = sjson.Set(reportEach, "actual", runRet)1730			if runRet == nil {1731				reportEach, _ = sjson.Set(reportEach, "result", false)1732				total = false1733			} else {1734				reportEach, _ = sjson.Set(reportEach, "result", runRet.EqualValue(callRet))1735				total = total && runRet.EqualValue(callRet)1736			}1737			report, _ = sjson.SetRaw(report, "cases.-1", reportEach)1738		}1739		report, _ = sjson.Set(report, "total", total)1740		c.JSON(http.StatusOK, restful.Success(json.RawMessage(report)))1741	})1742	apisvr.GET("/problem", func(c *gin.Context) {1743		var (1744			rows *sql.Rows1745			err  error1746		)1747		var (1748			result = "[]"1749		)1750		rows, err = db.Query("SELECT p.code, p.name, p.description, p.restriction, p.entry, p.parameters,p.parameterNames, p.return, p.type FROM problem p")1751		if err != nil {...

...251	for _, spec := range g.specs {252		g.suite.currentSpecReport = g.initialReportForSpec(spec)253		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.evaluateSkipStatus(spec)254		g.suite.reporter.WillRun(g.suite.currentSpecReport)255		g.suite.reportEach(spec, types.NodeTypeReportBeforeEach)256		skip := g.suite.config.DryRun || g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates|types.SpecStateSkipped|types.SpecStatePending)257		g.suite.currentSpecReport.StartTime = time.Now()258		if !skip {259			maxAttempts := max(1, spec.FlakeAttempts())260			if g.suite.config.FlakeAttempts > 0 {261				maxAttempts = g.suite.config.FlakeAttempts262			}263			for attempt := 0; attempt < maxAttempts; attempt++ {264				g.suite.currentSpecReport.NumAttempts = attempt + 1265				g.suite.writer.Truncate()266				g.suite.outputInterceptor.StartInterceptingOutput()267				if attempt > 0 {268					fmt.Fprintf(g.suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)269				}270				g.attemptSpec(attempt == maxAttempts-1, spec)271				g.suite.currentSpecReport.EndTime = time.Now()272				g.suite.currentSpecReport.RunTime = g.suite.currentSpecReport.EndTime.Sub(g.suite.currentSpecReport.StartTime)273				g.suite.currentSpecReport.CapturedGinkgoWriterOutput += string(g.suite.writer.Bytes())274				g.suite.currentSpecReport.CapturedStdOutErr += g.suite.outputInterceptor.StopInterceptingAndReturnOutput()275				if g.suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {276					break277				}278			}279		}280		g.suite.reportEach(spec, types.NodeTypeReportAfterEach)281		g.suite.processCurrentSpecReport()282		if g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {283			g.succeeded = false284		}285		g.suite.currentSpecReport = types.SpecReport{}286	}287}288func (g *group) oldRun(specs Specs) {289	var suite = g.suite290	nodeState := map[uint]types.SpecState{}291	groupSucceeded := true292	indexOfLastSpecContainingNodeID := func(id uint) int {293		lastIdx := -1294		for idx := range specs {295			if specs[idx].Nodes.ContainsNodeID(id) && !specs[idx].Skip {296				lastIdx = idx297			}298		}299		return lastIdx300	}301	for i, spec := range specs {302		suite.currentSpecReport = types.SpecReport{303			ContainerHierarchyTexts:     spec.Nodes.WithType(types.NodeTypeContainer).Texts(),304			ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),305			ContainerHierarchyLabels:    spec.Nodes.WithType(types.NodeTypeContainer).Labels(),306			LeafNodeLocation:            spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,307			LeafNodeType:                types.NodeTypeIt,308			LeafNodeText:                spec.FirstNodeWithType(types.NodeTypeIt).Text,309			LeafNodeLabels:              []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),310			ParallelProcess:             suite.config.ParallelProcess,311			IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),312			IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),313		}314		skip := spec.Skip315		if spec.Nodes.HasNodeMarkedPending() {316			skip = true317			suite.currentSpecReport.State = types.SpecStatePending318		} else {319			if suite.interruptHandler.Status().Interrupted || suite.skipAll {320				skip = true321			}322			if !groupSucceeded {323				skip = true324				suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),325					"Spec skipped because an earlier spec in an ordered container failed")326			}327			for _, node := range spec.Nodes.WithType(types.NodeTypeBeforeAll) {328				if nodeState[node.ID] == types.SpecStateSkipped {329					skip = true330					suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),331						"Spec skipped because Skip() was called in BeforeAll")332					break333				}334			}335			if skip {336				suite.currentSpecReport.State = types.SpecStateSkipped337			}338		}339		if suite.config.DryRun && !skip {340			skip = true341			suite.currentSpecReport.State = types.SpecStatePassed342		}343		suite.reporter.WillRun(suite.currentSpecReport)344		//send the spec report to any attached ReportBeforeEach blocks - this will update suite.currentSpecReport if failures occur in these blocks345		suite.reportEach(spec, types.NodeTypeReportBeforeEach)346		if suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {347			//the reportEach failed, skip this spec348			skip = true349		}350		suite.currentSpecReport.StartTime = time.Now()351		maxAttempts := max(1, spec.FlakeAttempts())352		if suite.config.FlakeAttempts > 0 {353			maxAttempts = suite.config.FlakeAttempts354		}355		for attempt := 0; !skip && (attempt < maxAttempts); attempt++ {356			suite.currentSpecReport.NumAttempts = attempt + 1357			suite.writer.Truncate()358			suite.outputInterceptor.StartInterceptingOutput()359			if attempt > 0 {360				fmt.Fprintf(suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)361			}362			isFinalAttempt := (attempt == maxAttempts-1)363			interruptStatus := suite.interruptHandler.Status()364			deepestNestingLevelAttained := -1365			var nodes = spec.Nodes.WithType(types.NodeTypeBeforeAll).Filter(func(n Node) bool {366				return nodeState[n.ID] != types.SpecStatePassed367			})368			nodes = nodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeBeforeEach)...).SortedByAscendingNestingLevel()369			nodes = nodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeJustBeforeEach).SortedByAscendingNestingLevel()...)370			nodes = nodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeIt)...)371			var terminatingNode Node372			for j := range nodes {373				deepestNestingLevelAttained = max(deepestNestingLevelAttained, nodes[j].NestingLevel)374				suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(nodes[j], interruptStatus.Channel, spec.Nodes.BestTextFor(nodes[j]))375				suite.currentSpecReport.RunTime = time.Since(suite.currentSpecReport.StartTime)376				nodeState[nodes[j].ID] = suite.currentSpecReport.State377				if suite.currentSpecReport.State != types.SpecStatePassed {378					terminatingNode = nodes[j]379					break380				}381			}382			afterAllNodesThatRan := map[uint]bool{}383			// pull out some shared code so we aren't repeating ourselves down below. this just runs after and cleanup nodes384			runAfterAndCleanupNodes := func(nodes Nodes) {385				for j := range nodes {386					state, failure := suite.runNode(nodes[j], suite.interruptHandler.Status().Channel, spec.Nodes.BestTextFor(nodes[j]))387					suite.currentSpecReport.RunTime = time.Since(suite.currentSpecReport.StartTime)388					nodeState[nodes[j].ID] = state389					if suite.currentSpecReport.State == types.SpecStatePassed || state == types.SpecStateAborted {390						suite.currentSpecReport.State = state391						suite.currentSpecReport.Failure = failure392						if state != types.SpecStatePassed {393							terminatingNode = nodes[j]394						}395					}396					if nodes[j].NodeType.Is(types.NodeTypeAfterAll) {397						afterAllNodesThatRan[nodes[j].ID] = true398					}399				}400			}401			// pull out a helper that captures the logic of whether or not we should run a given After node.402			// there is complexity here stemming from the fact that we allow nested ordered contexts and flakey retries403			shouldRunAfterNode := func(n Node) bool {404				if n.NodeType.Is(types.NodeTypeAfterEach | types.NodeTypeJustAfterEach) {405					return true406				}407				var id uint408				if n.NodeType.Is(types.NodeTypeAfterAll) {409					id = n.ID410					if afterAllNodesThatRan[id] { //we've already run on this attempt. don't run again.411						return false412					}413				}414				if n.NodeType.Is(types.NodeTypeCleanupAfterAll) {415					id = n.NodeIDWhereCleanupWasGenerated416				}417				isLastSpecWithNode := indexOfLastSpecContainingNodeID(id) == i418				switch suite.currentSpecReport.State {419				case types.SpecStatePassed: //we've passed so far...420					return isLastSpecWithNode //... and we're the last spec with this AfterNode, so we should run it421				case types.SpecStateSkipped: //the spec was skipped by the user...422					if isLastSpecWithNode {423						return true //...we're the last spec, so we should run the AfterNode424					}425					if terminatingNode.NodeType.Is(types.NodeTypeBeforeAll) && terminatingNode.NestingLevel == n.NestingLevel {426						return true //...or, a BeforeAll was skipped and it's at our nesting level, so our subgroup is going to skip427					}428				case types.SpecStateFailed, types.SpecStatePanicked: // the spec has failed...429					if isFinalAttempt {430						return true //...if this was the last attempt then we're the last spec to run and so the AfterNode should run431					}432					if terminatingNode.NodeType.Is(types.NodeTypeBeforeAll) {433						//...we'll be rerunning a BeforeAll so we should cleanup after it if...434						if n.NodeType.Is(types.NodeTypeAfterAll) && terminatingNode.NestingLevel == n.NestingLevel {435							return true //we're at the same nesting level436						}437						if n.NodeType.Is(types.NodeTypeCleanupAfterAll) && terminatingNode.ID == n.NodeIDWhereCleanupWasGenerated {438							return true //we're a DeferCleanup generated by it439						}440					}441					if terminatingNode.NodeType.Is(types.NodeTypeAfterAll) {442						//...we'll be rerunning an AfterAll so we should cleanup after it if...443						if n.NodeType.Is(types.NodeTypeCleanupAfterAll) && terminatingNode.ID == n.NodeIDWhereCleanupWasGenerated {444							return true //we're a DeferCleanup generated by it445						}446					}447				case types.SpecStateInterrupted, types.SpecStateAborted: // ...we've been interrupted and/or aborted448					return true //...that means the test run is over and we should clean up the stack.  Run the AfterNode449				}450				return false451			}452			// first pass - run all the JustAfterEach, Aftereach, and AfterAlls.  Our shoudlRunAfterNode filter function will clean up the AfterAlls for us.453			afterNodes := spec.Nodes.WithType(types.NodeTypeJustAfterEach).SortedByDescendingNestingLevel()454			afterNodes = afterNodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeAfterEach).CopyAppend(spec.Nodes.WithType(types.NodeTypeAfterAll)...).SortedByDescendingNestingLevel()...)455			afterNodes = afterNodes.WithinNestingLevel(deepestNestingLevelAttained)456			afterNodes = afterNodes.Filter(shouldRunAfterNode)457			runAfterAndCleanupNodes(afterNodes)458			// second-pass perhaps we didn't run the AfterAlls but a state change due to an AfterEach now requires us to run the AfterAlls:459			afterNodes = spec.Nodes.WithType(types.NodeTypeAfterAll).WithinNestingLevel(deepestNestingLevelAttained).Filter(shouldRunAfterNode)460			runAfterAndCleanupNodes(afterNodes)461			// now we run any DeferCleanups462			afterNodes = suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterEach).Reverse()463			afterNodes = append(afterNodes, suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterAll).Filter(shouldRunAfterNode).Reverse()...)464			runAfterAndCleanupNodes(afterNodes)465			// third-pass, perhaps a DeferCleanup failed and now we need to run the AfterAlls.466			afterNodes = spec.Nodes.WithType(types.NodeTypeAfterAll).WithinNestingLevel(deepestNestingLevelAttained).Filter(shouldRunAfterNode)467			runAfterAndCleanupNodes(afterNodes)468			// and finally - running AfterAlls may have generated some new DeferCleanup nodes, let's run them to finish up469			afterNodes = suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterAll).Reverse().Filter(shouldRunAfterNode)470			runAfterAndCleanupNodes(afterNodes)471			suite.currentSpecReport.EndTime = time.Now()472			suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)473			suite.currentSpecReport.CapturedGinkgoWriterOutput += string(suite.writer.Bytes())474			suite.currentSpecReport.CapturedStdOutErr += suite.outputInterceptor.StopInterceptingAndReturnOutput()475			if suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {476				break477			}478		}479		//send the spec report to any attached ReportAfterEach blocks - this will update suite.currentSpecReport if failures occur in these blocks480		suite.reportEach(spec, types.NodeTypeReportAfterEach)481		suite.processCurrentSpecReport()482		if suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {483			groupSucceeded = false484		}485		suite.currentSpecReport = types.SpecReport{}486	}487}...

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

1import "internal"2func main() {3    internal.reportEach()4}5import "fmt"6func reportEach() {7    fmt.Println("I'm reporting each")8}9import "fmt"10func reportAll() {11    fmt.Println("I'm reporting all")12}

1import (2func main() {3	fmt.Println("Hello, playground")4	internal.ReportEach()5}6import (7func main() {8	fmt.Println("Hello, playground")9	internal.ReportAll()10}11import "fmt"12func reportEach() {13	fmt.Println("from reportEach")14}15import "fmt"16func reportAll() {17	fmt.Println("from reportAll")18}

1import (2func main() {3	internal.ReportEach()4	fmt.Println("done")5}6import (7func ReportEach() {8	fmt.Println("ReportEach")9}10import (11func TestReportEach(t *testing.T) {12	fmt.Println("TestReportEach")13}14import "fmt"15func ReportEach() {16	fmt.Println("ReportEach")17}18import (19func TestReportEach(t *testing.T) {20	fmt.Println("TestReportEach")21}22--- PASS: TestReportEach (0.00s)23import "fmt

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

1import (2func main() {3    x := internal.New(1)4    x.ReportEach()5}6import "fmt"7type X struct {8}9func New(x int) *X {10    return &X{x}11}12func (x *X) ReportEach() {13    for i := 0; i < x.x; i++ {14        fmt.Println(i)15    }16}17        /usr/local/go/src/internal/1 (from $GOROOT)18        /home/abc/go/src/internal/1 (from $GOPATH)19You can't import a package that is not in your $GOPATH

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

1import (2func main() {3}4import (5func main() {6	_1.InternalClass{}.reportEach()7}8import (9func main() {10	_1.InternalClass{}.reportEach()11}

1import (2func main() {3    fmt.Println("Hello, playground")4    internalClass.ReportEach()5}6import (7func main() {8    fmt.Println("Hello, playground")9    internalClass2.ReportEach()10}11import (12func main() {13    fmt.Println("Hello, playground")14}15import (