github.com/linuxboot/fiano@v1.2.0/pkg/bytes/range_test.go (about)

     1  // Copyright 2019 the LinuxBoot 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 bytes
     6  
     7  import (
     8  	"testing"
     9  )
    10  
    11  func TestRangesSortAndMerge(t *testing.T) {
    12  	t.Run("nothing_to_merge", func(t *testing.T) {
    13  		entries := Ranges{{
    14  			Offset: 2,
    15  			Length: 1,
    16  		}, {
    17  			Offset: 0,
    18  			Length: 1,
    19  		}}
    20  		entries.SortAndMerge()
    21  		assertEqualRanges(t, Ranges{{
    22  			Offset: 0,
    23  			Length: 1,
    24  		}, {
    25  			Offset: 2,
    26  			Length: 1,
    27  		}}, entries)
    28  	})
    29  	t.Run("merge_overlapping", func(t *testing.T) {
    30  		entries := Ranges{{
    31  			Offset: 2,
    32  			Length: 3,
    33  		}, {
    34  			Offset: 0,
    35  			Length: 3,
    36  		}}
    37  		entries.SortAndMerge()
    38  		assertEqualRanges(t, Ranges{{
    39  			Offset: 0,
    40  			Length: 5,
    41  		}}, entries)
    42  	})
    43  	t.Run("merge_no_distance", func(t *testing.T) {
    44  		entries := Ranges{{
    45  			Offset: 2,
    46  			Length: 2,
    47  		}, {
    48  			Offset: 0,
    49  			Length: 2,
    50  		}}
    51  		entries.SortAndMerge()
    52  		assertEqualRanges(t, Ranges{{
    53  			Offset: 0,
    54  			Length: 4,
    55  		}}, entries)
    56  	})
    57  	t.Run("merge_next_range_inside_previous", func(t *testing.T) {
    58  		entries := Ranges{
    59  			{
    60  				Offset: 0,
    61  				Length: 0,
    62  			},
    63  			{
    64  				Offset: 12320788,
    65  				Length: 4,
    66  			},
    67  			{
    68  				Offset: 12255584,
    69  				Length: 32,
    70  			},
    71  			{
    72  				Offset: 12582912,
    73  				Length: 4194304,
    74  			},
    75  			{
    76  				Offset: 15760208,
    77  				Length: 67646,
    78  			},
    79  			{
    80  				Offset: 1114112,
    81  				Length: 11141120,
    82  			},
    83  			{
    84  				Offset: 16777152,
    85  				Length: 16,
    86  			},
    87  			{
    88  				Offset: 12255232,
    89  				Length: 432,
    90  			},
    91  		}
    92  		entries.SortAndMerge()
    93  		assertEqualRanges(t, Ranges{
    94  			{
    95  				Offset: 0,
    96  				Length: 0,
    97  			},
    98  			{
    99  				Offset: 1114112,
   100  				Length: 11141552,
   101  			},
   102  			{
   103  				Offset: 12320788,
   104  				Length: 4,
   105  			},
   106  			{
   107  				Offset: 12582912,
   108  				Length: 4194304,
   109  			},
   110  		}, entries)
   111  	})
   112  }
   113  
   114  func TestRangeExclude(t *testing.T) {
   115  	assertEqualRanges(t,
   116  		Ranges{
   117  			Range{
   118  				Offset: 0,
   119  				Length: 1,
   120  			},
   121  			Range{
   122  				Offset: 2,
   123  				Length: 3,
   124  			},
   125  			Range{
   126  				Offset: 6,
   127  				Length: 4,
   128  			},
   129  		},
   130  		Range{
   131  			Offset: 0,
   132  			Length: 10,
   133  		}.Exclude(
   134  			Range{
   135  				Offset: 1,
   136  				Length: 1,
   137  			},
   138  			Range{
   139  				Offset: 5,
   140  				Length: 1,
   141  			},
   142  		),
   143  	)
   144  
   145  	assertEqualRanges(t,
   146  		Ranges{
   147  			Range{
   148  				Offset: 1,
   149  				Length: 9,
   150  			},
   151  		},
   152  		Range{
   153  			Offset: 0,
   154  			Length: 10,
   155  		}.Exclude(
   156  			Range{
   157  				Offset: 0,
   158  				Length: 1,
   159  			},
   160  		),
   161  	)
   162  
   163  	assertEqualRanges(t,
   164  		Ranges{
   165  			Range{
   166  				Offset: 0,
   167  				Length: 9,
   168  			},
   169  		},
   170  		Range{
   171  			Offset: 0,
   172  			Length: 10,
   173  		}.Exclude(
   174  			Range{
   175  				Offset: 9,
   176  				Length: 1,
   177  			},
   178  		),
   179  	)
   180  
   181  	assertEqualRanges(t,
   182  		Ranges{
   183  			Range{
   184  				Offset: 11,
   185  				Length: 9,
   186  			},
   187  		},
   188  		Range{
   189  			Offset: 10,
   190  			Length: 10,
   191  		}.Exclude(
   192  			Range{
   193  				Offset: 9,
   194  				Length: 2,
   195  			},
   196  		),
   197  	)
   198  
   199  	assertEqualRanges(t,
   200  		Ranges{
   201  			Range{
   202  				Offset: 0,
   203  				Length: 9,
   204  			},
   205  		},
   206  		Range{
   207  			Offset: 0,
   208  			Length: 10,
   209  		}.Exclude(
   210  			Range{
   211  				Offset: 9,
   212  				Length: 2,
   213  			},
   214  		),
   215  	)
   216  
   217  	assertEqualRanges(t,
   218  		Ranges{
   219  			Range{
   220  				Offset: 0,
   221  				Length: 10,
   222  			},
   223  		},
   224  		Range{
   225  			Offset: 0,
   226  			Length: 10,
   227  		}.Exclude(),
   228  	)
   229  
   230  	assertEqualRanges(t,
   231  		Ranges{
   232  			Range{
   233  				Offset: 10,
   234  				Length: 10,
   235  			},
   236  		},
   237  		Range{
   238  			Offset: 10,
   239  			Length: 10,
   240  		}.Exclude(
   241  			Range{
   242  				Offset: 0,
   243  				Length: 10,
   244  			},
   245  		),
   246  	)
   247  
   248  	assertEqualRanges(t,
   249  		Ranges{
   250  			Range{
   251  				Offset: 0,
   252  				Length: 10,
   253  			},
   254  		},
   255  		Range{
   256  			Offset: 0,
   257  			Length: 10,
   258  		}.Exclude(
   259  			Range{
   260  				Offset: 10,
   261  				Length: 10,
   262  			},
   263  		),
   264  	)
   265  
   266  	assertEqualRanges(t,
   267  		Ranges(nil),
   268  		Range{
   269  			Offset: 0,
   270  			Length: 10,
   271  		}.Exclude(
   272  			Range{
   273  				Offset: 0,
   274  				Length: 10,
   275  			},
   276  		),
   277  	)
   278  
   279  	assertEqualRanges(t,
   280  		Ranges(nil),
   281  		Range{
   282  			Offset: 10,
   283  			Length: 10,
   284  		}.Exclude(
   285  			Range{
   286  				Offset: 0,
   287  				Length: 30,
   288  			},
   289  		),
   290  	)
   291  }
   292  
   293  func assertEqualRanges(t *testing.T, expected, actual Ranges) {
   294  	if len(expected) != len(actual) {
   295  		t.Errorf("Expected number of ranges: %d, got: %d", len(expected), len(actual))
   296  	}
   297  	if len(expected) == 0 {
   298  		return
   299  	}
   300  
   301  	for i := 0; i < len(expected); i++ {
   302  		expectedRange := expected[i]
   303  		actualRange := actual[i]
   304  
   305  		if expectedRange.Offset != actualRange.Offset || expectedRange.Length != actualRange.Length {
   306  			t.Errorf("Range element %d is different, expected: [%d:%d], got: [%d:%d]",
   307  				i,
   308  				expectedRange.Offset,
   309  				actualRange.Offset,
   310  				expectedRange.Length,
   311  				actualRange.Length,
   312  			)
   313  		}
   314  	}
   315  }