github.com/insolar/vanilla@v0.0.0-20201023172447-248fdf805322/longbits/bit_array_test.go (about)

     1  // Copyright 2020 Insolar Network Ltd.
     2  // All rights reserved.
     3  // This material is licensed under the Insolar License version 1.0,
     4  // available at https://github.com/insolar/assured-ledger/blob/master/LICENSE.md.
     5  
     6  package longbits
     7  
     8  import (
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestBitPos(t *testing.T) {
    15  	require.Panics(t, func() { BitPos(-1) })
    16  
    17  	for i, tc := range []struct {
    18  		input   int
    19  		bytePos int
    20  		bitPos  uint8
    21  	}{
    22  		{ 0, 0, 0},
    23  		{ 1, 0, 1},
    24  		{ 2, 0, 2},
    25  		{ 10, 1, 2},
    26  	} {
    27  		bytePos, bitPos := BitPos(tc.input)
    28  		require.Equal(t, tc.bytePos, bytePos, "%d: bytePos", i)
    29  		require.Equal(t, tc.bitPos, bitPos, "%d: bitPos", i)
    30  	}
    31  }
    32  
    33  func newString(s string) *string {
    34  	return &s
    35  }
    36  
    37  func TestBitSlice_BitBool(t *testing.T) {
    38  	for _, tc := range []struct {
    39  		slice []byte
    40  		index int
    41  		res   bool
    42  		panic *string
    43  	}{
    44  		{
    45  			slice: []byte{0x2},
    46  			index: 1,
    47  			res:   true,
    48  		},
    49  		{
    50  			slice: []byte{0x0, 0x2},
    51  			index: 9,
    52  			res:   true,
    53  		},
    54  		{
    55  			slice: []byte{0x0, 0x2},
    56  			index: 8,
    57  			res:   false,
    58  		},
    59  		{
    60  			slice: []byte{0x1},
    61  			index: 8,
    62  			panic: newString("out of bounds"),
    63  		},
    64  	} {
    65  		if tc.panic != nil {
    66  			require.Panics(t, func() { BitSliceLSB(tc.slice).BitBool(tc.index) })
    67  			continue
    68  		}
    69  		require.Equal(t, tc.res, BitSliceLSB(tc.slice).BitBool(tc.index))
    70  	}
    71  }
    72  
    73  func TestBitSlice_BitValue(t *testing.T) {
    74  	for _, tc := range []struct {
    75  		slice []byte
    76  		index int
    77  		res   byte
    78  		panic *string
    79  	}{
    80  		{
    81  			slice: []byte{0x2},
    82  			index: 1,
    83  			res:   1,
    84  		},
    85  		{
    86  			slice: []byte{0x0, 0x2},
    87  			index: 9,
    88  			res:   1,
    89  		},
    90  		{
    91  			slice: []byte{0x0, 0x2},
    92  			index: 8,
    93  			res:   0,
    94  		},
    95  		{
    96  			slice: []byte{0x1},
    97  			index: 8,
    98  			panic: newString("out of bounds"),
    99  		},
   100  	} {
   101  		if tc.panic != nil {
   102  			require.Panics(t, func() { BitSliceLSB(tc.slice).BitValue(tc.index) })
   103  			continue
   104  		}
   105  		require.Equal(t, tc.res, BitSliceLSB(tc.slice).BitValue(tc.index))
   106  	}
   107  }
   108  
   109  func TestBitSlice_BitLen(t *testing.T) {
   110  	require.Equal(t, 0, BitSliceLSB(nil).BitLen())
   111  	require.Equal(t, 0, BitSliceLSB([]byte{}).BitLen())
   112  	require.Equal(t, 8, BitSliceLSB([]byte{0x1}).BitLen())
   113  	require.Equal(t, 16, BitSliceLSB([]byte{0x1, 0x10}).BitLen())
   114  }
   115  
   116  func TestBitSlice_SearchBit(t *testing.T) {
   117  	for _, tc := range []struct {
   118  		slice   []byte
   119  		startAt int
   120  		bit     bool
   121  		res     int
   122  		panic   *string
   123  	}{
   124  		{
   125  			slice:   []byte{0x2},
   126  			startAt: 1,
   127  			res:     2,
   128  		},
   129  		{
   130  			slice:   []byte{0x2},
   131  			startAt: 8,
   132  			res:     -1,
   133  		},
   134  		{
   135  			slice:   []byte{0x0, 0x2},
   136  			startAt: 9,
   137  			res:     10,
   138  		},
   139  		{
   140  			slice:   []byte{0xFF, 0x2},
   141  			startAt: 0,
   142  			res:     8,
   143  		},
   144  		{
   145  			slice:   []byte{0x0, 0x2},
   146  			startAt: 9,
   147  			bit:     true,
   148  			res:     9,
   149  		},
   150  		{
   151  			slice:   []byte{0x0, 0x2},
   152  			startAt: 0,
   153  			bit:     true,
   154  			res:     9,
   155  		},
   156  		{
   157  			slice:   []byte{0x0, 0x0},
   158  			startAt: 8,
   159  			bit:     true,
   160  			res:     -1,
   161  		},
   162  		{
   163  			slice:   []byte{0xFF, 0xFF},
   164  			startAt: 0,
   165  			res:     -1,
   166  		},
   167  		{
   168  			slice:   []byte{0x1},
   169  			startAt: -1,
   170  			panic:   newString("illegal value"),
   171  		},
   172  	} {
   173  		if tc.panic != nil {
   174  			require.Panics(t, func() { BitSliceLSB(tc.slice).SearchBit(tc.startAt, tc.bit) })
   175  			continue
   176  		}
   177  		require.Equal(t, tc.res, BitSliceLSB(tc.slice).SearchBit(tc.startAt, tc.bit))
   178  	}
   179  }
   180  
   181  func TestBitSlice_Byte(t *testing.T) {
   182  	require.Equal(t, byte(0x1), BitSliceLSB([]byte{0x1}).Byte(0))
   183  	require.Equal(t, byte(0x10), BitSliceLSB([]byte{0x1, 0x10}).Byte(1))
   184  	require.Panics(t, func() { BitSliceLSB([]byte{0x1}).Byte(1) })
   185  }