// Verify consistency
                            if (!"concurrentRule".equals(ruleId)) {
                                errorCount.incrementAndGet();
                            }
                            if (proc != processor) {
                                errorCount.incrementAndGet();
                            }

                            // Occasionally update (half the threads)

                        errorCount.incrementAndGet();
                    } finally {
                        endLatch.countDown();
                    }
                }
            });
        }

        startLatch.countDown();
        endLatch.await(10, TimeUnit.SECONDS);
        executor.shutdown();

        assertEquals(0, errorCount.get());

	parser := newParser("amd64")
	var buf strings.Builder
	parser.errorWriter = &buf

	for _, cat := range testcats {
		for _, test := range cat.tests {
			parser.allowABI = cat.allowABI
			parser.errorCount = 0
			parser.lineNum++
			if !parser.pseudo(test.pseudo, tokenize(test.operands)) {
				t.Fatalf("Wrong pseudo-instruction: %s", test.pseudo)
			}
			errorLine := buf.String()
			if test.expected != errorLine {

		// Put file and line information on head of message.
		format = "%s:%d: " + format + "\n"
		args = append([]interface{}{p.lex.File(), p.lineNum}, args...)
	}
	fmt.Fprintf(p.errorWriter, format, args...)
	p.errorCount++
	if p.errorCount > 10 && !*flags.AllErrors {
		log.Fatal("too many errors")
	}
}

func (p *Parser) pos() src.XPos {
	return p.ctxt.PosTable.XPos(src.MakePos(p.lex.Base(), uint(p.lineNum), 0))
}

                    verbose: bool = False):
  """Creates a JUnit-based XML file, with each invocation as a testcase."""
  os.makedirs(os.path.dirname(output_path), exist_ok=True)
  failure_count = 0
  error_count = 0

  date_time = datetime.datetime
  attrib = {'name': 'Bazel Invocations', 'time': '0.0',
            'timestamp': date_time.isoformat(date_time.utcnow())}
  testsuites = ElemTree.Element('testsuites')

	errorCounts := make(map[error]int)
	for _, err := range errs {
		if IsErrIgnored(err, ignoredErrs...) {
			continue
		}
		// Errors due to context cancellation may be wrapped - group them by context.Canceled.
		if errors.Is(err, context.Canceled) {
			errorCounts[context.Canceled]++
			continue
		}
		errorCounts[err]++
	}

	maxCnt := 0

pkg go/scanner, type ErrorHandler func(token.Position, string)
pkg go/scanner, type ErrorList []*Error
pkg go/scanner, type Mode uint
pkg go/scanner, type Scanner struct
pkg go/scanner, type Scanner struct, ErrorCount int
pkg go/token, const ADD Token
pkg go/token, const ADD_ASSIGN Token
pkg go/token, const AND Token
pkg go/token, const AND_ASSIGN Token
pkg go/token, const AND_NOT Token