Support for io.EOF to C.AVERROR_EOF mapping (#73)

* Support for io.EOF to C.AVERROR_EOF mapping

* Requested changes

io_context.go

@@ -6,6 +6,7 @@ import "C"
 import (
 	"errors"
 	"fmt"
+	"io"
 	"sync"
 	"unsafe"
 )
@@ -241,6 +242,8 @@ func goAstiavIOContextReadFunc(opaque unsafe.Pointer, buf *C.uint8_t, bufSize C.
 		var e Error
 		if errors.As(err, &e) {
 			return C.int(e)
+		} else if errors.Is(err, io.EOF) {
+			return C.AVERROR_EOF
 		}
 		return C.AVERROR_UNKNOWN
 	}

io_context_test.go

@@ -1,6 +1,7 @@
 package astiav
 
 import (
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
@@ -9,34 +10,48 @@ import (
 )
 
 func TestIOContext(t *testing.T) {
-	var seeked bool
+	t.Run("read write seek", func(t *testing.T) {
-	rb := []byte("read")
+		var seeked bool
-	wb := []byte("write")
+		rb := []byte("read")
-	var written []byte
+		wb := []byte("write")
-	c, err := AllocIOContext(8, true, func(b []byte) (int, error) {
+		var written []byte
-		copy(b, rb)
+		c, err := AllocIOContext(8, true, func(b []byte) (int, error) {
-		return len(rb), nil
+			copy(b, rb)
-	}, func(offset int64, whence int) (n int64, err error) {
+			return len(rb), nil
-		seeked = true
+		}, func(offset int64, whence int) (n int64, err error) {
-		return offset, nil
+			seeked = true
-	}, func(b []byte) (int, error) {
+			return offset, nil
-		written = make([]byte, len(b))
+		}, func(b []byte) (int, error) {
-		copy(written, b)
+			written = make([]byte, len(b))
-		return len(b), nil
+			copy(written, b)
+			return len(b), nil
+		})
+		require.NoError(t, err)
+		defer c.Free()
+		b := make([]byte, 6)
+		n, err := c.Read(b)
+		require.NoError(t, err)
+		require.Equal(t, 4, n)
+		require.Equal(t, rb, b[:n])
+		_, err = c.Seek(2, 0)
+		require.NoError(t, err)
+		require.True(t, seeked)
+		c.Write(wb)
+		c.Flush()
+		require.Equal(t, wb, written)
+	})
+
+	t.Run("io.EOF is mapped to AVERROR_EOF when reading", func(t *testing.T) {
+		c, err := AllocIOContext(8, false, func(b []byte) (int, error) {
+			return 0, io.EOF
+		}, nil, nil)
+		require.NoError(t, err)
+		defer c.Free()
+		b := make([]byte, 100)
+		n, err := c.Read(b)
+		require.ErrorIs(t, err, ErrEof)
+		require.Equal(t, 0, n)
 	})
-	require.NoError(t, err)
-	defer c.Free()
-	b := make([]byte, 6)
-	n, err := c.Read(b)
-	require.NoError(t, err)
-	require.Equal(t, 4, n)
-	require.Equal(t, rb, b[:n])
-	_, err = c.Seek(2, 0)
-	require.NoError(t, err)
-	require.True(t, seeked)
-	c.Write(wb)
-	c.Flush()
-	require.Equal(t, wb, written)
 }
 
 func TestOpenIOContext(t *testing.T) {