Add some bench and little test

integrations/api_issue_test.go

@@ -5,13 +5,13 @@
 package integrations
 
 import (
+	"fmt"
 	"net/http"
 	"testing"
 
 	"code.gitea.io/gitea/models"
 	api "code.gitea.io/sdk/gitea"
 
-	"fmt"
 	"github.com/stretchr/testify/assert"
 )
 

models/git_diff.go

@@ -248,30 +248,54 @@ func ParsePatch(maxLines, maxLineCharacters, maxFiles int, reader io.Reader) (*D
 		lineCount           int
 		curFileLinesCount   int
 		curFileLFSPrefix    bool
+
+		input = bufio.NewReader(reader)
+		isEOF = false
 	)
 
-	input := bufio.NewReader(reader)
-	isEOF := false
 	for !isEOF {
 		var linebuf bytes.Buffer
 		for {
-			b, err := input.ReadByte()
+			peek, err := input.Peek(maxLineCharacters)
+			if err != nil && err != bufio.ErrBufferFull {
+				return nil, fmt.Errorf("PeekByte: %v", err)
+			}
+			newLine := bytes.IndexByte(peek, '\n')
+			if newLine == -1 {
+				// Instead of reading things, and copying memory around,
+				//  we simply discard them (which doesn't allocate memory)
+				curFile.IsIncomplete = true
+				// We already know that we can read `len(peek)` amount of bytes,
+				//  hence no error-checking
+				input.Discard(len(peek))
+				continue
+			}
+			if curFile.IsIncomplete {
+				// Since we get here without hiting the above case, we've found a newline
+				//  and only discard that part.
+				input.Discard(newLine)
+				break
+			}
+			buff := make([]byte, newLine)
+			n, err := input.Read(buff)
 			if err != nil {
 				if err == io.EOF {
 					isEOF = true
 					break
-				} else {
-					return nil, fmt.Errorf("ReadByte: %v", err)
 				}
+				return nil, fmt.Errorf("Read: %v", err)
 			}
-			if b == '\n' {
-				break
+			if n != newLine {
+				return nil, fmt.Errorf("Read: could not read enough bytes %d != %d", n, newLine)
 			}
-			if linebuf.Len() < maxLineCharacters {
-				linebuf.WriteByte(b)
-			} else if linebuf.Len() == maxLineCharacters {
-				curFile.IsIncomplete = true
+			n, err = linebuf.Write(buff)
+			if err != nil {
+				return nil, fmt.Errorf("Write: %v", err)
 			}
+			if n != newLine {
+				return nil, fmt.Errorf("Write: could not write enough bytes %d != %d", n, newLine)
+			}
+			break
 		}
 		line := linebuf.String()
 

models/git_diff_test.go

@@ -2,9 +2,13 @@ package models
 
 import (
 	"html/template"
+	"strings"
 	"testing"
 
+	"code.gitea.io/gitea/modules/log"
+
 	dmp "github.com/sergi/go-diff/diffmatchpatch"
+	"github.com/stretchr/testify/assert"
 )
 
 func assertEqual(t *testing.T, s1 string, s2 template.HTML) {
@@ -34,3 +38,72 @@ func TestDiffToHTML(t *testing.T) {
 		{Type: dmp.DiffEqual, Text: " biz"},
 	}, DiffLineDel))
 }
+
+func benchParsePatch(b *testing.B, diffStr string) {
+	log.DelLogger("console")
+	log.DelLogger("file")
+	b.ResetTimer() //Disable logger for becnh
+	for i := 0; i < b.N; i++ {
+		ParsePatch(1000, 5000, 100, strings.NewReader(diffStr))
+	}
+}
+
+func BenchmarkParsePatchSimple(b *testing.B) {
+	benchParsePatch(b, `diff --git a/integrations/api_issue_test.go b/integrations/api_issue_test.go
+index 74436ffe9..ff316cec3 100644
+--- a/integrations/api_issue_test.go
++++ b/integrations/api_issue_test.go
+@@ -5,13 +5,13 @@
+package integrations
+
+import (
++       "fmt"
+		"net/http"
+		"testing"
+
+		"code.gitea.io/gitea/models"
+		api "code.gitea.io/sdk/gitea"
+
+-       "fmt"
+		"github.com/stretchr/testify/assert"
+)
+`)
+}
+
+func TestParsePatch(t *testing.T) {
+	testCases := []struct {
+		result   error
+		files    int
+		addition int
+		deletion int
+		diff     string
+	}{
+		{nil, 1, 1, 1,
+			`diff --git a/integrations/api_issue_test.go b/integrations/api_issue_test.go
+index 74436ffe9..ff316cec3 100644
+--- a/integrations/api_issue_test.go
++++ b/integrations/api_issue_test.go
+@@ -5,13 +5,13 @@
+ package integrations
+
+ import (
++       "fmt"
+        "net/http"
+        "testing"
+
+        "code.gitea.io/gitea/models"
+        api "code.gitea.io/sdk/gitea"
+
+-       "fmt"
+        "github.com/stretchr/testify/assert"
+ )
+`},
+	}
+	for _, tc := range testCases {
+		diff, err := ParsePatch(1000, 5000, 100, strings.NewReader(tc.diff))
+		assert.Equal(t, tc.result, err)
+		assert.Equal(t, tc.files, diff.NumFiles())
+		assert.Equal(t, tc.addition, diff.TotalAddition)
+		assert.Equal(t, tc.deletion, diff.TotalDeletion)
+	}
+}