test: make createHash a test helper, don't call in examples

This makes a bit more of the test suite execute without panicking when run
without permissions. Running the examples will still panic.

createHash() is not expanded when reading the examples in GoDoc, making them
less useful for new readers. Replace it with a call to NewMap() with all
MapSpec parameters visible.

Signed-off-by: Timo Beckers <[email protected]>

Author: ti-mo

collection_test.go

@@ -586,6 +586,10 @@ func TestIncompleteLoadAndAssign(t *testing.T) {
 		t.Fatal("expected error loading invalid ProgramSpec")
 	}
 
+	if s.Valid == nil {
+		t.Fatal("expected valid prog to be non-nil")
+	}
+
 	if fd := s.Valid.FD(); fd != -1 {
 		t.Fatal("expected valid prog to have closed fd -1, got:", fd)
 	}

map_test.go

@@ -31,6 +31,21 @@ var (
 	}
 )
 
+// newHash returns a new Map of type Hash. Cleanup is handled automatically.
+func newHash(t *testing.T) *Map {
+	hash, err := NewMap(&MapSpec{
+		Type:       Hash,
+		KeySize:    5,
+		ValueSize:  4,
+		MaxEntries: 10,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { hash.Close() })
+	return hash
+}
+
 func TestMap(t *testing.T) {
 	m := createArray(t)
 	defer m.Close()
@@ -1214,8 +1229,7 @@ func TestMapGuessNonExistentKey(t *testing.T) {
 }
 
 func TestNotExist(t *testing.T) {
-	hash := createHash()
-	defer hash.Close()
+	hash := newHash(t)
 
 	var tmp uint32
 	err := hash.Lookup("hello", &tmp)
@@ -1246,8 +1260,7 @@ func TestNotExist(t *testing.T) {
 }
 
 func TestExist(t *testing.T) {
-	hash := createHash()
-	defer hash.Close()
+	hash := newHash(t)
 
 	if err := hash.Put("hello", uint32(21)); err != nil {
 		t.Errorf("Failed to put key/value pair into hash: %v", err)
@@ -1611,8 +1624,8 @@ func TestMapGetNextID(t *testing.T) {
 	var next MapID
 	var err error
 
-	hash := createHash()
-	defer hash.Close()
+	// Ensure there is at least one map on the system.
+	_ = newHash(t)
 
 	if next, err = MapGetNextID(MapID(0)); err != nil {
 		t.Fatal("Can't get next ID:", err)
@@ -1638,8 +1651,7 @@ func TestMapGetNextID(t *testing.T) {
 }
 
 func TestNewMapFromID(t *testing.T) {
-	hash := createHash()
-	defer hash.Close()
+	hash := newHash(t)
 
 	info, err := hash.Info()
 	testutils.SkipIfNotSupported(t, err)
@@ -1985,7 +1997,15 @@ func ExampleMap_perCPU() {
 // Note that using unsafe.Pointer is only marginally faster than
 // implementing Marshaler on the type.
 func ExampleMap_zeroCopy() {
-	hash := createHash()
+	hash, err := NewMap(&MapSpec{
+		Type:       Hash,
+		KeySize:    5,
+		ValueSize:  4,
+		MaxEntries: 10,
+	})
+	if err != nil {
+		panic(err)
+	}
 	defer hash.Close()
 
 	key := [5]byte{'h', 'e', 'l', 'l', 'o'}
@@ -2004,7 +2024,7 @@ func ExampleMap_zeroCopy() {
 	// Output: The value is: 23
 }
 
-func createHash() *Map {
+func ExampleMap_NextKey() {
 	hash, err := NewMap(&MapSpec{
 		Type:       Hash,
 		KeySize:    5,
@@ -2014,11 +2034,6 @@ func createHash() *Map {
 	if err != nil {
 		panic(err)
 	}
-	return hash
-}
-
-func ExampleMap_NextKey() {
-	hash := createHash()
 	defer hash.Close()
 
 	if err := hash.Put("hello", uint32(21)); err != nil {
@@ -2045,7 +2060,15 @@ func ExampleMap_NextKey() {
 // ExampleMap_Iterate demonstrates how to iterate over all entries
 // in a map.
 func ExampleMap_Iterate() {
-	hash := createHash()
+	hash, err := NewMap(&MapSpec{
+		Type:       Hash,
+		KeySize:    5,
+		ValueSize:  4,
+		MaxEntries: 10,
+	})
+	if err != nil {
+		panic(err)
+	}
 	defer hash.Close()
 
 	if err := hash.Put("hello", uint32(21)); err != nil {

marshaler_example_test.go

@@ -27,7 +27,15 @@ func (ce *customEncoding) UnmarshalBinary(buf []byte) error {
 
 // ExampleMarshaler shows how to use custom encoding with map methods.
 func Example_customMarshaler() {
-	hash := createHash()
+	hash, err := NewMap(&MapSpec{
+		Type:       Hash,
+		KeySize:    5,
+		ValueSize:  4,
+		MaxEntries: 10,
+	})
+	if err != nil {
+		panic(err)
+	}
 	defer hash.Close()
 
 	if err := hash.Put(&customEncoding{"hello"}, uint32(111)); err != nil {

prog_test.go

@@ -441,7 +441,7 @@ func TestProgramVerifierLogTruncated(t *testing.T) {
 		}
 		var ve *internal.VerifierError
 		if !errors.As(err, &ve) {
-			t.Error("Error is not a VerifierError")
+			t.Fatal("Error is not a VerifierError")
 		}
 		if !ve.Truncated {
 			t.Errorf("VerifierError is not truncated: %+v", ve)