github.com/safing/portbase@v0.19.5/container/container_test.go (about)

     1  package container
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/safing/portbase/utils"
     8  )
     9  
    10  var (
    11  	testData         = []byte("The quick brown fox jumps over the lazy dog")
    12  	testDataSplitted = [][]byte{
    13  		[]byte("T"),
    14  		[]byte("he"),
    15  		[]byte(" qu"),
    16  		[]byte("ick "),
    17  		[]byte("brown"),
    18  		[]byte(" fox j"),
    19  		[]byte("umps ov"),
    20  		[]byte("er the l"),
    21  		[]byte("azy dog"),
    22  	}
    23  )
    24  
    25  func TestContainerDataHandling(t *testing.T) {
    26  	t.Parallel()
    27  
    28  	c1 := New(utils.DuplicateBytes(testData))
    29  	c1c := c1.carbonCopy()
    30  
    31  	c2 := New()
    32  	for i := 0; i < len(testData); i++ {
    33  		oneByte := make([]byte, 1)
    34  		c1c.WriteToSlice(oneByte)
    35  		c2.Append(oneByte)
    36  	}
    37  	c2c := c2.carbonCopy()
    38  
    39  	c3 := New()
    40  	for i := len(c2c.compartments) - 1; i >= c2c.offset; i-- {
    41  		c3.Prepend(c2c.compartments[i])
    42  	}
    43  	c3c := c3.carbonCopy()
    44  
    45  	d4 := make([]byte, len(testData)*2)
    46  	n, _ := c3c.WriteToSlice(d4)
    47  	d4 = d4[:n]
    48  	c3c = c3.carbonCopy()
    49  
    50  	d5 := make([]byte, len(testData))
    51  	for i := 0; i < len(testData); i++ {
    52  		c3c.WriteToSlice(d5[i : i+1])
    53  	}
    54  
    55  	c6 := New()
    56  	c6.Replace(testData)
    57  
    58  	c7 := New(testDataSplitted[0])
    59  	for i := 1; i < len(testDataSplitted); i++ {
    60  		c7.Append(testDataSplitted[i])
    61  	}
    62  
    63  	c8 := New(testDataSplitted...)
    64  	for i := 0; i < 110; i++ {
    65  		c8.Prepend(nil)
    66  	}
    67  	c8.clean()
    68  
    69  	c9 := c8.PeekContainer(len(testData))
    70  
    71  	c10 := c9.PeekContainer(len(testData) - 1)
    72  	c10.Append(testData[len(testData)-1:])
    73  
    74  	compareMany(t, testData, c1.CompileData(), c2.CompileData(), c3.CompileData(), d4, d5, c6.CompileData(), c7.CompileData(), c8.CompileData(), c9.CompileData(), c10.CompileData())
    75  }
    76  
    77  func compareMany(t *testing.T, reference []byte, other ...[]byte) {
    78  	t.Helper()
    79  
    80  	for i, cmp := range other {
    81  		if !bytes.Equal(reference, cmp) {
    82  			t.Errorf("sample %d does not match reference: sample is '%s'", i+1, string(cmp))
    83  		}
    84  	}
    85  }
    86  
    87  func TestDataFetching(t *testing.T) {
    88  	t.Parallel()
    89  
    90  	c1 := New(utils.DuplicateBytes(testData))
    91  	data := c1.GetMax(1)
    92  	if string(data[0]) != "T" {
    93  		t.Errorf("failed to GetMax(1), got %s, expected %s", string(data), "T")
    94  	}
    95  
    96  	_, err := c1.Get(1000)
    97  	if err == nil {
    98  		t.Error("should fail")
    99  	}
   100  
   101  	_, err = c1.GetAsContainer(1000)
   102  	if err == nil {
   103  		t.Error("should fail")
   104  	}
   105  }
   106  
   107  func TestBlocks(t *testing.T) {
   108  	t.Parallel()
   109  
   110  	c1 := New(utils.DuplicateBytes(testData))
   111  	c1.PrependLength()
   112  
   113  	n, err := c1.GetNextN8()
   114  	if err != nil {
   115  		t.Errorf("GetNextN8() failed: %s", err)
   116  	}
   117  	if n != 43 {
   118  		t.Errorf("n should be 43, was %d", n)
   119  	}
   120  	c1.PrependLength()
   121  
   122  	n2, err := c1.GetNextN16()
   123  	if err != nil {
   124  		t.Errorf("GetNextN16() failed: %s", err)
   125  	}
   126  	if n2 != 43 {
   127  		t.Errorf("n should be 43, was %d", n2)
   128  	}
   129  	c1.PrependLength()
   130  
   131  	n3, err := c1.GetNextN32()
   132  	if err != nil {
   133  		t.Errorf("GetNextN32() failed: %s", err)
   134  	}
   135  	if n3 != 43 {
   136  		t.Errorf("n should be 43, was %d", n3)
   137  	}
   138  	c1.PrependLength()
   139  
   140  	n4, err := c1.GetNextN64()
   141  	if err != nil {
   142  		t.Errorf("GetNextN64() failed: %s", err)
   143  	}
   144  	if n4 != 43 {
   145  		t.Errorf("n should be 43, was %d", n4)
   146  	}
   147  }
   148  
   149  func TestContainerBlockHandling(t *testing.T) {
   150  	t.Parallel()
   151  
   152  	c1 := New(utils.DuplicateBytes(testData))
   153  	c1.PrependLength()
   154  	c1.AppendAsBlock(testData)
   155  	c1c := c1.carbonCopy()
   156  
   157  	c2 := New(nil)
   158  	for i := 0; i < c1.Length(); i++ {
   159  		oneByte := make([]byte, 1)
   160  		c1c.WriteToSlice(oneByte)
   161  		c2.Append(oneByte)
   162  	}
   163  
   164  	c3 := New(testDataSplitted[0])
   165  	for i := 1; i < len(testDataSplitted); i++ {
   166  		c3.Append(testDataSplitted[i])
   167  	}
   168  	c3.PrependLength()
   169  
   170  	d1, err := c1.GetNextBlock()
   171  	if err != nil {
   172  		t.Errorf("GetNextBlock failed: %s", err)
   173  	}
   174  	d2, err := c1.GetNextBlock()
   175  	if err != nil {
   176  		t.Errorf("GetNextBlock failed: %s", err)
   177  	}
   178  	d3, err := c2.GetNextBlock()
   179  	if err != nil {
   180  		t.Errorf("GetNextBlock failed: %s", err)
   181  	}
   182  	d4, err := c2.GetNextBlock()
   183  	if err != nil {
   184  		t.Errorf("GetNextBlock failed: %s", err)
   185  	}
   186  	d5, err := c3.GetNextBlock()
   187  	if err != nil {
   188  		t.Errorf("GetNextBlock failed: %s", err)
   189  	}
   190  
   191  	compareMany(t, testData, d1, d2, d3, d4, d5)
   192  }
   193  
   194  func TestContainerMisc(t *testing.T) {
   195  	t.Parallel()
   196  
   197  	c1 := New()
   198  	d1 := c1.CompileData()
   199  	if len(d1) > 0 {
   200  		t.Fatalf("empty container should not hold any data")
   201  	}
   202  }
   203  
   204  func TestDeprecated(t *testing.T) {
   205  	t.Parallel()
   206  
   207  	NewContainer(utils.DuplicateBytes(testData))
   208  }