Golang bytes.Count函数代码示例

func ExampleCount() {
	fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
	fmt.Println(bytes.Count([]byte("five"), []byte(""))) // before & after each rune
	// Output:
	// 3
	// 5
}

func solve(input io.Reader) {
	scanner := bufio.NewScanner(input)
	scanner.Scan()
	A := []byte(scanner.Text())
	scanner.Scan()
	B := []byte(scanner.Text())

	if bytes.Count(A, []byte("1")) != bytes.Count(B, []byte("1")) {
		fmt.Println("-1")
		return
	}

	swaps := 0
	for i := 0; i < len(A); i++ {
		if A[i] != B[i] {
			for j := i + 1; j < len(A); j++ {
				if A[j] != B[j] && B[i] != B[j] {
					swaps++
					B[i], B[j] = B[j], B[i]
					break
				}
			}
		}
	}

	fmt.Println(swaps)
}

func init() {
	Unix.DecodeLine = func(p []byte) (depth int, name []byte, err error) {
		var n int
		// TODO(rjeczalik): Count up to first non-box character.
		depth = (bytes.Count(p, boxSpace) + bytes.Count(p, boxHardSpace) +
			bytes.Count(p, boxVertical)) / 4
		if n = bytes.LastIndex(p, boxHorizontal); n == -1 {
			err = errors.New("invalid syntax: " + string(p))
			return
		}
		name = p[n:]
		if n = bytes.Index(name, boxSpace); n == -1 {
			err = errors.New("invalid syntax: " + string(p))
			return
		}
		name = name[n+1:]
		return
	}
	Unix.EncodeState = func(st EncodingState) []byte {
		return box[st]
	}
	Tab.DecodeLine = func(p []byte) (depth int, name []byte, err error) {
		depth = bytes.Count(p, []byte{'\t'})
		name = p[depth:]
		return
	}
	Tab.EncodeState = func(st EncodingState) []byte {
		return []byte{'\t'}
	}
}

func TestList(t *testing.T) {
	// use buffer instead of Stdout so we can inspect the results
	var b bytes.Buffer
	setOutput(&b)
	defer revertOutput()

	// use custom name so test won't interfere with a real _gen.go
	setCustomName("_gen_test.go")
	defer revertCustomName()

	// remove existing files, start fresh
	os.Remove(customName)

	// standard
	if err := runMain([]string{"gen", "list"}); err != nil {
		t.Error(err)
	}

	// one line for title, 2 standard typewriters
	if lines := bytes.Count(b.Bytes(), []byte("\n")); lines != 3 {
		t.Errorf("standard list should output 3 lines, got %v", lines)
	}

	// clear out the output buffer
	b.Reset()

	// create a custom typewriter import file
	w, err := os.Create(customName)

	if err != nil {
		t.Error(err)
	}

	defer os.Remove(customName)

	p := pkg{
		Name: "main",
		Imports: []string{
			// non-standard typewriter
			`_ "github.com/clipperhouse/gen/typewriters/foowriter"`,
			`_ "github.com/clipperhouse/gen/typewriters/genwriter"`,
			`_ "github.com/clipperhouse/gen/typewriters/container"`,
		},
	}

	if err := tmpl.Execute(w, p); err != nil {
		t.Error(err)
	}

	// custom file now exists
	if err := runMain([]string{"gen", "list"}); err != nil {
		t.Error(err)
	}

	// one line for title, 3 custom typewriters
	if lines := bytes.Count(b.Bytes(), []byte("\n")); lines != 4 {
		t.Errorf("standard list should output 4 lines, got %v", lines)
	}
}

func slicecount() {
	s := []byte("banana")
	sep1 := []byte("ban")
	sep2 := []byte("na")
	sep3 := []byte("a")

	fmt.Println(bytes.Count(s, sep1))
	fmt.Println(bytes.Count(s, sep2))
	fmt.Println(bytes.Count(s, sep3))

}

func Check(path string) {
	File, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer File.Close()
	buf := bufio.NewReader(File)
	var num int = 1
	var errornum int = 0
	s := []byte("{{")
	e := []byte("}}")
	for {
		line, _, err := buf.ReadLine()
		if err != nil {
			if err.Error() == "EOF" {
				break
			}
			return
		}
		if bytes.Count(line, s) != bytes.Count(line, e) {
			fmt.Printf("Line%d: %s\n", num, string(line))
			errornum++
			continue
		}
		if bytes.Count(line, []byte("{{.}}")) != 0 {
			fmt.Printf("Line%d: %s\n", num, string(line))
			errornum++
			continue
		}

		for i := 0; i < bytes.Count(line, s); i++ {
			first := bytes.Index(line, s)
			last := bytes.Index(line, e)
			if first == -1 || last == -1 {
				continue
			}
			if bytes.Index(line[first:last], []byte("{{.")) != 0 {
				fmt.Printf("Error Line %d: %s\n", num, string(line))
				errornum++
				break
			}
			line = line[last:]
		}
	}
	if errornum != 0 {
		fmt.Printf("Error num %d From %s\n", errornum, path)
		return
	}
	return
}

func (d *datagram) validate() (err error) {
	switch {
	case d.offset < 2:
		err = errors.New("Datagram has no opcode")
	case d.opcode() > 6:
		err = errors.New("Invalid opcode")
	default:
		switch d.opcode() {
		case opCodeRRQ, opCodeWRQ:
			switch {
			case len(d.filename()) < 1:
				err = errors.New("No filename provided")
			case d.buf[d.offset-1] != 0x0: // End with NULL
				err = fmt.Errorf("Corrupt %v datagram", d.opcode())
			case bytes.Count(d.buf[2:d.offset], []byte{0x0})%2 != 0: // Number of NULL chars is not even
				err = fmt.Errorf("Corrupt %v datagram", d.opcode())
			default:
				switch d.mode() {
				case ModeNetASCII, ModeOctet:
					break
				case modeMail:
					err = errors.New("MAIL transfer mode is unsupported")
				default:
					err = errors.New("Invalid transfer mode")
				}
			}
		case opCodeACK, opCodeDATA:
			if d.offset < 4 {
				err = errors.New("Corrupt block number")
			}
		case opCodeERROR:
			switch {
			case d.offset < 5:
				err = errors.New("Corrupt ERROR datagram")
			case d.buf[d.offset-1] != 0x0:
				err = errors.New("Corrupt ERROR datagram")
			case bytes.Count(d.buf[4:d.offset], []byte{0x0}) > 1:
				err = errors.New("Corrupt ERROR datagram")
			}
		case opCodeOACK:
			switch {
			case d.buf[d.offset-1] != 0x0:
				err = errors.New("Corrupt OACK datagram")
			case bytes.Count(d.buf[2:d.offset], []byte{0x0})%2 != 0: // Number of NULL chars is not even
				err = errors.New("Corrupt OACK datagram")
			}
		}
	}
	return
}

func numTCP() (ntcp, nopen, nclose int, err error) {
	lsof, err := exec.Command("lsof", "-n", "-p", strconv.Itoa(os.Getpid())).Output()
	if err != nil {
		return 0, 0, 0, err
	}
	ntcp += bytes.Count(lsof, []byte("TCP"))
	for _, state := range []string{"LISTEN", "SYN_SENT", "SYN_RECEIVED", "ESTABLISHED"} {
		nopen += bytes.Count(lsof, []byte(state))
	}
	for _, state := range []string{"CLOSED", "CLOSE_WAIT", "LAST_ACK", "FIN_WAIT_1", "FIN_WAIT_2", "CLOSING", "TIME_WAIT"} {
		nclose += bytes.Count(lsof, []byte(state))
	}
	return ntcp, nopen, nclose, nil
}

func shortText(t []byte) []byte {
	if t == nil {
		return nil
	}

	// Cut signature.
	i := bytes.LastIndex(t, sigDash)
	j := bytes.LastIndex(t, quote)
	if i > j && bytes.Count(t[i+1:], nl) <= 10 {
		t = t[:i+1]
	}

	// Cut trailing quoted text.
	for {
		rest, last := lastLine(t)
		trim := bytes.TrimSpace(last)
		if len(rest) < len(t) && (len(trim) == 0 || trim[0] == '>') {
			t = rest
			continue
		}
		break
	}

	// Cut 'On foo.*wrote:' line.
	rest, last := lastLine(t)
	if onwrote.Match(last) {
		t = rest
	}

	// Cut trailing blank lines.
	for {
		rest, last := lastLine(t)
		trim := bytes.TrimSpace(last)
		if len(rest) < len(t) && len(trim) == 0 {
			t = rest
			continue
		}
		break
	}

	// Cut signature again.
	i = bytes.LastIndex(t, sigDash)
	j = bytes.LastIndex(t, quote)
	if i > j && bytes.Count(t[i+1:], nl) <= 10 {
		t = t[:i+1]
	}

	return t
}

func Write(ch chan []byte, k, v string) error {
	data := []byte(k + "=" + v + "\n")
	if bytes.Count(data, []byte("=")) > 1 || bytes.Count(data, []byte("=")) > 1 {
		return errors.New("Cannot have '=' in stream key or value")
	}
	if bytes.Count(data, []byte("\n")) > 1 || bytes.Count(data, []byte("\n")) > 1 {
		return errors.New("Cannot have newline in stream key or value")
	}
	select {
	case ch <- data:
	default:
		return ErrOverflow
	}
	return nil
}

func loadConfig() *Config {
	var config *Config
	file, err := ioutil.ReadFile("mipples.json")
	if err != nil {
		panic(err)
	}

	if err := json.Unmarshal(file, &config); err != nil {
		syntaxErr, ok := err.(*json.SyntaxError)
		if !ok {
			log.Fatalf("Cannot read config: %s", err)
		}

		// We have a syntax error. Extract out the line number and friends.
		// https://groups.google.com/forum/#!topic/golang-nuts/fizimmXtVfc
		newline := []byte{'\x0a'}

		// Calculate the start/end position of the line where the error is
		start := bytes.LastIndex(file[:syntaxErr.Offset], newline) + 1
		end := len(file)
		if idx := bytes.Index(file[start:], newline); idx >= 0 {
			end = start + idx
		}

		// Count the line number we're on plus the offset in the line
		line := bytes.Count(file[:start], newline) + 1
		pos := int(syntaxErr.Offset) - start - 1

		log.Fatalf("Cannot read config. Error in line %d, char %d: %s\n%s",
			line, pos, syntaxErr, file[start:end])
	}

	return config
}

func TestMessagePlainPGPSingleKey(t *testing.T) {

	const caddyFile = `mailout {
				to              [email protected]
				cc              "[email protected]"
				subject         "Encrypted contact 🔑"
				body            testdata/mail_plainTextMessage.txt
				[email protected] 		testdata/B06469EE_nopw.pub.asc
			}`

	buf := new(bytes.Buffer)
	srv := testMessageServer(t, caddyFile, buf, 2)
	defer srv.Close()

	data := make(url.Values)
	data.Set("firstname", "Ken")
	data.Set("lastname", "Thompson")
	data.Set("email", "[email protected]")
	data.Set("name", "Ken Thompson")

	testDoPost(t, srv.URL, data)

	assert.Len(t, buf.String(), 2710) // whenever you change the template, change also here
	assert.Contains(t, buf.String(), "Subject: =?UTF-8?q?Encrypted_contact_=F0=9F=94=91?=")
	assert.Contains(t, buf.String(), "Cc: [email protected]")
	assert.Exactly(t, 1, bytes.Count(buf.Bytes(), maillog.MultiMessageSeparator))
	assert.Contains(t, buf.String(), `This shows the content of a text template.`)
	//t.Log(buf.String())
}

func (p *parser) processDefine(line []byte) {
	line = concatline(line)
	if glog.V(1) {
		glog.Infof("concatline:%q", line)
	}
	if !p.isEndef(line) {
		if p.inDef != nil {
			p.inDef = append(p.inDef, '\n')
		}
		p.inDef = append(p.inDef, line...)
		if p.inDef == nil {
			p.inDef = []byte{}
		}
		return
	}
	glog.V(1).Infof("multilineAssign %q %q", p.defineVar, p.inDef)
	aast, err := newAssignAST(p, p.defineVar, p.inDef, "=")
	if err != nil {
		p.err = p.srcpos().errorf("assign error %q=%q: %v", p.defineVar, p.inDef, err)
		return
	}
	aast.srcpos = p.srcpos()
	aast.srcpos.lineno -= bytes.Count(p.inDef, []byte{'\n'})
	p.addStatement(aast)
	p.defineVar = nil
	p.inDef = nil
	return
}

func parseCover(fn string) []*SourceFile {
	profs, err := parseProfiles(fn)
	if err != nil {
		log.Fatalf("Error parsing coverage: %v", err)
	}

	var rv []*SourceFile
	for _, prof := range profs {
		path, err := findFile(prof.FileName)
		if err != nil {
			log.Fatalf("Can't find %v", err)
		}
		fb, err := ioutil.ReadFile(path)
		if err != nil {
			log.Fatalf("Error reading %v: %v", path, err)
		}
		sf := &SourceFile{
			Name:     prof.FileName,
			Source:   string(fb),
			Coverage: make([]interface{}, 1+bytes.Count(fb, []byte{'\n'})),
		}

		for _, block := range prof.Blocks {
			for i := block.StartLine; i <= block.EndLine; i++ {
				sf.Coverage[i-1] = block.Count
			}
		}

		rv = append(rv, sf)
	}

	return rv
}

func TestTrie_compact(t *testing.T) {
	trie := NewTrie()

	trie.Insert(Prefix("a"), 0)
	trie.Insert(Prefix("ab"), 0)
	trie.Insert(Prefix("abc"), 0)
	trie.Insert(Prefix("abcd"), 0)
	trie.Insert(Prefix("abcde"), 0)
	trie.Insert(Prefix("abcdef"), 0)
	trie.Insert(Prefix("abcdefg"), 0)
	trie.Insert(Prefix("abcdefgi"), 0)
	trie.Insert(Prefix("abcdefgij"), 0)
	trie.Insert(Prefix("abcdefgijk"), 0)

	trie.Delete(Prefix("abcdef"))
	trie.Delete(Prefix("abcde"))
	trie.Delete(Prefix("abcdefg"))

	trie.Delete(Prefix("a"))
	trie.Delete(Prefix("abc"))
	trie.Delete(Prefix("ab"))

	trie.Visit(func(prefix Prefix, item Item) error {
		// 97 ~~ 'a',
		for ch := byte(97); ch <= 107; ch++ {
			if c := bytes.Count(prefix, []byte{ch}); c > 1 {
				t.Errorf("%q appeared in %q %v times", ch, prefix, c)
			}
		}
		return nil
	})
}