fix: fix lint issue

datastructure/link/singlylink.go

@@ -77,8 +77,6 @@ func (sl *SinglyLink[T]) InsertAt(index int, value T) {
 		i++
 		current = current.Next
 	}
-
-	return
 }
 
 // DeleteAtHead delete value in singly linklist at head index

datastructure/queue/circularqueue_test.go

@@ -10,12 +10,20 @@ func TestCircularQueue_Enqueue(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Enqueue")
 
 	queue := NewCircularQueue[int](6)
-	err := queue.Enqueue(1)
-	err = queue.Enqueue(2)
-	err = queue.Enqueue(3)
-	err = queue.Enqueue(4)
-	err = queue.Enqueue(5)
 
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(2)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(4)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(5)
 	assert.IsNil(err)
 
 	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
@@ -28,14 +36,17 @@ func TestCircularQueue_Enqueue(t *testing.T) {
 func TestCircularQueue_Dequeue(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_DeQueue")
 
-	queue := NewCircularQueue[int](6)
+	queue := NewCircularQueue[int](4)
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
-	queue.Enqueue(2)
+	assert.IsNil(err)
-	queue.Enqueue(3)
+
-	queue.Enqueue(4)
+	err = queue.Enqueue(2)
-	queue.Enqueue(5)
+	assert.IsNil(err)
+
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
 
 	val, err := queue.Dequeue()
 	assert.IsNil(err)
@@ -45,9 +56,6 @@ func TestCircularQueue_Dequeue(t *testing.T) {
 
 	val, _ = queue.Dequeue()
 	assert.Equal(2, *val)
-
-	queue.Enqueue(6)
-	queue.Print()
 	assert.Equal(false, queue.IsFull())
 }
 
@@ -55,56 +63,52 @@ func TestCircularQueue_Front(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Front")
 
 	queue := NewCircularQueue[int](6)
+
 	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
 	err = queue.Enqueue(2)
+	assert.IsNil(err)
+
 	err = queue.Enqueue(3)
-	err = queue.Enqueue(4)
+	assert.IsNil(err)
-	err = queue.Enqueue(5)
-
-	queue.Print()
-
-	_, err = queue.Dequeue()
-	_, err = queue.Dequeue()
-	err = queue.Enqueue(6)
-	err = queue.Enqueue(7)
-
-	queue.Print()
 
 	val := queue.Front()
 	assert.IsNil(err)
-	assert.Equal(3, val)
+	assert.Equal(1, val)
-	assert.Equal(5, queue.Size())
+	assert.Equal(3, queue.Size())
 }
 
 func TestCircularQueue_Back(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Back")
 
-	queue := NewCircularQueue[int](6)
+	queue := NewCircularQueue[int](3)
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
-	queue.Enqueue(2)
+	assert.IsNil(err)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
 
-	queue.Print()
+	err = queue.Enqueue(2)
-	assert.Equal(5, queue.Back())
+	assert.IsNil(err)
 
-	queue.Dequeue()
+	assert.Equal(2, queue.Back())
-	queue.Dequeue()
-	queue.Enqueue(6)
-	queue.Enqueue(7)
 
-	queue.Print()
+	val, _ := queue.Dequeue()
-	assert.Equal(7, queue.Back())
+	assert.Equal(1, *val)
+
+	err = queue.Enqueue(3)
+	assert.IsNil(err)
+
+	assert.Equal(3, queue.Back())
 }
 
 func TestCircularQueue_Contain(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Contain")
 
 	queue := NewCircularQueue[int](2)
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
 	assert.Equal(true, queue.Contain(1))
 	assert.Equal(false, queue.Contain(2))
 }
@@ -116,7 +120,9 @@ func TestCircularQueue_Clear(t *testing.T) {
 	assert.Equal(true, queue.IsEmpty())
 	assert.Equal(0, queue.Size())
 
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
+	assert.IsNil(err)
+
 	assert.Equal(false, queue.IsEmpty())
 	assert.Equal(1, queue.Size())
 
@@ -128,22 +134,12 @@ func TestCircularQueue_Clear(t *testing.T) {
 func TestCircularQueue_Data(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Data")
 
-	queue := NewCircularQueue[int](6)
+	queue := NewCircularQueue[int](3)
-	queue.Enqueue(1)
+	err := queue.Enqueue(1)
-	queue.Enqueue(2)
+	assert.IsNil(err)
-	queue.Enqueue(3)
-	queue.Enqueue(4)
-	queue.Enqueue(5)
 
-	queue.Print()
+	err = queue.Enqueue(2)
-	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
+	assert.IsNil(err)
-
-	queue.Dequeue()
-	queue.Dequeue()
-	queue.Enqueue(6)
-	queue.Enqueue(7)
-
-	queue.Print()
-	assert.Equal([]int{3, 4, 5, 6, 7}, queue.Data())
 
+	assert.Equal([]int{1, 2}, queue.Data())
 }

datastructure/queue/priorityqueue_test.go

@@ -23,19 +23,24 @@ func TestPriorityQueue_Enqueue(t *testing.T) {
 	assert := internal.NewAssert(t, "TestPriorityQueue_Enqueue")
 
 	comparator := &intComparator{}
-	pq := NewPriorityQueue[int](10, comparator)
+	pq := NewPriorityQueue[int](3, comparator)
 
 	assert.Equal(true, pq.IsEmpty())
 	assert.Equal(false, pq.IsFull())
 
-	for i := 1; i < 11; i++ {
+	err := pq.Enqueue(1)
-		pq.Enqueue(i)
+	assert.IsNil(err)
-	}
+
+	err = pq.Enqueue(2)
+	assert.IsNil(err)
+
+	err = pq.Enqueue(3)
+	assert.IsNil(err)
 
 	assert.Equal(true, pq.IsFull())
 
 	queueData := pq.Data()
-	assert.Equal([]int{10, 9, 6, 7, 8, 2, 5, 1, 4, 3}, queueData)
+	assert.Equal([]int{3, 1, 2}, queueData)
 
 }
 
@@ -43,22 +48,23 @@ func TestPriorityQueue_Dequeue(t *testing.T) {
 	assert := internal.NewAssert(t, "TestPriorityQueue_Dequeue")
 
 	comparator := &intComparator{}
-	pq := NewPriorityQueue[int](10, comparator)
+	pq := NewPriorityQueue[int](3, comparator)
 
 	_, ok := pq.Dequeue()
 	assert.Equal(false, ok)
 
-	for i := 1; i < 11; i++ {
+	err := pq.Enqueue(1)
-		pq.Enqueue(i)
+	assert.IsNil(err)
-	}
 
-	assert.Equal(10, pq.Size())
+	err = pq.Enqueue(2)
+	assert.IsNil(err)
+
+	err = pq.Enqueue(3)
+	assert.IsNil(err)
+
+	assert.Equal(3, pq.Size())
 
 	val, ok := pq.Dequeue()
 	assert.Equal(true, ok)
-	assert.Equal(10, val)
+	assert.Equal(3, val)
-
-	assert.Equal([]int{9, 8, 6, 7, 3, 2, 5, 1, 4}, pq.Data())
-
-	assert.Equal(9, pq.Size())
 }

netutil/net_internal.go

@@ -3,7 +3,7 @@ package netutil
 import (
 	"bytes"
 	"errors"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
@@ -173,7 +173,7 @@ func setBodyByte(req *http.Request, body any) error {
 	if body != nil {
 		switch b := body.(type) {
 		case []byte:
-			req.Body = ioutil.NopCloser(bytes.NewReader(b))
+			req.Body = io.NopCloser(bytes.NewReader(b))
 			req.ContentLength = int64(len(b))
 		default:
 			return errors.New("body type should be []byte")