go-hep.org/x/hep@v0.38.1/groot/rbytes/rbuffer_test.go (about)

     1  // Copyright ©2017 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package rbytes
     6  
     7  import (
     8  	"fmt"
     9  	"math/rand"
    10  	"testing"
    11  )
    12  
    13  func TestRBuffer(t *testing.T) {
    14  	data := make([]byte, 32)
    15  	r := NewRBuffer(data, nil, 0, nil)
    16  
    17  	if got, want := r.Len(), int64(32); got != want {
    18  		t.Fatalf("got len=%v. want=%v", got, want)
    19  	}
    20  	start := r.Pos()
    21  	if start != 0 {
    22  		t.Fatalf("got start=%v. want=%v", start, 0)
    23  	}
    24  
    25  	_ = r.ReadI16()
    26  	if r.Err() != nil {
    27  		t.Fatalf("error reading int16: %v", r.Err())
    28  	}
    29  
    30  	pos := r.Pos()
    31  	if pos != 2 {
    32  		t.Fatalf("got pos=%v. want=%v", pos, 16)
    33  	}
    34  
    35  	pos = 0
    36  	data = make([]byte, 2*(2+4+8))
    37  	r = NewRBuffer(data, nil, 0, nil)
    38  	for _, n := range []int{2, 4, 8} {
    39  		beg := r.Pos()
    40  		if beg != pos {
    41  			t.Errorf("pos[%d] error: got=%d, want=%d\n", n, beg, pos)
    42  		}
    43  		switch n {
    44  		case 2:
    45  			_ = r.ReadI16()
    46  			_ = r.ReadU16()
    47  		case 4:
    48  			_ = r.ReadI32()
    49  			_ = r.ReadU32()
    50  		case 8:
    51  			_ = r.ReadI64()
    52  			_ = r.ReadU64()
    53  		}
    54  		end := r.Pos()
    55  		pos += int64(2 * n)
    56  
    57  		if got, want := end-beg, int64(2*n); got != want {
    58  			t.Errorf("%d-bytes: got=%d. want=%d\n", n, got, want)
    59  		}
    60  	}
    61  }
    62  
    63  var f64sBenchSink = 0
    64  
    65  func BenchmarkReadF64s(b *testing.B) {
    66  	for _, sz := range []int{0, 1, 2, 4, 8, 64, 128, 1024, 1024 * 1024} {
    67  		b.Run(fmt.Sprintf("%d", sz), func(b *testing.B) {
    68  			wbuf := NewWBuffer(nil, nil, 0, nil)
    69  			rnd := rand.New(rand.NewSource(1234))
    70  			sli := make([]float64, sz)
    71  			for i := range sli {
    72  				sli[i] = rnd.Float64()
    73  			}
    74  			wbuf.WriteArrayF64(sli)
    75  
    76  			rbuf := NewRBuffer(wbuf.Bytes(), nil, 0, nil)
    77  			b.ReportAllocs()
    78  			b.ResetTimer()
    79  			for i := 0; i < b.N; i++ {
    80  				rbuf.r.c = 0
    81  				rbuf.ReadArrayF64(sli)
    82  				f64sBenchSink += len(sli)
    83  			}
    84  		})
    85  	}
    86  }
    87  
    88  var f32sBenchSink = 0
    89  
    90  func BenchmarkReadF32s(b *testing.B) {
    91  	for _, sz := range []int{0, 1, 2, 4, 8, 64, 128, 1024, 1024 * 1024} {
    92  		b.Run(fmt.Sprintf("%d", sz), func(b *testing.B) {
    93  			wbuf := NewWBuffer(nil, nil, 0, nil)
    94  			rnd := rand.New(rand.NewSource(1234))
    95  			sli := make([]float32, sz)
    96  			for i := range sli {
    97  				sli[i] = float32(rnd.Float64())
    98  			}
    99  			wbuf.WriteArrayF32(sli)
   100  
   101  			rbuf := NewRBuffer(wbuf.Bytes(), nil, 0, nil)
   102  			b.ReportAllocs()
   103  			b.ResetTimer()
   104  			for i := 0; i < b.N; i++ {
   105  				rbuf.r.c = 0
   106  				rbuf.ReadArrayF32(sli)
   107  				f32sBenchSink += len(sli)
   108  			}
   109  		})
   110  	}
   111  }