Merge pull request #23 from hayabusa-cloud/fix

fix: return ErrUnexpectedEOF on short copies

Author: hayabusa-cloud

io.go

@@ -135,7 +135,14 @@ func CopyNPolicy(dst Writer, src Reader, n int64, policy SemanticPolicy) (writte
 		return CopyN(dst, src, n)
 	}
 	lr := limitedReader{R: src, N: n}
-	return copyBufferPolicy(dst, &lr, nil, policy)
+	written, err = copyBufferPolicy(dst, &lr, nil, policy)
+	if written == n {
+		return n, nil
+	}
+	if err == nil || err == io.EOF {
+		return written, io.ErrUnexpectedEOF
+	}
+	return written, err
 }
 
 // CopyNBuffer is like CopyN but stages through buf if needed.
@@ -177,7 +184,14 @@ func CopyNBufferPolicy(dst Writer, src Reader, n int64, buf []byte, policy Seman
 		return CopyNBuffer(dst, src, n, buf)
 	}
 	lr := limitedReader{R: src, N: n}
-	return copyBufferPolicy(dst, &lr, buf, policy)
+	written, err = copyBufferPolicy(dst, &lr, buf, policy)
+	if written == n {
+		return n, nil
+	}
+	if err == nil || err == io.EOF {
+		return written, io.ErrUnexpectedEOF
+	}
+	return written, err
 }
 
 type limitedReader struct {
@@ -383,6 +397,12 @@ func copyBufferPolicy(dst Writer, src Reader, buf []byte, policy SemanticPolicy)
 						}
 						return written, ErrMore
 					}
+					// Attempt Seeker rollback on partial write with semantic error.
+					if off < nr && IsSemantic(ew) {
+						if rollbackErr := rollbackSeeker(src, off-nr); rollbackErr != nil {
+							return written, rollbackErr
+						}
+					}
 					return written, ew
 				}
 				if nw == 0 {

policy_test.go

@@ -7,6 +7,7 @@ package iox_test
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"io"
 	"testing"
 
@@ -457,22 +458,21 @@ func TestCopyPolicy_ReaderFromFastPath_More_Returns(t *testing.T) {
 		t.Fatalf("want More from ReaderFrom fast path: n=%d err=%v", n, err)
 	}
 }
-func TestCopyNPolicy_Short_NoUnexpectedEOF_NoErrShort(t *testing.T) {
+func TestCopyNPolicy_Short_ReturnsUnexpectedEOF(t *testing.T) {
 	var dst bytes.Buffer
 	// src returns fewer than N without error → UnexpectedEOF
 	src := bytes.NewBufferString("ab")
 	n, err := iox.CopyNPolicy(&dst, src, 3, iox.YieldPolicy{})
-	// Current CopyNPolicy returns underlying result directly (no UnexpectedEOF mapping)
-	if err != nil || n != 2 {
-		t.Fatalf("want (2,nil) got n=%d err=%v", n, err)
+	if err != io.ErrUnexpectedEOF || n != 2 {
+		t.Fatalf("want (2,ErrUnexpectedEOF) got n=%d err=%v", n, err)
 	}
 }
-func TestCopyNPolicy_ShortEOF_NoUnexpectedEOF(t *testing.T) {
+func TestCopyNPolicy_ShortEOF_ReturnsUnexpectedEOF(t *testing.T) {
 	var dst bytes.Buffer
 	src := bytes.NewBufferString("a")
 	n, err := iox.CopyNPolicy(&dst, src, 2, iox.YieldPolicy{})
-	if err != nil || n != 1 {
-		t.Fatalf("want (1,nil) got n=%d err=%v", n, err)
+	if err != io.ErrUnexpectedEOF || n != 1 {
+		t.Fatalf("want (1,ErrUnexpectedEOF) got n=%d err=%v", n, err)
 	}
 }
 func TestCopyNBufferPolicy_ExactN_WithBuf(t *testing.T) {
@@ -848,3 +848,79 @@ func TestTeeWriterPolicy_PrimaryWouldBlockOnceCompletes(t *testing.T) {
 		t.Fatalf("primary=%q tee=%q", p.buf.String(), tbuf.String())
 	}
 }
+
+// --- Coverage tests for uncovered patch lines ---
+
+// CopyNPolicy: non-nil/non-EOF error passthrough.
+func TestCopyNPolicy_ErrorPassthrough(t *testing.T) {
+	readErr := errors.New("read-fail")
+	src := &dataThenErrReader{data: []byte("a"), err: readErr}
+	var dst bytes.Buffer
+	n, err := iox.CopyNPolicy(&dst, src, 5, iox.YieldPolicy{})
+	if !errors.Is(err, readErr) || n != 1 {
+		t.Fatalf("want (1, read-fail) got (%d, %v)", n, err)
+	}
+}
+
+// CopyNBufferPolicy: short copy → ErrUnexpectedEOF.
+func TestCopyNBufferPolicy_Short_ReturnsUnexpectedEOF(t *testing.T) {
+	src := bytes.NewBufferString("ab")
+	var dst bytes.Buffer
+	buf := make([]byte, 4)
+	n, err := iox.CopyNBufferPolicy(&dst, src, 5, buf, iox.YieldPolicy{})
+	if err != io.ErrUnexpectedEOF || n != 2 {
+		t.Fatalf("want (2, ErrUnexpectedEOF) got (%d, %v)", n, err)
+	}
+}
+
+// CopyNBufferPolicy: non-nil/non-EOF error passthrough.
+func TestCopyNBufferPolicy_ErrorPassthrough(t *testing.T) {
+	readErr := errors.New("read-fail")
+	src := &dataThenErrReader{data: []byte("x"), err: readErr}
+	var dst bytes.Buffer
+	buf := make([]byte, 4)
+	n, err := iox.CopyNBufferPolicy(&dst, src, 5, buf, iox.YieldPolicy{})
+	if !errors.Is(err, readErr) || n != 1 {
+		t.Fatalf("want (1, read-fail) got (%d, %v)", n, err)
+	}
+}
+
+// wrappedWBWriter returns a wrapped ErrWouldBlock (passes IsSemantic but not ==).
+type wrappedWBWriter struct {
+	n int
+}
+
+func (w *wrappedWBWriter) Write(p []byte) (int, error) {
+	// Partial write with wrapped semantic error.
+	n := w.n
+	if n > len(p) {
+		n = len(p)
+	}
+	return n, fmt.Errorf("wrapped: %w", iox.ErrWouldBlock)
+}
+
+// seekableReader wraps bytes.Reader but hides WriterTo so the slow path is used.
+type seekableReader struct {
+	r *bytes.Reader
+}
+
+func (s *seekableReader) Read(p []byte) (int, error) { return s.r.Read(p) }
+func (s *seekableReader) Seek(offset int64, whence int) (int64, error) {
+	return s.r.Seek(offset, whence)
+}
+
+// copyBufferPolicy: wrapped semantic write error triggers IsSemantic rollback.
+func TestCopyPolicy_SlowPath_WrappedSemanticWrite_Rollback(t *testing.T) {
+	src := &seekableReader{r: bytes.NewReader([]byte("abcd"))}
+	dst := &wrappedWBWriter{n: 1}
+	pol := &recPolicy{}
+	n, err := iox.CopyPolicy(dst, src, pol)
+	if !iox.IsWouldBlock(err) || n != 1 {
+		t.Fatalf("want (1, wrapped-WouldBlock) got (%d, %v)", n, err)
+	}
+	// Verify src was rolled back: position should be at 1 (1 written, rolled back 3).
+	pos, _ := src.Seek(0, io.SeekCurrent)
+	if pos != 1 {
+		t.Fatalf("want src position 1 after rollback, got %d", pos)
+	}
+}