作者：vaudo
项目：go
func (self Remote) Less(other Remote) bool {
val := bytes.Compare(self.Pos, other.Pos)
if val == 0 {
val = bytes.Compare([]byte(self.Addr), []byte(other.Addr))
}
return val < 0
}
作者：markbenvenut
项目：evergree
func (suts *SortableUiTaskSlice) Less(i, j int) bool {
taskOne := suts.tasks[i]
taskTwo := suts.tasks[j]
displayNameOne := taskOne.Task.DisplayName
displayNameTwo := taskTwo.Task.DisplayName
if displayNameOne == evergreen.CompileStage {
return true
}
if displayNameTwo == evergreen.CompileStage {
return false
}
if displayNameOne == evergreen.PushStage {
return false
}
if displayNameTwo == evergreen.PushStage {
return true
}
if bytes.Compare([]byte(displayNameOne), []byte(displayNameTwo)) == -1 {
return true
}
if bytes.Compare([]byte(displayNameOne), []byte(displayNameTwo)) == 1 {
return false
}
return false
}
作者：loga
项目：hei
func (ctrl *Controller) authorizeKey(conn ssh.ConnMetadata, key ssh.PublicKey) (
*ssh.Permissions, error) {
marshaledKey := key.Marshal()
for _, authorizedKey := range ctrl.authorizedKeys {
if bytes.Compare(authorizedKey.Marshal(), marshaledKey) == 0 {
return &ssh.Permissions{}, nil
}
}
nodes, err := ctrl.cluster.GetDir("console/authorized_keys")
if err != nil {
if err == cluster.ErrNotFound {
return nil, fmt.Errorf("unauthorized")
}
return nil, err
}
for path, value := range nodes {
key, _, _, _, err := ssh.ParseAuthorizedKey([]byte(value))
if err != nil {
fmt.Printf("bad authorized key from etcd: %s: %s\n", path, err)
}
if bytes.Compare(key.Marshal(), marshaledKey) == 0 {
return &ssh.Permissions{}, nil
}
}
return nil, fmt.Errorf("unauthorized")
}
作者：reason
项目：im_servic
func (oc OfflineComparer) Compare(a, b []byte) int {
p1, p2, p3 := oc.Split(a)
p4, p5, p6 := oc.Split(b)
if p1 == nil || p4 == nil {
log.Infof("can't find seperate, a:%s b:%s compare bytes...\n", string(a), string(b))
return bytes.Compare(a, b)
}
r1 := bytes.Compare(p1, p4)
if r1 != 0 {
return r1
}
r2 := bytes.Compare(p2, p5)
if r2 != 0 {
return r2
}
v1, err1 := strconv.ParseInt(string(p3), 10, 64)
v2, err2 := strconv.ParseInt(string(p6), 10, 64)
if err1 != nil || err2 != nil {
log.Infof("parse int err, a:%s b:%s compare bytes...\n", string(a), string(b))
return bytes.Compare(p3, p6)
}
if v1 < v2 {
return -1
} else if v1 == v2 {
return 0
} else {
return 1
}
}
作者：freeform
项目：go-oaut
func (p byKeyValue) Less(i, j int) bool {
sgn := bytes.Compare(p[i].key, p[j].key)
if sgn == 0 {
sgn = bytes.Compare(p[i].value, p[j].value)
}
return sgn < 0
}
作者：neurodron
项目：influxd
// depending on the query order (whether it's ascending or not) returns
// the min (or max in case of descending query) of the current
// [timestamp,sequence] and the self's [timestamp,sequence]
//
// This is used to determine what the next point's timestamp
// and sequence number should be.
func (self *rawColumnValue) updatePointTimeAndSequence(currentTimeRaw, currentSequenceRaw []byte, isAscendingQuery bool) ([]byte, []byte) {
if currentTimeRaw == nil {
return self.time, self.sequence
}
compareValue := 1
if isAscendingQuery {
compareValue = -1
}
timeCompare := bytes.Compare(self.time, currentTimeRaw)
if timeCompare == compareValue {
return self.time, self.sequence
}
if timeCompare != 0 {
return currentTimeRaw, currentSequenceRaw
}
if bytes.Compare(self.sequence, currentSequenceRaw) == compareValue {
return currentTimeRaw, self.sequence
}
return currentTimeRaw, currentSequenceRaw
}
作者：soniabhishe
项目：cockroac
func testBasicEncodeDecode32(encFunc func([]byte, uint32) []byte,
decFunc func([]byte) ([]byte, uint32, error), descending bool, t *testing.T) {
testCases := []uint32{
0, 1,
1<<8 - 1, 1 << 8,
1<<16 - 1, 1 << 16,
1<<24 - 1, 1 << 24,
math.MaxUint32 - 1, math.MaxUint32,
}
var lastEnc []byte
for i, v := range testCases {
enc := encFunc(nil, v)
if i > 0 {
if (descending && bytes.Compare(enc, lastEnc) >= 0) ||
(!descending && bytes.Compare(enc, lastEnc) < 0) {
t.Errorf("ordered constraint violated for %d: [% x] vs. [% x]", v, enc, lastEnc)
}
}
b, decode, err := decFunc(enc)
if err != nil {
t.Error(err)
continue
}
if len(b) != 0 {
t.Errorf("leftover bytes: [% x]", b)
}
if decode != v {
t.Errorf("decode yielded different value than input: %d vs. %d", decode, v)
}
lastEnc = enc
}
}
作者：utamar
项目：cor
//Equals returns true if r==r2
func (r *Record) Equals(r2 *Record) bool {
if r.Thread != r2.Thread {
log.Println("unmatched threadname")
return false
}
if bytes.Compare(r.Sign, r2.Sign) != 0 {
log.Println("unmatched sign")
return false
}
if !r.Stamp.Equal(r2.Stamp) {
log.Println("unmatched stamp")
return false
}
if r.self != r2.self {
log.Println("unmatched self")
return false
}
if len(r.Contents) != len(r2.Contents) {
log.Println("unmatched contents length")
return false
}
for k, v := range r.Contents {
v2, exist := r2.Contents[k]
if !exist || bytes.Compare(v, v2) != 0 {
log.Println("unmatched contents", k)
return false
}
}
return true
}
作者：CedarLogi
项目：go-ethereu
func TestGetSeedHash(t *testing.T) {
seed0, err := GetSeedHash(0)
if err != nil {
t.Errorf("Failed to get seedHash for block 0: %v", err)
}
if bytes.Compare(seed0, make([]byte, 32)) != 0 {
log.Printf("seedHash for block 0 should be 0s, was: %v\n", seed0)
}
seed1, err := GetSeedHash(30000)
if err != nil {
t.Error(err)
}
// From python:
// > from pyethash import get_seedhash
// > get_seedhash(30000)
expectedSeed1, err := hex.DecodeString("290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563")
if err != nil {
t.Error(err)
}
if bytes.Compare(seed1, expectedSeed1) != 0 {
log.Printf("seedHash for block 1 should be: %v,\nactual value: %v\n", expectedSeed1, seed1)
}
}
作者：pid-
项目：go-qr-generatio
func Test_Blocks(t *testing.T) {
byteIt := make(chan byte)
go func() {
for _, b := range []byte{67, 85, 70, 134, 87, 38, 85, 194, 119, 50, 6, 18, 6, 103, 38, 246, 246, 66, 7, 118, 134, 242, 7, 38, 86, 22, 198, 199, 146, 6, 182, 230, 247, 119, 50, 7, 118, 134, 87, 38, 82, 6, 134, 151, 50, 7, 70, 247, 118, 86, 194, 6, 151, 50, 16, 236, 17, 236, 17, 236, 17, 236} {
byteIt <- b
}
close(byteIt)
}()
vi := &versionInfo{5, Q, 18, 2, 15, 2, 16}
data := splitToBlocks(byteIt, vi).interleave(vi)
if bytes.Compare(data, []byte{67, 246, 182, 70, 85, 246, 230, 247, 70, 66, 247, 118, 134, 7, 119, 86, 87, 118, 50, 194, 38, 134, 7, 6, 85, 242, 118, 151, 194, 7, 134, 50, 119, 38, 87, 16, 50, 86, 38, 236, 6, 22, 82, 17, 18, 198, 6, 236, 6, 199, 134, 17, 103, 146, 151, 236, 38, 6, 50, 17, 7, 236, 213, 87, 148, 235, 199, 204, 116, 159, 11, 96, 177, 5, 45, 60, 212, 173, 115, 202, 76, 24, 247, 182, 133, 147, 241, 124, 75, 59, 223, 157, 242, 33, 229, 200, 238, 106, 248, 134, 76, 40, 154, 27, 195, 255, 117, 129, 230, 172, 154, 209, 189, 82, 111, 17, 10, 2, 86, 163, 108, 131, 161, 163, 240, 32, 111, 120, 192, 178, 39, 133, 141, 236}) != 0 {
t.Fail()
}
byteIt2 := make(chan byte)
go func() {
for _, b := range []byte{67, 85, 70, 134, 87, 38, 85, 194, 119, 50, 6, 18, 6, 103, 38, 246, 246, 66, 7, 118, 134, 242, 7, 38, 86, 22, 198, 199, 146, 6, 182, 230, 247, 119, 50, 7, 118, 134, 87, 38, 82, 6, 134, 151, 50, 7, 70, 247, 118, 86, 194, 6, 151, 50, 16, 236, 17, 236, 17, 236, 17, 236} {
byteIt2 <- b
}
close(byteIt2)
}()
vi = &versionInfo{5, Q, 18, 2, 16, 2, 15}
data = splitToBlocks(byteIt2, vi).interleave(vi)
if bytes.Compare(data, []byte{67, 246, 247, 247, 85, 66, 119, 118, 70, 7, 50, 86, 134, 118, 7, 194, 87, 134, 118, 6, 38, 242, 134, 151, 85, 7, 87, 50, 194, 38, 38, 16, 119, 86, 82, 236, 50, 22, 6, 17, 6, 198, 134, 236, 18, 199, 151, 17, 6, 146, 50, 236, 103, 6, 7, 17, 38, 182, 70, 236, 246, 230, 71, 101, 27, 62, 13, 91, 166, 86, 138, 16, 78, 229, 102, 11, 199, 107, 2, 182, 132, 103, 89, 66, 136, 69, 78, 255, 116, 129, 126, 163, 219, 234, 158, 216, 42, 234, 97, 62, 186, 59, 123, 148, 220, 191, 254, 145, 82, 95, 129, 79, 236, 254, 30, 174, 228, 50, 181, 110, 150, 205, 34, 235, 242, 0, 115, 147, 58, 243, 28, 140, 221, 219}) != 0 {
t.Fail()
}
}
作者：neuroradiolog
项目：syncthin
func ldbDropRepo(db *leveldb.DB, repo []byte) {
defer runtime.GC()
snap, err := db.GetSnapshot()
if err != nil {
panic(err)
}
defer snap.Release()
// Remove all items related to the given repo from the node->file bucket
start := []byte{keyTypeNode}
limit := []byte{keyTypeNode + 1}
dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
for dbi.Next() {
itemRepo := nodeKeyRepo(dbi.Key())
if bytes.Compare(repo, itemRepo) == 0 {
db.Delete(dbi.Key(), nil)
}
}
dbi.Release()
// Remove all items related to the given repo from the global bucket
start = []byte{keyTypeGlobal}
limit = []byte{keyTypeGlobal + 1}
dbi = snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
for dbi.Next() {
itemRepo := globalKeyRepo(dbi.Key())
if bytes.Compare(repo, itemRepo) == 0 {
db.Delete(dbi.Key(), nil)
}
}
dbi.Release()
}
作者：hyperledge
项目：fabri
func TestCreateAttributesMetadataObjectFromCert(t *testing.T) {
tcert, preK0, err := loadTCertAndPreK0()
if err != nil {
t.Error(err)
}
metadata := []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
attributeKeys := []string{"position"}
metadataObj := CreateAttributesMetadataObjectFromCert(tcert, metadata, preK0, attributeKeys)
if bytes.Compare(metadataObj.Metadata, metadata) != 0 {
t.Errorf("Invalid metadata result %v but expected %v", metadataObj.Metadata, metadata)
}
entries := metadataObj.GetEntries()
if len(entries) != 2 {
t.Errorf("Invalid entries in metadata result %v but expected %v", len(entries), 3)
}
firstEntry := entries[0]
if firstEntry.AttributeName != "position" {
t.Errorf("Invalid first attribute name, this has to be %v but is %v", "position", firstEntry.AttributeName)
}
firstKey, err := GetKForAttribute("position", preK0, tcert)
if err != nil {
t.Error(err)
}
if bytes.Compare(firstKey, firstEntry.AttributeKey) != 0 {
t.Errorf("Invalid K for first attribute expected %v but returned %v", firstKey, firstEntry.AttributeKey)
}
}
作者：hyperledge
项目：fabri
func TestGetAttributesMetadata(t *testing.T) {
metadata := []byte{255, 255, 255, 255}
entries := make([]*pb.AttributesMetadataEntry, 1)
var entry pb.AttributesMetadataEntry
entry.AttributeName = "position"
entry.AttributeKey = []byte{0, 0, 0, 0}
entries[0] = &entry
attributesMetadata := pb.AttributesMetadata{Metadata: metadata, Entries: entries}
raw, err := proto.Marshal(&attributesMetadata)
if err != nil {
t.Error(err)
}
resultMetadata, err := GetAttributesMetadata(raw)
if err != nil {
t.Error(err)
}
if bytes.Compare(resultMetadata.Metadata, attributesMetadata.Metadata) != 0 {
t.Fatalf("Invalid metadata expected %v result %v", attributesMetadata.Metadata, resultMetadata.Metadata)
}
if resultMetadata.Entries[0].AttributeName != attributesMetadata.Entries[0].AttributeName {
t.Fatalf("Invalid first entry attribute name expected %v result %v", attributesMetadata.Entries[0].AttributeName, resultMetadata.Entries[0].AttributeName)
}
if bytes.Compare(resultMetadata.Entries[0].AttributeKey, attributesMetadata.Entries[0].AttributeKey) != 0 {
t.Fatalf("Invalid first entry attribute key expected %v result %v", attributesMetadata.Entries[0].AttributeKey, resultMetadata.Entries[0].AttributeKey)
}
}
作者：ntijani
项目：arvado
func TestPutSerialized(t *testing.T) {
// Create a volume with I/O serialization enabled.
v := TempUnixVolume(t, true)
defer _teardown(v)
sem := make(chan int)
go func(sem chan int) {
err := v.Put(TEST_HASH, TEST_BLOCK)
if err != nil {
t.Errorf("err1: %v", err)
}
sem <- 1
}(sem)
go func(sem chan int) {
err := v.Put(TEST_HASH_2, TEST_BLOCK_2)
if err != nil {
t.Errorf("err2: %v", err)
}
sem <- 1
}(sem)
go func(sem chan int) {
err := v.Put(TEST_HASH_3, TEST_BLOCK_3)
if err != nil {
t.Errorf("err3: %v", err)
}
sem <- 1
}(sem)
// Wait for all goroutines to finish
for done := 0; done < 2; {
done += <-sem
}
// Double check that we actually wrote the blocks we expected to write.
buf, err := v.Get(TEST_HASH)
if err != nil {
t.Errorf("Get #1: %v", err)
}
if bytes.Compare(buf, TEST_BLOCK) != 0 {
t.Errorf("Get #1: expected %s, got %s", string(TEST_BLOCK), string(buf))
}
buf, err = v.Get(TEST_HASH_2)
if err != nil {
t.Errorf("Get #2: %v", err)
}
if bytes.Compare(buf, TEST_BLOCK_2) != 0 {
t.Errorf("Get #2: expected %s, got %s", string(TEST_BLOCK_2), string(buf))
}
buf, err = v.Get(TEST_HASH_3)
if err != nil {
t.Errorf("Get #3: %v", err)
}
if bytes.Compare(buf, TEST_BLOCK_3) != 0 {
t.Errorf("Get #3: expected %s, got %s", string(TEST_BLOCK_3), string(buf))
}
}
作者：rnaveira
项目：packe
func TestBMPString(t *testing.T) {
str, err := bmpString("")
if bytes.Compare(str, []byte{0, 0}) != 0 {
t.Errorf("expected empty string to return double 0, but found: % x", str)
}
if err != nil {
t.Errorf("err: %v", err)
}
// Example from https://tools.ietf.org/html/rfc7292#appendix-B
str, err = bmpString("Beavis")
if bytes.Compare(str, []byte{0x00, 0x42, 0x00, 0x65, 0x00, 0x61, 0x00, 0x0076, 0x00, 0x69, 0x00, 0x73, 0x00, 0x00}) != 0 {
t.Errorf("expected 'Beavis' to return 0x00 0x42 0x00 0x65 0x00 0x61 0x00 0x76 0x00 0x69 0x00 0x73 0x00 0x00, but found: % x", str)
}
if err != nil {
t.Errorf("err: %v", err)
}
// some characters from the "Letterlike Symbols Unicode block"
tst := "\u2115 - Double-struck N"
str, err = bmpString(tst)
if bytes.Compare(str, []byte{0x21, 0x15, 0x00, 0x20, 0x00, 0x2d, 0x00, 0x20, 0x00, 0x44, 0x00, 0x6f, 0x00, 0x75, 0x00, 0x62, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x2d, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x75, 0x00, 0x63, 0x00, 0x6b, 0x00, 0x20, 0x00, 0x4e, 0x00, 0x00}) != 0 {
t.Errorf("expected '%s' to return 0x21 0x15 0x00 0x20 0x00 0x2d 0x00 0x20 0x00 0x44 0x00 0x6f 0x00 0x75 0x00 0x62 0x00 0x6c 0x00 0x65 0x00 0x2d 0x00 0x73 0x00 0x74 0x00 0x72 0x00 0x75 0x00 0x63 0x00 0x6b 0x00 0x20 0x00 0x4e 0x00 0x00, but found: % x", tst, str)
}
if err != nil {
t.Errorf("err: %v", err)
}
// some character outside the BMP should error
tst = "\U0001f000 East wind (Mahjong)"
str, err = bmpString(tst)
if err == nil {
t.Errorf("expected '%s' to throw error because the first character is not in the BMP", tst)
}
}
作者：jaekwo
项目：GuppyCam
func BasicCodecComparator(o1 interface{}, o2 interface{}) int {
switch o1.(type) {
case byte:
return int(o1.(byte) - o2.(byte))
case int8:
return int(o1.(int8) - o2.(int8))
//case uint8:
case int16:
return int(o1.(int16) - o2.(int16))
case uint16:
return int(o1.(uint16) - o2.(uint16))
case int32:
return int(o1.(int32) - o2.(int32))
case uint32:
return int(o1.(uint32) - o2.(uint32))
case int64:
return int(o1.(int64) - o2.(int64))
case uint64:
return int(o1.(uint64) - o2.(uint64))
case int:
return o1.(int) - o2.(int)
case uint:
return int(o1.(uint)) - int(o2.(uint))
case string:
return bytes.Compare([]byte(o1.(string)), []byte(o2.(string)))
case []byte:
return bytes.Compare(o1.([]byte), o2.([]byte))
case time.Time:
return int(o1.(time.Time).UnixNano() - o2.(time.Time).UnixNano())
default:
panic(fmt.Sprintf("Unsupported type: %v", reflect.TypeOf(o1)))
}
}
作者：marain
项目：gossi
func (m *MockQuery) sliceRow(r *Row) (*Row, error) {
if m.components != nil || m.betweenStart != nil || m.betweenEnd != nil || m.columnLimit != 0 {
slice, err := m.buildSlice()
if err != nil {
return nil, err
}
if m.reversed {
slice.Start, slice.End = slice.End, slice.Start
}
cr := *r
cr.Columns = []*Column{}
for _, c := range r.Columns {
if len(slice.Start) > 0 && bytes.Compare(slice.Start, c.Name) > 0 {
continue
}
if len(slice.End) > 0 && bytes.Compare(slice.End, c.Name) < 0 {
continue
}
cr.Columns = append(cr.Columns, c)
}
if slice.Count != 0 && len(cr.Columns) > slice.Count {
if m.reversed {
cr.Columns = cr.Columns[(len(cr.Columns) - slice.Count):len(cr.Columns)]
} else {
cr.Columns = cr.Columns[0:slice.Count]
}
}
r = &cr
}
return r, nil
}
作者：shawnp
项目：elastig
func TestSetBodyGzip(t *testing.T) {
s := "foo"
// test []byte
expB := []byte(s)
actB, err := gzipHelper(t, expB)
assert.T(t, err == nil, fmt.Sprintf("Expected err to be nil"))
assert.T(t, bytes.Compare(actB, expB) == 0, fmt.Sprintf("Expected: %s, got: %s", expB, actB))
// test string
expS := s
actS, err := gzipHelper(t, expS)
assert.T(t, err == nil, fmt.Sprintf("Expected err to be nil"))
assert.T(t, string(actS) == expS, fmt.Sprintf("Expected: %s, got: %s", expS, actS))
// test io.Reader
expR := strings.NewReader(s)
actR, err := gzipHelper(t, expR)
assert.T(t, err == nil, fmt.Sprintf("Expected err to be nil"))
assert.T(t, bytes.Compare([]byte(s), actR) == 0, fmt.Sprintf("Expected: %s, got: %s", s, actR))
// test other
expO := testStruct{Name: "Travis"}
actO, err := gzipHelper(t, expO)
assert.T(t, err == nil, fmt.Sprintf("Expected err to not be nil"))
assert.T(t, bytes.Compare([]byte(`{"name":"Travis"}`), actO) == 0, fmt.Sprintf("Expected: %s, got: %s", s, actO))
}
作者：cwen-code
项目：study-gopk
/*
参数列表
a 第一个要比较的字节切片
b 第二个要比较的字节切片
返回值
int 如果a==b返回0，如果a < b返回-1，如果a > b返回1
功能说明
Compare根据字节的值比较两个字节切片的大小
*/
func main() {
fmt.Println(bytes.Compare([]byte{1}, []byte{2}))
fmt.Println(bytes.Compare([]byte{1}, []byte{1}))
fmt.Println(bytes.Compare([]byte{1}, []byte{0}))
fmt.Println(bytes.Compare([]byte{1}, []byte{1, 2}))
fmt.Println(bytes.Compare([]byte{2}, []byte{1, 2}))
}
作者：vkovtas
项目：libqui
// skipPacket processes all the DTLS records in packet. It updates
// sequence number expectations but otherwise ignores them.
func (c *Conn) skipPacket(packet []byte) error {
for len(packet) > 0 {
if len(packet) < 13 {
return errors.New("tls: bad packet")
}
// Dropped packets are completely ignored save to update
// expected sequence numbers for this and the next epoch. (We
// don't assert on the contents of the packets both for
// simplicity and because a previous test with one shorter
// timeout schedule would have done so.)
epoch := packet[3:5]
seq := packet[5:11]
length := uint16(packet[11])<<8 | uint16(packet[12])
if bytes.Equal(c.in.seq[:2], epoch) {
if bytes.Compare(seq, c.in.seq[2:]) < 0 {
return errors.New("tls: sequence mismatch")
}
copy(c.in.seq[2:], seq)
c.in.incSeq(false)
} else {
if bytes.Compare(seq, c.in.nextSeq[:]) < 0 {
return errors.New("tls: sequence mismatch")
}
copy(c.in.nextSeq[:], seq)
c.in.incNextSeq()
}
if len(packet) < 13+int(length) {
return errors.New("tls: bad packet")
}
packet = packet[13+length:]
}
return nil
}
