コード例 #1
0
ファイル: sign.go プロジェクト: zhjh1209/a_game
func signProto(day int) []*protodata.RewardData {

	var result []*protodata.RewardData
	Lua, _ := lua.NewLua("conf/sign_reward.lua")

	begin := day/7 - 1
	if begin < 0 {
		begin = 0
	}
	begin = begin*7 + 1
	for i := begin; i <= begin+7; i++ {

		//Lua.L.GetGlobal("signReward")
		Lua.L.DoString(fmt.Sprintf("coin, diamond, action, generalId = signReward(%d)", i))
		coin := Lua.GetInt("coin")
		diamond := Lua.GetInt("diamond")
		action := Lua.GetInt("action")
		generalId := Lua.GetInt("generalId")

		temp := new(protodata.RewardData)
		temp.RewardCoin = proto.Int32(int32(coin))
		temp.RewardDiamond = proto.Int32(int32(diamond))
		temp.Stamina = proto.Int32(int32(action))
		if generalId > 0 {
			config := models.BaseGeneral(generalId, nil)
			temp.General = generalProto(new(models.GeneralData), config)
		}

		result = append(result, temp)
	}

	Lua.Close()
	return result
}
コード例 #2
0
func ExampleBytesPerDevice_missingFlow() {
	trace := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(10),
				FlowId: proto.Int32(4),
			},
		},
	}
	consistentRanges := []*store.Record{
		&store.Record{
			Key:   lex.EncodeOrDie("node0", "anon0", int64(0), int32(0)),
			Value: lex.EncodeOrDie("node0", "anon0", int64(0), int32(0)),
		},
	}
	records := map[string]Trace{
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(0))): trace,
	}
	runBytesPerDevicePipeline(consistentRanges, records)

	fmt.Printf("No output")

	// Output:
	// No output
}
コード例 #3
0
ファイル: proto.go プロジェクト: shawnfeng/code_tst
func (self *Client) SendBussiness(ziptype int32, datatype int32, data []byte) (uint64, string) {
	fun := "Client.SendBussiness"

	msgid, err := self.manager.Msgid()
	if err != nil {
		slog.Errorf("%s get msgid error:%s", fun, err)
		return 0, self.remoteaddr
	}

	buss := &pushproto.Talk{
		Type:     pushproto.Talk_BUSSINESS.Enum(),
		Msgid:    proto.Uint64(msgid),
		Ziptype:  proto.Int32(ziptype),
		Datatype: proto.Int32(datatype),
		Bussdata: data,
	}

	spb, err := proto.Marshal(buss)
	if err != nil {
		slog.Errorf("%s marshaling error: ", fun, err)
		return 0, self.remoteaddr
	}

	p := util.Packdata(spb)
	self.sendBussRetry(msgid, p)

	slog.Infof("%s client:%s send msgid:%d", fun, self, msgid)
	self.Send(p)

	return msgid, self.remoteaddr
}
コード例 #4
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakeImport(path string, lineNum int32) *Instruction {
	return &Instruction{
		Type:       pb.Int32(constants.Instruction_IMPORT),
		Value:      pb.String(path),
		LineNumber: pb.Int32(lineNum),
	}
}
コード例 #5
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakeComment(comment string, lineNum int32) *Instruction {
	return &Instruction{
		Type:       pb.Int32(constants.Instruction_COMMENT),
		Value:      pb.String(comment),
		LineNumber: pb.Int32(lineNum),
	}
}
コード例 #6
0
ファイル: packetslices.go プロジェクト: zwczou/goserver
func init() {
	netlib.RegisterHandler(int(protocol.CoreBuiltinPacketID_PACKET_SS_SLICES), &PacketSlicesHandler{})
	netlib.RegisterFactory(int(protocol.CoreBuiltinPacketID_PACKET_SS_SLICES), &PacketSlicesPacketFactory{})

	netlib.DefaultBuiltinProtocolEncoder.PacketCutor = func(data []byte) (packs []interface{}) {

		var (
			offset    = 0
			sendSize  = 0
			seqNo     = 1
			totalSize = len(data)
			restSize  = len(data)
		)
		for restSize > 0 {
			sendSize = restSize
			if sendSize > netlib.MaxPacketSize-128 {
				sendSize = netlib.MaxPacketSize - 128
			}
			pack := &protocol.SSPacketSlices{
				SeqNo:      proto.Int32(int32(seqNo)),
				TotalSize:  proto.Int32(int32(totalSize)),
				Offset:     proto.Int32(int32(offset)),
				PacketData: data[offset : offset+sendSize],
			}
			proto.SetDefaults(pack)
			seqNo++
			restSize -= sendSize
			offset += sendSize
			packs = append(packs, pack)
		}
		return
	}
}
コード例 #7
0
ファイル: packager.go プロジェクト: jcgill81/tritium
// can't re-use the legacy native function resolver because it's a method of a
// type that provides its own helpers and contextual data, all of which would
// be too hard to reproduce
func (pkgr *Packager) resolveNativeDeclaration(f *tp.Function, path string) {
	// first we should check that the signature refers to something that actually exists
	sigStr := strings.Replace(f.Stub(pkgr.Package), ",", ".", -1)
	if whale.LookupBuiltIn(sigStr) == nil {
		panic(fmt.Sprintf("attempt to provide signature for nonexistent native function `%s` in `%s`", sigStr, path))
	}

	// now turn the type names into the appropriate numeric ids
	if returnType := f.GetReturnType(); len(returnType) > 0 {
		f.ReturnTypeId = proto.Int32(int32(pkgr.TypeMap[returnType]))
		f.ReturnType = nil
	}
	if scopeType := f.GetScopeType(); len(scopeType) > 0 {
		f.ScopeTypeId = proto.Int32(int32(pkgr.TypeMap[scopeType]))
		f.ScopeType = nil
	}
	if opensType := f.GetOpensType(); len(opensType) > 0 {
		f.OpensTypeId = proto.Int32(int32(pkgr.TypeMap[opensType]))
		f.OpensType = nil
	}
	for _, arg := range f.Args {
		if typeName := arg.GetTypeString(); len(typeName) > 0 {
			arg.TypeId = proto.Int32(int32(pkgr.TypeMap[typeName]))
			arg.TypeString = nil
		}
	}
}
コード例 #8
0
ファイル: resolve.go プロジェクト: nmakiya/tritium
func (pkg *Package) resolveHeader(function *tp.Function) {
	returnType := null.GetString(function.ReturnType)
	if len(returnType) > 0 {
		function.ReturnTypeId = proto.Int32(int32(pkg.findTypeIndex(returnType)))
		function.ReturnType = nil
	}

	scopeType := null.GetString(function.ScopeType)
	if len(scopeType) > 0 {
		function.ScopeTypeId = proto.Int32(int32(pkg.findTypeIndex(scopeType)))
		function.ScopeType = nil
	}

	opensType := null.GetString(function.OpensType)
	if len(opensType) > 0 {
		function.OpensTypeId = proto.Int32(int32(pkg.findTypeIndex(opensType)))
		function.OpensType = nil
	}

	for _, arg := range function.Args {
		typeName := null.GetString(arg.TypeString)
		if len(typeName) > 0 {
			arg.TypeId = proto.Int32(int32(pkg.findTypeIndex(typeName)))
			arg.TypeString = nil
		}
	}
}
コード例 #9
0
func TestParseSectionIntro_Valid(t *testing.T) {
	lines := []string{
		"10",
		"BUILDID",
		"NODEID 123 321 789",
		"12 23 34",
	}
	trace := Trace{}
	err := parseSectionIntro(lines, &trace)
	if err != nil {
		t.Fatal("Unexpected error:", err)
	}
	expectedTrace := Trace{
		FileFormatVersion: proto.Int32(10),
		BuildId:           proto.String("BUILDID"),
		NodeId:            proto.String("NODEID"),
		ProcessStartTimeMicroseconds: proto.Int64(123),
		SequenceNumber:               proto.Int32(321),
		TraceCreationTimestamp:       proto.Int64(789),
		PcapReceived:                 proto.Uint32(12),
		PcapDropped:                  proto.Uint32(23),
		InterfaceDropped:             proto.Uint32(34),
	}
	checkProtosEqual(t, &expectedTrace, &trace)
}
コード例 #10
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakeBlock(children []*Instruction, lineNum int32) *Instruction {
	return &Instruction{
		Type:       pb.Int32(constants.Instruction_BLOCK),
		Children:   children,
		LineNumber: pb.Int32(lineNum),
	}
}
コード例 #11
0
ファイル: rewrite_rule.go プロジェクト: nmakiya/tritium
func ReadRewriteRules(rules []string) []*RewriteRule {
	if ruleNum := len(rules); ruleNum/4 > 0 {
		rrules := make([]*RewriteRule, 0, ruleNum/4)
		for i := 0; i < ruleNum/4; i++ {
			newRule := &RewriteRule{}
			newRule.Proxy = new(string)
			newRule.Upstream = new(string)
			newRule.CookieDomain = new(string)
			direction := rules[4*i]
			*(newRule.Proxy) = rules[4*i+1]
			*(newRule.Upstream) = rules[4*i+2]
			*(newRule.CookieDomain) = rules[4*i+3]
			if direction == RuleToProxy {
				newRule.Direction = pb.Int32(constants.RewriteRule_UPSTREAM_TO_PROXY)
			} else if direction == RuleToUpstream {
				newRule.Direction = pb.Int32(constants.RewriteRule_PROXY_TO_UPSTREAM)
			} else {
				newRule.Direction = pb.Int32(constants.RewriteRule_BIDIRECTIONAL)
			}
			rrules = append(rrules, newRule)
		}
		return rrules
	}
	return nil
}
コード例 #12
0
ファイル: insert.go プロジェクト: kennylixi/btree
// Insert can insert record into a btree
func (t *Btree) insert(record TreeLog) error {
	tnode, err := t.getTreeNode(t.GetRoot())
	if err != nil {
		if err.Error() != "no data" {
			return err
		}
		nnode := t.newTreeNode()
		nnode.NodeType = proto.Int32(isLeaf)
		_, err = nnode.insertRecord(record, t)
		if err == nil {
			t.Nodes[nnode.GetId()], err = proto.Marshal(nnode)
		}
		t.Root = proto.Int64(nnode.GetId())
		return err
	}
	clonednode, err := tnode.insertRecord(record, t)
	if err == nil && len(clonednode.GetKeys()) > int(t.GetNodeMax()) {
		nnode := t.newTreeNode()
		nnode.NodeType = proto.Int32(isNode)
		key, left, right := clonednode.split(t)
		nnode.insertOnce(key, left, right, t)
		t.Nodes[nnode.GetId()], err = proto.Marshal(nnode)
		t.Root = proto.Int64(nnode.GetId())
	} else {
		t.Root = proto.Int64(clonednode.GetId())
	}
	return err
}
コード例 #13
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakeText(text string, lineNum int32) *Instruction {
	return &Instruction{
		Type:       pb.Int32(constants.Instruction_TEXT),
		Value:      pb.String(text),
		LineNumber: pb.Int32(lineNum),
	}
}
コード例 #14
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakePosition(pos string, lineNum int32) *Instruction {
	return &Instruction{
		Type:       pb.Int32(constants.Instruction_POSITION),
		Value:      pb.String(pos),
		LineNumber: pb.Int32(lineNum),
	}
}
コード例 #15
0
ファイル: battle.go プロジェクト: zhjh1209/a_game
func rewardProto(coin, diamond, actionValue int, generalData *protodata.GeneralData) *protodata.RewardData {
	return &protodata.RewardData{
		RewardCoin:    proto.Int32(int32(coin)),
		RewardDiamond: proto.Int32(int32(diamond)),
		Stamina:       proto.Int32(int32(actionValue)),
		General:       generalData}
}
コード例 #16
0
func TestParseSectionAddressTable_Valid(t *testing.T) {
	lines := []string{
		"10 11",
		"MAC1 IP1",
		"MAC2 IP2",
	}
	trace := Trace{}
	err := parseSectionAddressTable(lines, &trace)
	if err != nil {
		t.Fatal("Unexpected error:", err)
	}
	expectedTrace := Trace{
		AddressTableFirstId: proto.Int32(10),
		AddressTableSize:    proto.Int32(11),
		AddressTableEntry: []*AddressTableEntry{
			&AddressTableEntry{
				MacAddress: proto.String("MAC1"),
				IpAddress:  proto.String("IP1"),
			},
			&AddressTableEntry{
				MacAddress: proto.String("MAC2"),
				IpAddress:  proto.String("IP2"),
			},
		},
	}
	checkProtosEqual(t, &expectedTrace, &trace)
}
コード例 #17
0
func writerPipe(conn *net.TCPConn) {
	for {
		var msg string
		fmt.Scanln(&msg)

		if strings.EqualFold(msg, "quit") {
			quitSp <- true
			break
		}
		testMessage := &pb.TestMessage{
			TestInt:    proto.Int32(123),
			TestString: proto.String("est"),
		}
		fmt.Println(testMessage)
		byt, _ := proto.Marshal(testMessage)
		fmt.Println(byt)

		buff := &pb.MobileSuiteProtobuf{
			Type:    proto.Int32(321),
			Arena:   proto.Int32(111),
			Command: proto.Int32(0xa),
			Message: byt,
		}
		fmt.Println(buff)
		bybuf, _ := proto.Marshal(buff)
		fmt.Println(bybuf)
		conn.Write(bybuf)

	}
}
コード例 #18
0
ファイル: function.go プロジェクト: nmakiya/tritium
func (f *Function) RelocateTypes(relocations map[int]int) {
	f.ScopeTypeId = pb.Int32(int32(relocations[int(f.GetScopeTypeId())]))
	f.ReturnTypeId = pb.Int32(int32(relocations[int(f.GetReturnTypeId())]))
	f.OpensTypeId = pb.Int32(int32(relocations[int(f.GetOpensTypeId())]))
	for _, arg := range f.Args {
		arg.TypeId = pb.Int32(int32(relocations[int(arg.GetTypeId())]))
	}
}
コード例 #19
0
ファイル: server.go プロジェクト: ZhangzheBJUT/GoProject
func (t *Arith) Divide(args *arith.ArithRequest, reply *arith.ArithResponse) error {
	if args.GetB() == 0 {
		return errors.New("divide by zero")
	}
	reply.Quo = proto.Int32(args.GetA() / args.GetB())
	reply.Rem = proto.Int32(args.GetA() % args.GetB())
	return nil
}
コード例 #20
0
ファイル: text_test.go プロジェクト: adjust/goprotobuf
func newTestMessage() *pb.MyMessage {
	msg := &pb.MyMessage{
		Count: proto.Int32(42),
		Name:  proto.String("Dave"),
		Quote: proto.String(`"I didn't want to go."`),
		Pet:   []string{"bunny", "kitty", "horsey"},
		Inner: &pb.InnerMessage{
			Host:      proto.String("footrest.syd"),
			Port:      proto.Int32(7001),
			Connected: proto.Bool(true),
		},
		Others: []*pb.OtherMessage{
			{
				Key:   proto.Int64(0xdeadbeef),
				Value: []byte{1, 65, 7, 12},
			},
			{
				Weight: proto.Float32(6.022),
				Inner: &pb.InnerMessage{
					Host: proto.String("lesha.mtv"),
					Port: proto.Int32(8002),
				},
			},
		},
		Bikeshed: pb.MyMessage_BLUE.Enum(),
		Somegroup: &pb.MyMessage_SomeGroup{
			GroupField: proto.Int32(8),
		},
		// One normally wouldn't do this.
		// This is an undeclared tag 13, as a varint (wire type 0) with value 4.
		XXX_unrecognized: []byte{13<<3 | 0, 4},
	}
	ext := &pb.Ext{
		Data: proto.String("Big gobs for big rats"),
	}
	if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil {
		panic(err)
	}
	greetings := []string{"adg", "easy", "cow"}
	if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil {
		panic(err)
	}

	// Add an unknown extension. We marshal a pb.Ext, and fake the ID.
	b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")})
	if err != nil {
		panic(err)
	}
	b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...)
	proto.SetRawExtension(msg, 201, b)

	// Extensions can be plain fields, too, so let's test that.
	b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19)
	proto.SetRawExtension(msg, 202, b)

	return msg
}
コード例 #21
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakeFunctionCall(name string, args []*Instruction, block []*Instruction, lineNum int32) *Instruction {
	return &Instruction{
		Type:       pb.Int32(constants.Instruction_FUNCTION_CALL),
		Value:      pb.String(name),
		Arguments:  args,
		Children:   block,
		LineNumber: pb.Int32(lineNum),
	}
}
コード例 #22
0
ファイル: OSMsg_test.go プロジェクト: shaalx/protobuf
func init() {
	osmsg = &OSMsg{Pattern: &login}
	loginMsg = &LoginMsg{
		Pattern: &login,
		From:    proto.Int32(111),
		To:      proto.Int32(112),
		Msg:     proto.String("hello, world."),
	}
	loginMsgBytes, _ = proto.Marshal(loginMsg)
}
コード例 #23
0
ファイル: query.go プロジェクト: LeXa4894/test
// toProto converts the query to a protocol buffer.
func (q *Query) toProto(dst *pb.Query, appID string) error {
	if q.kind == "" {
		return errors.New("datastore: empty query kind")
	}
	dst.Reset()
	dst.App = proto.String(appID)
	dst.Kind = proto.String(q.kind)
	if q.ancestor != nil {
		dst.Ancestor = keyToProto(appID, q.ancestor)
	}
	if q.keysOnly {
		dst.KeysOnly = proto.Bool(true)
		dst.RequirePerfectPlan = proto.Bool(true)
	}
	for _, qf := range q.filter {
		if qf.FieldName == "" {
			return errors.New("datastore: empty query filter field name")
		}
		p, errStr := valueToProto(appID, qf.FieldName, reflect.ValueOf(qf.Value), false)
		if errStr != "" {
			return errors.New("datastore: bad query filter value type: " + errStr)
		}
		xf := &pb.Query_Filter{
			Op:       operatorToProto[qf.Op],
			Property: []*pb.Property{p},
		}
		if xf.Op == nil {
			return errors.New("datastore: unknown query filter operator")
		}
		dst.Filter = append(dst.Filter, xf)
	}
	for _, qo := range q.order {
		if qo.FieldName == "" {
			return errors.New("datastore: empty query order field name")
		}
		xo := &pb.Query_Order{
			Property:  proto.String(qo.FieldName),
			Direction: sortDirectionToProto[qo.Direction],
		}
		if xo.Direction == nil {
			return errors.New("datastore: unknown query order direction")
		}
		dst.Order = append(dst.Order, xo)
	}
	if q.limit >= 0 {
		dst.Limit = proto.Int32(q.limit)
	}
	if q.offset != 0 {
		dst.Offset = proto.Int32(q.offset)
	}
	dst.CompiledCursor = q.start
	dst.EndCompiledCursor = q.end
	dst.Compile = proto.Bool(true)
	return nil
}
コード例 #24
0
ファイル: clientsessionload.go プロジェクト: zwczou/goserver
func (sfcl *SessionHandlerClientLoad) reportLoad(s *netlib.Session) {
	sc := s.GetSessionConfig()
	pack := &protocol.ServerLoad{
		SrvType: proto.Int32(int32(sc.Type)),
		SrvId:   proto.Int32(int32(sc.Id)),
		CurLoad: proto.Int32(int32(srvlib.ClientSessionMgrSington.Count())),
	}
	proto.SetDefaults(pack)
	srvlib.ServerSessionMgrSington.Broadcast(pack, netlib.Config.SrvInfo.AreaID, srvlib.BalanceServerType)
	logger.Tracef("SessionHandlerClientLoad.reportLoad %v", pack)
}
コード例 #25
0
ファイル: item.go プロジェクト: zhjh1209/a_game
func itemProto(item *models.ItemData, config *models.Base_Item) *protodata.ItemData {

	return &protodata.ItemData{
		ItemId:      proto.Int32(int32(config.BaseId)),
		ItemName:    proto.String(config.Name),
		ItemDesc:    proto.String(config.Desc),
		ItemValue:   proto.Int32(int32(config.Value + item.Level*config.Group)),
		ItemPro:     proto.Int32(int32(config.Probability)),
		Level:       proto.Int32(int32(item.Level)),
		LevelUpCoin: proto.Int32(int32(config.LevelUpCoin[item.Level]))}
}
コード例 #26
0
func ExampleBytesPerDevice_macBoundAtStartOfFlow() {
	trace1 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(10),
				FlowId: proto.Int32(4),
			},
		},
		FlowTableEntry: []*FlowTableEntry{
			&FlowTableEntry{
				FlowId:        proto.Int32(4),
				SourceIp:      proto.String("1.2.3.4"),
				DestinationIp: proto.String("4.3.2.1"),
			},
		},
		AddressTableEntry: []*AddressTableEntry{
			&AddressTableEntry{
				IpAddress:  proto.String("1.2.3.4"),
				MacAddress: proto.String("AABBCCDDEEFF"),
			},
		},
	}
	trace2 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(12),
				FlowId: proto.Int32(4),
			},
		},
		AddressTableEntry: []*AddressTableEntry{
			&AddressTableEntry{
				IpAddress:  proto.String("1.2.3.4"),
				MacAddress: proto.String("FFEEDDCCBBAA"),
			},
		},
	}
	consistentRanges := []*store.Record{
		&store.Record{
			Key:   lex.EncodeOrDie("node0", "anon0", int64(0), int32(0)),
			Value: lex.EncodeOrDie("node0", "anon0", int64(0), int32(1)),
		},
	}
	records := map[string]Trace{
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(0))): trace1,
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(1))): trace2,
	}
	runBytesPerDevicePipeline(consistentRanges, records)

	// Output:
	// node0,AABBCCDDEEFF,0: 22
}
コード例 #27
0
ファイル: test.go プロジェクト: cokeboL/mandela
func main() {
	m := new(msg.FindNode)
	m.MsgType = proto.Int32(1)
	m.Timeout = proto.Int32(1)
	m.NodeId = proto.String("haha")
	m.AccID = proto.Uint64(1)
	buf, _ := proto.Marshal(m)
	fmt.Println(buf)

	base := new(msg.BaseMsg)
	proto.Unmarshal(buf, base)
	fmt.Println(*base.MsgType, *base.Timeout)
}
コード例 #28
0
ファイル: instruction.go プロジェクト: nmakiya/tritium
func MakeLocalVar(name string, val *Instruction, block []*Instruction, lineNum int32) *Instruction {
	node := &Instruction{
		Type:       pb.Int32(constants.Instruction_LOCAL_VAR),
		Value:      pb.String(name),
		Children:   block,
		LineNumber: pb.Int32(lineNum),
	}
	if val == nil {
		node.Arguments = nil
	} else {
		node.Arguments = ListInstructions(val)
	}
	return node
}
コード例 #29
0
func sendLogin(conn *net.TCPConn) {
	m := md5.New()
	io.WriteString(m, "123456")
	password := string(m.Sum(nil))
	password = hex.EncodeToString([]byte(password))
	loginInfo := &Auth_C2S.LoginInfo{
		Name: proto.String("	"),
		Passworld:       proto.String(password),
		ClientType:      proto.Int32(1),
		MachineId:       proto.String("ddd"),
		SoftwareVersion: proto.Int32(1),
	}
	sendMsg(conn, byte(C2S_LoginInfo_CMD), loginInfo)
}
コード例 #30
0
func TestParseSectionDnsTableA_Valid(t *testing.T) {
	lines := []string{
		"10 11",
		"12 13 0 DOM1 IP1 14",
		"15 16 1 DOM2 IP2 17",
	}
	trace := Trace{}
	err := parseSectionDnsTableA(lines, &trace)
	if err != nil {
		t.Fatal("Unexpected error:", err)
	}
	expectedTrace := Trace{
		ARecordsDropped:     proto.Int32(10),
		CnameRecordsDropped: proto.Int32(11),
		ARecord: []*DnsARecord{
			&DnsARecord{
				PacketId:   proto.Int32(12),
				AddressId:  proto.Int32(13),
				Anonymized: proto.Bool(false),
				Domain:     proto.String("DOM1"),
				IpAddress:  proto.String("IP1"),
				Ttl:        proto.Int32(14),
			},
			&DnsARecord{
				PacketId:   proto.Int32(15),
				AddressId:  proto.Int32(16),
				Anonymized: proto.Bool(true),
				Domain:     proto.String("DOM2"),
				IpAddress:  proto.String("IP2"),
				Ttl:        proto.Int32(17),
			},
		},
	}
	checkProtosEqual(t, &expectedTrace, &trace)
}