Fix issues reported by golangsci-lint

dtls/client.go

@@ -80,7 +80,7 @@ func Client(conn *dtls.Conn, opts ...udp.Option) *udpClient.Conn {
 		errorsFunc(fmt.Errorf("dtls: %v: %w", conn.RemoteAddr(), err))
 	}
 
-	createBlockWise := func(cc *udpClient.Conn) *blockwise.BlockWise[*udpClient.Conn] {
+	createBlockWise := func(*udpClient.Conn) *blockwise.BlockWise[*udpClient.Conn] {
 		return nil
 	}
 	if cfg.BlockwiseEnable {

dtls/client_test.go

@@ -207,7 +207,7 @@ func TestConnGetSeparateMessage(t *testing.T) {
 		require.NoError(t, errS)
 	}()
 
-	cc, err := dtls.Dial(l.Addr().String(), dtlsCfg, options.WithHandlerFunc(func(w *responsewriter.ResponseWriter[*client.Conn], r *pool.Message) {
+	cc, err := dtls.Dial(l.Addr().String(), dtlsCfg, options.WithHandlerFunc(func(_ *responsewriter.ResponseWriter[*client.Conn], r *pool.Message) {
 		assert.NoError(t, fmt.Errorf("none msg expected comes: %+v", r))
 	}))
 	require.NoError(t, err)

dtls/server/config.go

@@ -20,7 +20,7 @@ type HandlerFunc = func(*responsewriter.ResponseWriter[*udpClient.Conn], *pool.M
 type ErrorFunc = func(error)
 
 // OnNewConnFunc is the callback for new connections.
-type OnNewConnFunc = func(cc *udpClient.Conn)
+type OnNewConnFunc = func(*udpClient.Conn)
 
 type GetMIDFunc = func() int32
 
@@ -34,10 +34,10 @@ var DefaultConfig = func() Config {
 			}
 			return inactivity.New(timeout, onInactive)
 		},
-		RequestMonitor: func(cc *udpClient.Conn, req *pool.Message) (bool, error) {
+		RequestMonitor: func(*udpClient.Conn, *pool.Message) (bool, error) {
 			return false, nil
 		},
-		OnNewConn: func(cc *udpClient.Conn) {
+		OnNewConn: func(*udpClient.Conn) {
 			// do nothing by default
 		},
 		TransmissionNStart:             1,
@@ -46,7 +46,7 @@ var DefaultConfig = func() Config {
 		GetMID:                         message.GetMID,
 		MTU:                            udpClient.DefaultMTU,
 	}
-	opts.Handler = func(w *responsewriter.ResponseWriter[*udpClient.Conn], r *pool.Message) {
+	opts.Handler = func(w *responsewriter.ResponseWriter[*udpClient.Conn], _ *pool.Message) {
 		if err := w.SetResponse(codes.NotFound, message.TextPlain, nil); err != nil {
 			opts.Errors(fmt.Errorf("dtls server: cannot set response: %w", err))
 		}

dtls/server/server.go

@@ -188,7 +188,7 @@ func (s *Server) Stop() {
 }
 
 func (s *Server) createConn(connection *coapNet.Conn, inactivityMonitor udpClient.InactivityMonitor, requestMonitor udpClient.RequestMonitorFunc) *udpClient.Conn {
-	createBlockWise := func(cc *udpClient.Conn) *blockwise.BlockWise[*udpClient.Conn] {
+	createBlockWise := func(*udpClient.Conn) *blockwise.BlockWise[*udpClient.Conn] {
 		return nil
 	}
 	if s.cfg.BlockwiseEnable {

message/codes/codes_test.go

@@ -93,7 +93,7 @@ func FuzzUnmarshalJSON(f *testing.F) {
 	f.Add([]byte("0x2a"))
 	f.Add([]byte("42"))
 
-	f.Fuzz(func(t *testing.T, input_data []byte) {
+	f.Fuzz(func(_ *testing.T, input_data []byte) {
 		var got Code
 		_ = got.UnmarshalJSON(input_data)
 	})

message/options_test.go

@@ -352,7 +352,7 @@ func TestQueryOption(t *testing.T) {
 }
 
 func FuzzUnmarshalData(f *testing.F) {
-	f.Fuzz(func(t *testing.T, input_data []byte) {
+	f.Fuzz(func(_ *testing.T, input_data []byte) {
 		uoptions := make(Options, 0, 10)
 		_, _ = uoptions.Unmarshal(input_data, CoapOptionDefs)
 	})

mux/example_logging_middleware_test.go

@@ -16,7 +16,7 @@ func loggingMiddleware(next mux.Handler) mux.Handler {
 
 func Example_authenticationMiddleware() {
 	r := mux.NewRouter()
-	r.HandleFunc("/", func(w mux.ResponseWriter, r *mux.Message) {
+	r.HandleFunc("/", func(mux.ResponseWriter, *mux.Message) {
 		// Do something here
 	})
 	r.Use(loggingMiddleware)

mux/router.go

@@ -74,7 +74,7 @@ func NewRouter() *Router {
 		m: new(sync.RWMutex),
 		z: make(map[string]Route),
 	}
-	router.defaultHandler = HandlerFunc(func(w ResponseWriter, m *Message) {
+	router.defaultHandler = HandlerFunc(func(w ResponseWriter, _ *Message) {
 		if err := w.SetResponse(codes.NotFound, message.TextPlain, nil); err != nil {
 			router.errors(fmt.Errorf("router handler: cannot set response: %w", err))
 		}

mux/router_test.go

@@ -111,7 +111,7 @@ func TestMux(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.title, func(t *testing.T) {
-			r.HandleFunc(test.pathTemplate, func(w mux.ResponseWriter, r *mux.Message) {})
+			r.HandleFunc(test.pathTemplate, func(mux.ResponseWriter, *mux.Message) {})
 			testRegexp(t, r, test)
 			testRoute(t, r, test)
 			err := r.HandleRemove(test.pathTemplate)

net/blockwise/blockwise.go

@@ -163,7 +163,7 @@ func New[C Client](
 	getSentRequestFromOutside func(token message.Token) (*pool.Message, bool),
 ) *BlockWise[C] {
 	if getSentRequestFromOutside == nil {
-		getSentRequestFromOutside = func(token message.Token) (*pool.Message, bool) { return nil, false }
+		getSentRequestFromOutside = func(message.Token) (*pool.Message, bool) { return nil, false }
 	}
 	return &BlockWise[C]{
 		cc:                        cc,

net/blockwise/blockwise_test.go

@@ -81,7 +81,7 @@ func makeDo[C Client](t *testing.T, sender, receiver *BlockWise[C], senderMaxSZX
 				receiver.Handle(receiverResp, roReq, senderMaxSZX, senderMaxMessageSize, next)
 				t.Logf("receiver.Handle - receiverResp %v senderResp.Message: %v\n", receiverResp.Message(), roReq)
 				senderResp := responsewriter.New(sender.cc.AcquireMessage(roReq.Context()), sender.cc)
-				sender.Handle(senderResp, receiverResp.Message(), receiverMaxSZX, receiverMaxMessageSize, func(w *responsewriter.ResponseWriter[C], r *pool.Message) {
+				sender.Handle(senderResp, receiverResp.Message(), receiverMaxSZX, receiverMaxMessageSize, func(_ *responsewriter.ResponseWriter[C], r *pool.Message) {
 					resp = r
 				})
 				t.Logf("sender.Handle - senderResp %v receiverResp.Message: %v\n", senderResp.Message(), receiverResp.Message())
@@ -503,7 +503,7 @@ func makeWriteReq[C Client](sender, receiver *BlockWise[C], senderMaxSZX SZX, se
 				})
 				senderResp := responsewriter.New(sender.cc.AcquireMessage(roReq.Context()), sender.cc)
 				orig := senderResp.Message()
-				sender.Handle(senderResp, receiverResp.Message(), receiverMaxSZX, receiverMaxMessageSize, func(w *responsewriter.ResponseWriter[C], r *pool.Message) {
+				sender.Handle(senderResp, receiverResp.Message(), receiverMaxSZX, receiverMaxMessageSize, func(*responsewriter.ResponseWriter[C], *pool.Message) {
 				})
 				if orig == senderResp.Message() {
 					select {
@@ -552,7 +552,7 @@ func TestBlockWiseWriteTestMessage(t *testing.T) {
 				},
 				szx:            SZX16,
 				maxMessageSize: SZX16.Size(),
-				writetestmessage: makeWriteReq(sender, receiver, SZX16, uint32(SZX16.Size()), SZX16, uint32(SZX16.Size()), func(w *responsewriter.ResponseWriter[*testClient], r *pool.Message) {
+				writetestmessage: makeWriteReq(sender, receiver, SZX16, uint32(SZX16.Size()), SZX16, uint32(SZX16.Size()), func(_ *responsewriter.ResponseWriter[*testClient], r *pool.Message) {
 					require.NoError(t, fmt.Errorf("not expected received message: %+v", r))
 				}),
 			},
@@ -569,7 +569,7 @@ func TestBlockWiseWriteTestMessage(t *testing.T) {
 				},
 				szx:            SZX16,
 				maxMessageSize: SZX16.Size(),
-				writetestmessage: makeWriteReq(sender, receiver, SZX16, uint32(SZX16.Size()), SZX1024, uint32(SZX1024.Size()), func(w *responsewriter.ResponseWriter[*testClient], r *pool.Message) {
+				writetestmessage: makeWriteReq(sender, receiver, SZX16, uint32(SZX16.Size()), SZX1024, uint32(SZX1024.Size()), func(_ *responsewriter.ResponseWriter[*testClient], r *pool.Message) {
 					require.Equal(t, &testmessage{
 						ctx:     context.Background(),
 						token:   []byte{2},
@@ -592,7 +592,7 @@ func TestBlockWiseWriteTestMessage(t *testing.T) {
 				},
 				szx:            SZXBERT,
 				maxMessageSize: SZXBERT.Size() * 2,
-				writetestmessage: makeWriteReq(sender, receiver, SZXBERT, uint32(SZXBERT.Size()*2), SZXBERT, uint32(SZXBERT.Size()*5), func(w *responsewriter.ResponseWriter[*testClient], r *pool.Message) {
+				writetestmessage: makeWriteReq(sender, receiver, SZXBERT, uint32(SZXBERT.Size()*2), SZXBERT, uint32(SZXBERT.Size()*5), func(_ *responsewriter.ResponseWriter[*testClient], r *pool.Message) {
 					require.Equal(t, &testmessage{
 						ctx:     context.Background(),
 						token:   []byte{'B', 'E', 'R', 'T'},

net/client/limitParallelRequests/limitParallelRequests_test.go

@@ -46,9 +46,8 @@ func TestLimitParallelRequestsDo(t *testing.T) {
 		req           []*pool.Message
 	}
 	tests := []struct {
-		name         string
-		args         args
-		expNumReqIds int
+		name string
+		args args
 	}{
 		{
 			name: "limit 1 endpointLimit 1",
@@ -66,7 +65,6 @@ func TestLimitParallelRequestsDo(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "limit n endpointLimit 1",
@@ -84,7 +82,6 @@ func TestLimitParallelRequestsDo(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "limit 1 endpointLimit n",
@@ -102,7 +99,6 @@ func TestLimitParallelRequestsDo(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "limit n endpointLimit n",
@@ -120,7 +116,6 @@ func TestLimitParallelRequestsDo(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "context canceled",
@@ -138,7 +133,6 @@ func TestLimitParallelRequestsDo(t *testing.T) {
 					newReq(ctx, t), newReq(canceledCtx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 16,
 		},
 	}
 	for _, tt := range tests {
@@ -173,9 +167,8 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 		req           []*pool.Message
 	}
 	tests := []struct {
-		name         string
-		args         args
-		expNumReqIds int
+		name string
+		args args
 	}{
 		{
 			name: "limit 1 endpointLimit 1",
@@ -193,7 +186,6 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "limit n endpointLimit 1",
@@ -211,7 +203,6 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "limit 1 endpointLimit n",
@@ -229,7 +220,6 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "limit n endpointLimit n",
@@ -247,7 +237,6 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 					newReq(ctx, t), newReq(ctx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 24,
 		},
 		{
 			name: "context canceled",
@@ -265,7 +254,6 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 					newReq(ctx, t), newReq(canceledCtx, t), newReq(ctx, t),
 				},
 			},
-			expNumReqIds: 16,
 		},
 	}
 	for _, tt := range tests {
@@ -278,7 +266,7 @@ func TestLimitParallelRequestsDoObserve(t *testing.T) {
 				req.SetMessageID(int32(idx))
 				go func(r *pool.Message) {
 					defer wg.Done()
-					_, err := c.DoObserve(r, func(req *pool.Message) {
+					_, err := c.DoObserve(r, func(*pool.Message) {
 						// do nothing
 					})
 					require.Error(t, err)

net/connUDP.go

@@ -220,7 +220,7 @@ func IsIPv6(addr net.IP) bool {
 }
 
 var DefaultUDPConnConfig = UDPConnConfig{
-	Errors: func(err error) {
+	Errors: func(error) {
 		// don't log any error from fails for multicast requests
 	},
 }

net/tlslistener_test.go

@@ -31,13 +31,13 @@ func SetTLSConfig(t *testing.T) *tls.Config {
 		ClientCAs:    caRootPool,
 		RootCAs:      caRootPool,
 
-		GetConfigForClient: func(info *tls.ClientHelloInfo) (*tls.Config, error) {
+		GetConfigForClient: func(*tls.ClientHelloInfo) (*tls.Config, error) {
 			// https://github.com/golang/go/issues/29895
 			m := tls.Config{
 				Certificates: []tls.Certificate{cert},
 				ClientAuth:   tls.RequireAnyClientCert,
 			}
-			m.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
+			m.VerifyPeerCertificate = func([][]byte, [][]*x509.Certificate) error {
 				return nil
 			}
 			return &m, nil
@@ -192,7 +192,7 @@ func TestTLSListenerCheckForInfinitLoop(t *testing.T) {
 				tlsConn := tls.Client(conn, &tls.Config{
 					InsecureSkipVerify: true,
 					Certificates:       []tls.Certificate{cert},
-					VerifyPeerCertificate: func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
+					VerifyPeerCertificate: func([][]byte, [][]*x509.Certificate) error {
 						errC := conn.Close()
 						require.NoError(t, errC)
 						return nil

pkg/cache/cache_test.go

@@ -72,7 +72,7 @@ func TestElementExpiration(t *testing.T) {
 	cache := NewCache[string, string]()
 
 	elementToCache := string("elem")
-	elem := NewElement(elementToCache, time.Now().Add(1*time.Second), func(d string) {
+	elem := NewElement(elementToCache, time.Now().Add(1*time.Second), func(string) {
 		expirationInvoked = true
 	})
 	loadedElem, _ := cache.LoadOrStore("abcd", elem)
@@ -141,7 +141,7 @@ func TestPullOutAllFunction(t *testing.T) {
 	cache.LoadAndDeleteAll()
 
 	foundElements := 0
-	cache.Range(func(key string, value *Element[string]) bool {
+	cache.Range(func(string, *Element[string]) bool {
 		foundElements++
 		return true
 	})

pkg/connections/connections.go

@@ -31,7 +31,7 @@ func (c *Connections) Store(conn Connection) {
 
 func (c *Connections) length() int {
 	var l int
-	c.data.Range(func(k, v interface{}) bool {
+	c.data.Range(func(_, _ interface{}) bool {
 		l++
 		return true
 	})
@@ -40,7 +40,7 @@ func (c *Connections) length() int {
 
 func (c *Connections) copyConnections() []Connection {
 	m := make([]Connection, 0, c.length())
-	c.data.Range(func(key, value interface{}) bool {
+	c.data.Range(func(_, value interface{}) bool {
 		con, ok := value.(Connection)
 		if !ok {
 			panic(fmt.Errorf("invalid type %T in connections map", con))

pkg/sync/map_test.go

@@ -76,7 +76,7 @@ func TestLoadOrStore(t *testing.T) {
 	}
 
 	newV := "forty two"
-	v1, l1 := m.LoadOrStoreWithFunc(42, func(value string) string {
+	v1, l1 := m.LoadOrStoreWithFunc(42, func(string) string {
 		require.FailNow(t, "unexpected load call")
 		return ""
 	}, func() string {
@@ -142,15 +142,15 @@ func TestReplace(t *testing.T) {
 	require.True(t, ok)
 	require.Equal(t, src[1], oldV)
 
-	oldV, ok = m.ReplaceWithFunc(1, func(oldValue string, oldLoaded bool) (string, bool) {
+	oldV, ok = m.ReplaceWithFunc(1, func(string, bool) (string, bool) {
 		return "", true
 	})
 	require.True(t, ok)
 	require.Equal(t, newV, oldV)
 	require.Equal(t, len(src)-1, m.Length())
 
 	newV = "forty two"
-	_, ok = m.ReplaceWithFunc(42, func(oldValue string, oldLoaded bool) (string, bool) {
+	_, ok = m.ReplaceWithFunc(42, func(string, bool) (string, bool) {
 		return newV, false
 	})
 	require.False(t, ok)
@@ -175,7 +175,7 @@ func TestDelete(t *testing.T) {
 	_, ok := m.Load(1)
 	require.False(t, ok)
 
-	m.DeleteWithFunc(1, func(value string) {
+	m.DeleteWithFunc(1, func(string) {
 		require.FailNow(t, "unexpected deleted value")
 	})
 

tcp/client.go

@@ -69,7 +69,7 @@ func Client(conn net.Conn, opts ...Option) *client.Conn {
 		errorsFunc(fmt.Errorf("tcp: %w", err))
 	}
 
-	createBlockWise := func(cc *client.Conn) *blockwise.BlockWise[*client.Conn] {
+	createBlockWise := func(*client.Conn) *blockwise.BlockWise[*client.Conn] {
 		return nil
 	}
 	if cfg.BlockwiseEnable {