go-hep.org/x/hep@v0.38.1/groot/riofs/blocks_test.go (about)

     1  // Copyright ©2018 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 riofs
     6  
     7  import (
     8  	"reflect"
     9  	"testing"
    10  )
    11  
    12  func TestFreeList(t *testing.T) {
    13  	var list freeList
    14  
    15  	checkSize := func(size int) {
    16  		t.Helper()
    17  		if got, want := len(list), size; got != want {
    18  			t.Fatalf("got=%d, want=%d", got, want)
    19  		}
    20  	}
    21  	checkSegment := func(free *freeSegment, want freeSegment) {
    22  		t.Helper()
    23  		if free == nil {
    24  			t.Fatalf("expected a valid free segment")
    25  		}
    26  		if *free != want {
    27  			t.Fatalf("got=%#v, want=%#v", *free, want)
    28  		}
    29  	}
    30  
    31  	list.add(0, 1)
    32  	checkSize(1)
    33  
    34  	list.add(3, 10)
    35  	checkSize(2)
    36  
    37  	free := list.add(13, 20)
    38  	checkSize(3)
    39  	checkSegment(free, freeSegment{13, 20})
    40  
    41  	free = list.add(12, 22)
    42  	checkSize(3)
    43  	checkSegment(free, freeSegment{12, 22})
    44  
    45  	if got, want := list, (freeList{
    46  		{0, 1},
    47  		{3, 10},
    48  		{12, 22},
    49  	}); !reflect.DeepEqual(got, want) {
    50  		t.Fatalf("error\ngot = %v\nwant= %v", got, want)
    51  	}
    52  
    53  	free = list.add(15, 20)
    54  	checkSize(3)
    55  	checkSegment(free, freeSegment{12, 22})
    56  
    57  	free = list.add(40, 50)
    58  	checkSize(4)
    59  	checkSegment(free, freeSegment{40, 50})
    60  
    61  	free = list.add(39, 40)
    62  	checkSize(4)
    63  	checkSegment(free, freeSegment{39, 50})
    64  
    65  	free = list.add(37, 38)
    66  	checkSize(4)
    67  	checkSegment(free, freeSegment{37, 50})
    68  
    69  	list.add(55, 60)
    70  	list.add(65, 70)
    71  	free = list.add(56, 66)
    72  	checkSize(5)
    73  	checkSegment(free, freeSegment{55, 70})
    74  
    75  	free = list.add(54, 71)
    76  	checkSize(5)
    77  	checkSegment(free, freeSegment{54, 71})
    78  
    79  	for _, tc := range []struct {
    80  		list []freeSegment
    81  		want []freeSegment
    82  		free freeList
    83  	}{
    84  		{
    85  			list: nil,
    86  			want: nil,
    87  			free: nil,
    88  		},
    89  		{
    90  			list: []freeSegment{{0, 1}, {1, 2}},
    91  			want: []freeSegment{{0, 1}, {0, 2}},
    92  			free: freeList{{0, 2}},
    93  		},
    94  		{
    95  			list: []freeSegment{{10, 12}, {10, 13}},
    96  			want: []freeSegment{{10, 12}, {10, 13}},
    97  			free: freeList{{10, 13}},
    98  		},
    99  	} {
   100  		t.Run("", func(t *testing.T) {
   101  			var list freeList
   102  			for i, v := range tc.list {
   103  				free := list.add(v.first, v.last)
   104  				if !reflect.DeepEqual(*free, tc.want[i]) {
   105  					t.Fatalf("error:\ngot[%d] = %#v\nwant[%d]= %#v\n",
   106  						i, *free, i, tc.want[i],
   107  					)
   108  				}
   109  			}
   110  			if !reflect.DeepEqual(list, tc.free) {
   111  				t.Fatalf("error:\ngot = %#v\nwant= %#v\n", list, tc.free)
   112  			}
   113  		})
   114  	}
   115  }
   116  
   117  func TestFreeListBest(t *testing.T) {
   118  	for _, tc := range []struct {
   119  		name   string
   120  		nbytes int64
   121  		list   freeList
   122  		want   *freeSegment
   123  	}{
   124  		{
   125  			name:   "empty",
   126  			nbytes: 0,
   127  			list:   nil,
   128  			want:   nil,
   129  		},
   130  		{
   131  			name:   "empty-list",
   132  			nbytes: 10,
   133  			list:   nil,
   134  			want:   nil,
   135  		},
   136  		{
   137  			name:   "exact-match",
   138  			nbytes: 10,
   139  			list:   freeList{{0, 1}, {10, 20 - 1}},
   140  			want:   &freeSegment{10, 20 - 1},
   141  		},
   142  		{
   143  			name:   "match",
   144  			nbytes: 1,
   145  			list:   freeList{{0, 10}},
   146  			want:   &freeSegment{0, 10},
   147  		},
   148  		{
   149  			name:   "match",
   150  			nbytes: 10,
   151  			list:   freeList{{0, 1}, {10, 20 + 4 + 1}},
   152  			want:   &freeSegment{10, 20 + 4 + 1},
   153  		},
   154  		{
   155  			name:   "big-file",
   156  			nbytes: 10,
   157  			list:   freeList{{0, 1}},
   158  			want:   &freeSegment{0, 1000000001},
   159  		},
   160  	} {
   161  		t.Run(tc.name, func(t *testing.T) {
   162  			got := tc.list.best(tc.nbytes)
   163  			if !reflect.DeepEqual(got, tc.want) {
   164  				t.Fatalf("error\ngot = %#v\nwant= %#v\n", got, tc.want)
   165  			}
   166  		})
   167  	}
   168  }
   169  
   170  func TestFreeListLast(t *testing.T) {
   171  	for _, tc := range []struct {
   172  		list freeList
   173  		want *freeSegment
   174  	}{
   175  		{
   176  			list: nil,
   177  			want: nil,
   178  		},
   179  		{
   180  			list: freeList{},
   181  			want: nil,
   182  		},
   183  		{
   184  			list: freeList{{0, kStartBigFile}},
   185  			want: &freeSegment{0, kStartBigFile},
   186  		},
   187  		{
   188  			list: freeList{{0, 10}, {12, kStartBigFile}},
   189  			want: &freeSegment{12, kStartBigFile},
   190  		},
   191  	} {
   192  		t.Run("", func(t *testing.T) {
   193  			got := tc.list.last()
   194  			if !reflect.DeepEqual(got, tc.want) {
   195  				t.Fatalf("error\ngot = %#v\nwant= %#v\n", got, tc.want)
   196  			}
   197  		})
   198  	}
   199  }