github.com/annchain/OG@v0.0.9/og/protocol/ogmessage/archive/raw_tx_gen_test.go (about)

     1  package archive
     2  
     3  //
     4  //// Code generated by github.com/tinylib/msgp DO NOT EDIT.
     5  //
     6  //import (
     7  //	"bytes"
     8  //	"testing"
     9  //
    10  //	"github.com/tinylib/msgp/msgp"
    11  //)
    12  //
    13  //func TestMarshalUnmarshalRawActionTx(t *testing.T) {
    14  //	v := RawActionTx{}
    15  //	bts, err := v.MarshalMsg(nil)
    16  //	if err != nil {
    17  //		t.Fatal(err)
    18  //	}
    19  //	left, err := v.UnmarshalMsg(bts)
    20  //	if err != nil {
    21  //		t.Fatal(err)
    22  //	}
    23  //	if len(left) > 0 {
    24  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
    25  //	}
    26  //
    27  //	left, err = msgp.Skip(bts)
    28  //	if err != nil {
    29  //		t.Fatal(err)
    30  //	}
    31  //	if len(left) > 0 {
    32  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
    33  //	}
    34  //}
    35  //
    36  //func BenchmarkMarshalMsgRawActionTx(b *testing.B) {
    37  //	v := RawActionTx{}
    38  //	b.ReportAllocs()
    39  //	b.ResetTimer()
    40  //	for i := 0; i < b.N; i++ {
    41  //		v.MarshalMsg(nil)
    42  //	}
    43  //}
    44  //
    45  //func BenchmarkAppendMsgRawActionTx(b *testing.B) {
    46  //	v := RawActionTx{}
    47  //	bts := make([]byte, 0, v.Msgsize())
    48  //	bts, _ = v.MarshalMsg(bts[0:0])
    49  //	b.SetBytes(int64(len(bts)))
    50  //	b.ReportAllocs()
    51  //	b.ResetTimer()
    52  //	for i := 0; i < b.N; i++ {
    53  //		bts, _ = v.MarshalMsg(bts[0:0])
    54  //	}
    55  //}
    56  //
    57  //func BenchmarkUnmarshalRawActionTx(b *testing.B) {
    58  //	v := RawActionTx{}
    59  //	bts, _ := v.MarshalMsg(nil)
    60  //	b.ReportAllocs()
    61  //	b.SetBytes(int64(len(bts)))
    62  //	b.ResetTimer()
    63  //	for i := 0; i < b.N; i++ {
    64  //		_, err := v.UnmarshalMsg(bts)
    65  //		if err != nil {
    66  //			b.Fatal(err)
    67  //		}
    68  //	}
    69  //}
    70  //
    71  //func TestEncodeDecodeRawActionTx(t *testing.T) {
    72  //	v := RawActionTx{}
    73  //	var buf bytes.Buffer
    74  //	msgp.Encode(&buf, &v)
    75  //
    76  //	m := v.Msgsize()
    77  //	if buf.Len() > m {
    78  //		t.Log("WARNING: TestEncodeDecodeRawActionTx Msgsize() is inaccurate")
    79  //	}
    80  //
    81  //	vn := RawActionTx{}
    82  //	err := msgp.Decode(&buf, &vn)
    83  //	if err != nil {
    84  //		t.Error(err)
    85  //	}
    86  //
    87  //	buf.Reset()
    88  //	msgp.Encode(&buf, &v)
    89  //	err = msgp.NewReader(&buf).Skip()
    90  //	if err != nil {
    91  //		t.Error(err)
    92  //	}
    93  //}
    94  //
    95  //func BenchmarkEncodeRawActionTx(b *testing.B) {
    96  //	v := RawActionTx{}
    97  //	var buf bytes.Buffer
    98  //	msgp.Encode(&buf, &v)
    99  //	b.SetBytes(int64(buf.Len()))
   100  //	en := msgp.NewWriter(msgp.Nowhere)
   101  //	b.ReportAllocs()
   102  //	b.ResetTimer()
   103  //	for i := 0; i < b.N; i++ {
   104  //		v.EncodeMsg(en)
   105  //	}
   106  //	en.Flush()
   107  //}
   108  //
   109  //func BenchmarkDecodeRawActionTx(b *testing.B) {
   110  //	v := RawActionTx{}
   111  //	var buf bytes.Buffer
   112  //	msgp.Encode(&buf, &v)
   113  //	b.SetBytes(int64(buf.Len()))
   114  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   115  //	dc := msgp.NewReader(rd)
   116  //	b.ReportAllocs()
   117  //	b.ResetTimer()
   118  //	for i := 0; i < b.N; i++ {
   119  //		err := v.DecodeMsg(dc)
   120  //		if err != nil {
   121  //			b.Fatal(err)
   122  //		}
   123  //	}
   124  //}
   125  //
   126  //func TestMarshalUnmarshalRawActionTxs(t *testing.T) {
   127  //	v := RawActionTxs{}
   128  //	bts, err := v.MarshalMsg(nil)
   129  //	if err != nil {
   130  //		t.Fatal(err)
   131  //	}
   132  //	left, err := v.UnmarshalMsg(bts)
   133  //	if err != nil {
   134  //		t.Fatal(err)
   135  //	}
   136  //	if len(left) > 0 {
   137  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
   138  //	}
   139  //
   140  //	left, err = msgp.Skip(bts)
   141  //	if err != nil {
   142  //		t.Fatal(err)
   143  //	}
   144  //	if len(left) > 0 {
   145  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
   146  //	}
   147  //}
   148  //
   149  //func BenchmarkMarshalMsgRawActionTxs(b *testing.B) {
   150  //	v := RawActionTxs{}
   151  //	b.ReportAllocs()
   152  //	b.ResetTimer()
   153  //	for i := 0; i < b.N; i++ {
   154  //		v.MarshalMsg(nil)
   155  //	}
   156  //}
   157  //
   158  //func BenchmarkAppendMsgRawActionTxs(b *testing.B) {
   159  //	v := RawActionTxs{}
   160  //	bts := make([]byte, 0, v.Msgsize())
   161  //	bts, _ = v.MarshalMsg(bts[0:0])
   162  //	b.SetBytes(int64(len(bts)))
   163  //	b.ReportAllocs()
   164  //	b.ResetTimer()
   165  //	for i := 0; i < b.N; i++ {
   166  //		bts, _ = v.MarshalMsg(bts[0:0])
   167  //	}
   168  //}
   169  //
   170  //func BenchmarkUnmarshalRawActionTxs(b *testing.B) {
   171  //	v := RawActionTxs{}
   172  //	bts, _ := v.MarshalMsg(nil)
   173  //	b.ReportAllocs()
   174  //	b.SetBytes(int64(len(bts)))
   175  //	b.ResetTimer()
   176  //	for i := 0; i < b.N; i++ {
   177  //		_, err := v.UnmarshalMsg(bts)
   178  //		if err != nil {
   179  //			b.Fatal(err)
   180  //		}
   181  //	}
   182  //}
   183  //
   184  //func TestEncodeDecodeRawActionTxs(t *testing.T) {
   185  //	v := RawActionTxs{}
   186  //	var buf bytes.Buffer
   187  //	msgp.Encode(&buf, &v)
   188  //
   189  //	m := v.Msgsize()
   190  //	if buf.Len() > m {
   191  //		t.Log("WARNING: TestEncodeDecodeRawActionTxs Msgsize() is inaccurate")
   192  //	}
   193  //
   194  //	vn := RawActionTxs{}
   195  //	err := msgp.Decode(&buf, &vn)
   196  //	if err != nil {
   197  //		t.Error(err)
   198  //	}
   199  //
   200  //	buf.Reset()
   201  //	msgp.Encode(&buf, &v)
   202  //	err = msgp.NewReader(&buf).Skip()
   203  //	if err != nil {
   204  //		t.Error(err)
   205  //	}
   206  //}
   207  //
   208  //func BenchmarkEncodeRawActionTxs(b *testing.B) {
   209  //	v := RawActionTxs{}
   210  //	var buf bytes.Buffer
   211  //	msgp.Encode(&buf, &v)
   212  //	b.SetBytes(int64(buf.Len()))
   213  //	en := msgp.NewWriter(msgp.Nowhere)
   214  //	b.ReportAllocs()
   215  //	b.ResetTimer()
   216  //	for i := 0; i < b.N; i++ {
   217  //		v.EncodeMsg(en)
   218  //	}
   219  //	en.Flush()
   220  //}
   221  //
   222  //func BenchmarkDecodeRawActionTxs(b *testing.B) {
   223  //	v := RawActionTxs{}
   224  //	var buf bytes.Buffer
   225  //	msgp.Encode(&buf, &v)
   226  //	b.SetBytes(int64(buf.Len()))
   227  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   228  //	dc := msgp.NewReader(rd)
   229  //	b.ReportAllocs()
   230  //	b.ResetTimer()
   231  //	for i := 0; i < b.N; i++ {
   232  //		err := v.DecodeMsg(dc)
   233  //		if err != nil {
   234  //			b.Fatal(err)
   235  //		}
   236  //	}
   237  //}
   238  //
   239  //func TestMarshalUnmarshalRawSequencer(t *testing.T) {
   240  //	v := RawSequencer{}
   241  //	bts, err := v.MarshalMsg(nil)
   242  //	if err != nil {
   243  //		t.Fatal(err)
   244  //	}
   245  //	left, err := v.UnmarshalMsg(bts)
   246  //	if err != nil {
   247  //		t.Fatal(err)
   248  //	}
   249  //	if len(left) > 0 {
   250  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
   251  //	}
   252  //
   253  //	left, err = msgp.Skip(bts)
   254  //	if err != nil {
   255  //		t.Fatal(err)
   256  //	}
   257  //	if len(left) > 0 {
   258  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
   259  //	}
   260  //}
   261  //
   262  //func BenchmarkMarshalMsgRawSequencer(b *testing.B) {
   263  //	v := RawSequencer{}
   264  //	b.ReportAllocs()
   265  //	b.ResetTimer()
   266  //	for i := 0; i < b.N; i++ {
   267  //		v.MarshalMsg(nil)
   268  //	}
   269  //}
   270  //
   271  //func BenchmarkAppendMsgRawSequencer(b *testing.B) {
   272  //	v := RawSequencer{}
   273  //	bts := make([]byte, 0, v.Msgsize())
   274  //	bts, _ = v.MarshalMsg(bts[0:0])
   275  //	b.SetBytes(int64(len(bts)))
   276  //	b.ReportAllocs()
   277  //	b.ResetTimer()
   278  //	for i := 0; i < b.N; i++ {
   279  //		bts, _ = v.MarshalMsg(bts[0:0])
   280  //	}
   281  //}
   282  //
   283  //func BenchmarkUnmarshalRawSequencer(b *testing.B) {
   284  //	v := RawSequencer{}
   285  //	bts, _ := v.MarshalMsg(nil)
   286  //	b.ReportAllocs()
   287  //	b.SetBytes(int64(len(bts)))
   288  //	b.ResetTimer()
   289  //	for i := 0; i < b.N; i++ {
   290  //		_, err := v.UnmarshalMsg(bts)
   291  //		if err != nil {
   292  //			b.Fatal(err)
   293  //		}
   294  //	}
   295  //}
   296  //
   297  //func TestEncodeDecodeRawSequencer(t *testing.T) {
   298  //	v := RawSequencer{}
   299  //	var buf bytes.Buffer
   300  //	msgp.Encode(&buf, &v)
   301  //
   302  //	m := v.Msgsize()
   303  //	if buf.Len() > m {
   304  //		t.Log("WARNING: TestEncodeDecodeRawSequencer Msgsize() is inaccurate")
   305  //	}
   306  //
   307  //	vn := RawSequencer{}
   308  //	err := msgp.Decode(&buf, &vn)
   309  //	if err != nil {
   310  //		t.Error(err)
   311  //	}
   312  //
   313  //	buf.Reset()
   314  //	msgp.Encode(&buf, &v)
   315  //	err = msgp.NewReader(&buf).Skip()
   316  //	if err != nil {
   317  //		t.Error(err)
   318  //	}
   319  //}
   320  //
   321  //func BenchmarkEncodeRawSequencer(b *testing.B) {
   322  //	v := RawSequencer{}
   323  //	var buf bytes.Buffer
   324  //	msgp.Encode(&buf, &v)
   325  //	b.SetBytes(int64(buf.Len()))
   326  //	en := msgp.NewWriter(msgp.Nowhere)
   327  //	b.ReportAllocs()
   328  //	b.ResetTimer()
   329  //	for i := 0; i < b.N; i++ {
   330  //		v.EncodeMsg(en)
   331  //	}
   332  //	en.Flush()
   333  //}
   334  //
   335  //func BenchmarkDecodeRawSequencer(b *testing.B) {
   336  //	v := RawSequencer{}
   337  //	var buf bytes.Buffer
   338  //	msgp.Encode(&buf, &v)
   339  //	b.SetBytes(int64(buf.Len()))
   340  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   341  //	dc := msgp.NewReader(rd)
   342  //	b.ReportAllocs()
   343  //	b.ResetTimer()
   344  //	for i := 0; i < b.N; i++ {
   345  //		err := v.DecodeMsg(dc)
   346  //		if err != nil {
   347  //			b.Fatal(err)
   348  //		}
   349  //	}
   350  //}
   351  //
   352  //func TestMarshalUnmarshalRawSequencers(t *testing.T) {
   353  //	v := RawSequencers{}
   354  //	bts, err := v.MarshalMsg(nil)
   355  //	if err != nil {
   356  //		t.Fatal(err)
   357  //	}
   358  //	left, err := v.UnmarshalMsg(bts)
   359  //	if err != nil {
   360  //		t.Fatal(err)
   361  //	}
   362  //	if len(left) > 0 {
   363  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
   364  //	}
   365  //
   366  //	left, err = msgp.Skip(bts)
   367  //	if err != nil {
   368  //		t.Fatal(err)
   369  //	}
   370  //	if len(left) > 0 {
   371  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
   372  //	}
   373  //}
   374  //
   375  //func BenchmarkMarshalMsgRawSequencers(b *testing.B) {
   376  //	v := RawSequencers{}
   377  //	b.ReportAllocs()
   378  //	b.ResetTimer()
   379  //	for i := 0; i < b.N; i++ {
   380  //		v.MarshalMsg(nil)
   381  //	}
   382  //}
   383  //
   384  //func BenchmarkAppendMsgRawSequencers(b *testing.B) {
   385  //	v := RawSequencers{}
   386  //	bts := make([]byte, 0, v.Msgsize())
   387  //	bts, _ = v.MarshalMsg(bts[0:0])
   388  //	b.SetBytes(int64(len(bts)))
   389  //	b.ReportAllocs()
   390  //	b.ResetTimer()
   391  //	for i := 0; i < b.N; i++ {
   392  //		bts, _ = v.MarshalMsg(bts[0:0])
   393  //	}
   394  //}
   395  //
   396  //func BenchmarkUnmarshalRawSequencers(b *testing.B) {
   397  //	v := RawSequencers{}
   398  //	bts, _ := v.MarshalMsg(nil)
   399  //	b.ReportAllocs()
   400  //	b.SetBytes(int64(len(bts)))
   401  //	b.ResetTimer()
   402  //	for i := 0; i < b.N; i++ {
   403  //		_, err := v.UnmarshalMsg(bts)
   404  //		if err != nil {
   405  //			b.Fatal(err)
   406  //		}
   407  //	}
   408  //}
   409  //
   410  //func TestEncodeDecodeRawSequencers(t *testing.T) {
   411  //	v := RawSequencers{}
   412  //	var buf bytes.Buffer
   413  //	msgp.Encode(&buf, &v)
   414  //
   415  //	m := v.Msgsize()
   416  //	if buf.Len() > m {
   417  //		t.Log("WARNING: TestEncodeDecodeRawSequencers Msgsize() is inaccurate")
   418  //	}
   419  //
   420  //	vn := RawSequencers{}
   421  //	err := msgp.Decode(&buf, &vn)
   422  //	if err != nil {
   423  //		t.Error(err)
   424  //	}
   425  //
   426  //	buf.Reset()
   427  //	msgp.Encode(&buf, &v)
   428  //	err = msgp.NewReader(&buf).Skip()
   429  //	if err != nil {
   430  //		t.Error(err)
   431  //	}
   432  //}
   433  //
   434  //func BenchmarkEncodeRawSequencers(b *testing.B) {
   435  //	v := RawSequencers{}
   436  //	var buf bytes.Buffer
   437  //	msgp.Encode(&buf, &v)
   438  //	b.SetBytes(int64(buf.Len()))
   439  //	en := msgp.NewWriter(msgp.Nowhere)
   440  //	b.ReportAllocs()
   441  //	b.ResetTimer()
   442  //	for i := 0; i < b.N; i++ {
   443  //		v.EncodeMsg(en)
   444  //	}
   445  //	en.Flush()
   446  //}
   447  //
   448  //func BenchmarkDecodeRawSequencers(b *testing.B) {
   449  //	v := RawSequencers{}
   450  //	var buf bytes.Buffer
   451  //	msgp.Encode(&buf, &v)
   452  //	b.SetBytes(int64(buf.Len()))
   453  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   454  //	dc := msgp.NewReader(rd)
   455  //	b.ReportAllocs()
   456  //	b.ResetTimer()
   457  //	for i := 0; i < b.N; i++ {
   458  //		err := v.DecodeMsg(dc)
   459  //		if err != nil {
   460  //			b.Fatal(err)
   461  //		}
   462  //	}
   463  //}
   464  //
   465  //func TestMarshalUnmarshalRawTx(t *testing.T) {
   466  //	v := RawTx{}
   467  //	bts, err := v.MarshalMsg(nil)
   468  //	if err != nil {
   469  //		t.Fatal(err)
   470  //	}
   471  //	left, err := v.UnmarshalMsg(bts)
   472  //	if err != nil {
   473  //		t.Fatal(err)
   474  //	}
   475  //	if len(left) > 0 {
   476  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
   477  //	}
   478  //
   479  //	left, err = msgp.Skip(bts)
   480  //	if err != nil {
   481  //		t.Fatal(err)
   482  //	}
   483  //	if len(left) > 0 {
   484  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
   485  //	}
   486  //}
   487  //
   488  //func BenchmarkMarshalMsgRawTx(b *testing.B) {
   489  //	v := RawTx{}
   490  //	b.ReportAllocs()
   491  //	b.ResetTimer()
   492  //	for i := 0; i < b.N; i++ {
   493  //		v.MarshalMsg(nil)
   494  //	}
   495  //}
   496  //
   497  //func BenchmarkAppendMsgRawTx(b *testing.B) {
   498  //	v := RawTx{}
   499  //	bts := make([]byte, 0, v.Msgsize())
   500  //	bts, _ = v.MarshalMsg(bts[0:0])
   501  //	b.SetBytes(int64(len(bts)))
   502  //	b.ReportAllocs()
   503  //	b.ResetTimer()
   504  //	for i := 0; i < b.N; i++ {
   505  //		bts, _ = v.MarshalMsg(bts[0:0])
   506  //	}
   507  //}
   508  //
   509  //func BenchmarkUnmarshalRawTx(b *testing.B) {
   510  //	v := RawTx{}
   511  //	bts, _ := v.MarshalMsg(nil)
   512  //	b.ReportAllocs()
   513  //	b.SetBytes(int64(len(bts)))
   514  //	b.ResetTimer()
   515  //	for i := 0; i < b.N; i++ {
   516  //		_, err := v.UnmarshalMsg(bts)
   517  //		if err != nil {
   518  //			b.Fatal(err)
   519  //		}
   520  //	}
   521  //}
   522  //
   523  //func TestEncodeDecodeRawTx(t *testing.T) {
   524  //	v := RawTx{}
   525  //	var buf bytes.Buffer
   526  //	msgp.Encode(&buf, &v)
   527  //
   528  //	m := v.Msgsize()
   529  //	if buf.Len() > m {
   530  //		t.Log("WARNING: TestEncodeDecodeRawTx Msgsize() is inaccurate")
   531  //	}
   532  //
   533  //	vn := RawTx{}
   534  //	err := msgp.Decode(&buf, &vn)
   535  //	if err != nil {
   536  //		t.Error(err)
   537  //	}
   538  //
   539  //	buf.Reset()
   540  //	msgp.Encode(&buf, &v)
   541  //	err = msgp.NewReader(&buf).Skip()
   542  //	if err != nil {
   543  //		t.Error(err)
   544  //	}
   545  //}
   546  //
   547  //func BenchmarkEncodeRawTx(b *testing.B) {
   548  //	v := RawTx{}
   549  //	var buf bytes.Buffer
   550  //	msgp.Encode(&buf, &v)
   551  //	b.SetBytes(int64(buf.Len()))
   552  //	en := msgp.NewWriter(msgp.Nowhere)
   553  //	b.ReportAllocs()
   554  //	b.ResetTimer()
   555  //	for i := 0; i < b.N; i++ {
   556  //		v.EncodeMsg(en)
   557  //	}
   558  //	en.Flush()
   559  //}
   560  //
   561  //func BenchmarkDecodeRawTx(b *testing.B) {
   562  //	v := RawTx{}
   563  //	var buf bytes.Buffer
   564  //	msgp.Encode(&buf, &v)
   565  //	b.SetBytes(int64(buf.Len()))
   566  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   567  //	dc := msgp.NewReader(rd)
   568  //	b.ReportAllocs()
   569  //	b.ResetTimer()
   570  //	for i := 0; i < b.N; i++ {
   571  //		err := v.DecodeMsg(dc)
   572  //		if err != nil {
   573  //			b.Fatal(err)
   574  //		}
   575  //	}
   576  //}
   577  //
   578  //func TestMarshalUnmarshalRawTxs(t *testing.T) {
   579  //	v := RawTxs{}
   580  //	bts, err := v.MarshalMsg(nil)
   581  //	if err != nil {
   582  //		t.Fatal(err)
   583  //	}
   584  //	left, err := v.UnmarshalMsg(bts)
   585  //	if err != nil {
   586  //		t.Fatal(err)
   587  //	}
   588  //	if len(left) > 0 {
   589  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
   590  //	}
   591  //
   592  //	left, err = msgp.Skip(bts)
   593  //	if err != nil {
   594  //		t.Fatal(err)
   595  //	}
   596  //	if len(left) > 0 {
   597  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
   598  //	}
   599  //}
   600  //
   601  //func BenchmarkMarshalMsgRawTxs(b *testing.B) {
   602  //	v := RawTxs{}
   603  //	b.ReportAllocs()
   604  //	b.ResetTimer()
   605  //	for i := 0; i < b.N; i++ {
   606  //		v.MarshalMsg(nil)
   607  //	}
   608  //}
   609  //
   610  //func BenchmarkAppendMsgRawTxs(b *testing.B) {
   611  //	v := RawTxs{}
   612  //	bts := make([]byte, 0, v.Msgsize())
   613  //	bts, _ = v.MarshalMsg(bts[0:0])
   614  //	b.SetBytes(int64(len(bts)))
   615  //	b.ReportAllocs()
   616  //	b.ResetTimer()
   617  //	for i := 0; i < b.N; i++ {
   618  //		bts, _ = v.MarshalMsg(bts[0:0])
   619  //	}
   620  //}
   621  //
   622  //func BenchmarkUnmarshalRawTxs(b *testing.B) {
   623  //	v := RawTxs{}
   624  //	bts, _ := v.MarshalMsg(nil)
   625  //	b.ReportAllocs()
   626  //	b.SetBytes(int64(len(bts)))
   627  //	b.ResetTimer()
   628  //	for i := 0; i < b.N; i++ {
   629  //		_, err := v.UnmarshalMsg(bts)
   630  //		if err != nil {
   631  //			b.Fatal(err)
   632  //		}
   633  //	}
   634  //}
   635  //
   636  //func TestEncodeDecodeRawTxs(t *testing.T) {
   637  //	v := RawTxs{}
   638  //	var buf bytes.Buffer
   639  //	msgp.Encode(&buf, &v)
   640  //
   641  //	m := v.Msgsize()
   642  //	if buf.Len() > m {
   643  //		t.Log("WARNING: TestEncodeDecodeRawTxs Msgsize() is inaccurate")
   644  //	}
   645  //
   646  //	vn := RawTxs{}
   647  //	err := msgp.Decode(&buf, &vn)
   648  //	if err != nil {
   649  //		t.Error(err)
   650  //	}
   651  //
   652  //	buf.Reset()
   653  //	msgp.Encode(&buf, &v)
   654  //	err = msgp.NewReader(&buf).Skip()
   655  //	if err != nil {
   656  //		t.Error(err)
   657  //	}
   658  //}
   659  //
   660  //func BenchmarkEncodeRawTxs(b *testing.B) {
   661  //	v := RawTxs{}
   662  //	var buf bytes.Buffer
   663  //	msgp.Encode(&buf, &v)
   664  //	b.SetBytes(int64(buf.Len()))
   665  //	en := msgp.NewWriter(msgp.Nowhere)
   666  //	b.ReportAllocs()
   667  //	b.ResetTimer()
   668  //	for i := 0; i < b.N; i++ {
   669  //		v.EncodeMsg(en)
   670  //	}
   671  //	en.Flush()
   672  //}
   673  //
   674  //func BenchmarkDecodeRawTxs(b *testing.B) {
   675  //	v := RawTxs{}
   676  //	var buf bytes.Buffer
   677  //	msgp.Encode(&buf, &v)
   678  //	b.SetBytes(int64(buf.Len()))
   679  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   680  //	dc := msgp.NewReader(rd)
   681  //	b.ReportAllocs()
   682  //	b.ResetTimer()
   683  //	for i := 0; i < b.N; i++ {
   684  //		err := v.DecodeMsg(dc)
   685  //		if err != nil {
   686  //			b.Fatal(err)
   687  //		}
   688  //	}
   689  //}
   690  //
   691  //func TestMarshalUnmarshalTxisMarshaler(t *testing.T) {
   692  //	v := TxisMarshaler{}
   693  //	bts, err := v.MarshalMsg(nil)
   694  //	if err != nil {
   695  //		t.Fatal(err)
   696  //	}
   697  //	left, err := v.UnmarshalMsg(bts)
   698  //	if err != nil {
   699  //		t.Fatal(err)
   700  //	}
   701  //	if len(left) > 0 {
   702  //		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
   703  //	}
   704  //
   705  //	left, err = msgp.Skip(bts)
   706  //	if err != nil {
   707  //		t.Fatal(err)
   708  //	}
   709  //	if len(left) > 0 {
   710  //		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
   711  //	}
   712  //}
   713  //
   714  //func BenchmarkMarshalMsgTxisMarshaler(b *testing.B) {
   715  //	v := TxisMarshaler{}
   716  //	b.ReportAllocs()
   717  //	b.ResetTimer()
   718  //	for i := 0; i < b.N; i++ {
   719  //		v.MarshalMsg(nil)
   720  //	}
   721  //}
   722  //
   723  //func BenchmarkAppendMsgTxisMarshaler(b *testing.B) {
   724  //	v := TxisMarshaler{}
   725  //	bts := make([]byte, 0, v.Msgsize())
   726  //	bts, _ = v.MarshalMsg(bts[0:0])
   727  //	b.SetBytes(int64(len(bts)))
   728  //	b.ReportAllocs()
   729  //	b.ResetTimer()
   730  //	for i := 0; i < b.N; i++ {
   731  //		bts, _ = v.MarshalMsg(bts[0:0])
   732  //	}
   733  //}
   734  //
   735  //func BenchmarkUnmarshalTxisMarshaler(b *testing.B) {
   736  //	v := TxisMarshaler{}
   737  //	bts, _ := v.MarshalMsg(nil)
   738  //	b.ReportAllocs()
   739  //	b.SetBytes(int64(len(bts)))
   740  //	b.ResetTimer()
   741  //	for i := 0; i < b.N; i++ {
   742  //		_, err := v.UnmarshalMsg(bts)
   743  //		if err != nil {
   744  //			b.Fatal(err)
   745  //		}
   746  //	}
   747  //}
   748  //
   749  //func TestEncodeDecodeTxisMarshaler(t *testing.T) {
   750  //	v := TxisMarshaler{}
   751  //	var buf bytes.Buffer
   752  //	msgp.Encode(&buf, &v)
   753  //
   754  //	m := v.Msgsize()
   755  //	if buf.Len() > m {
   756  //		t.Log("WARNING: TestEncodeDecodeTxisMarshaler Msgsize() is inaccurate")
   757  //	}
   758  //
   759  //	vn := TxisMarshaler{}
   760  //	err := msgp.Decode(&buf, &vn)
   761  //	if err != nil {
   762  //		t.Error(err)
   763  //	}
   764  //
   765  //	buf.Reset()
   766  //	msgp.Encode(&buf, &v)
   767  //	err = msgp.NewReader(&buf).Skip()
   768  //	if err != nil {
   769  //		t.Error(err)
   770  //	}
   771  //}
   772  //
   773  //func BenchmarkEncodeTxisMarshaler(b *testing.B) {
   774  //	v := TxisMarshaler{}
   775  //	var buf bytes.Buffer
   776  //	msgp.Encode(&buf, &v)
   777  //	b.SetBytes(int64(buf.Len()))
   778  //	en := msgp.NewWriter(msgp.Nowhere)
   779  //	b.ReportAllocs()
   780  //	b.ResetTimer()
   781  //	for i := 0; i < b.N; i++ {
   782  //		v.EncodeMsg(en)
   783  //	}
   784  //	en.Flush()
   785  //}
   786  //
   787  //func BenchmarkDecodeTxisMarshaler(b *testing.B) {
   788  //	v := TxisMarshaler{}
   789  //	var buf bytes.Buffer
   790  //	msgp.Encode(&buf, &v)
   791  //	b.SetBytes(int64(buf.Len()))
   792  //	rd := msgp.NewEndlessReader(buf.KeyBytes(), b)
   793  //	dc := msgp.NewReader(rd)
   794  //	b.ReportAllocs()
   795  //	b.ResetTimer()
   796  //	for i := 0; i < b.N; i++ {
   797  //		err := v.DecodeMsg(dc)
   798  //		if err != nil {
   799  //			b.Fatal(err)
   800  //		}
   801  //	}
   802  //}