Add support for parsing git trailers #614
|
|
@ -0,0 +1,42 @@
|
|||
|
|
||||
package git
|
||||
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
/*
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
#include <git2.h>
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
*/
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
import "C"
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
import (
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
"runtime"
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
"unsafe"
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
)
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
// Trailer represents a single git message trailer.
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
type Trailer struct {
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
Key string
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
Value string
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
}
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
// MessageTrailers parses trailers out of a message, returning a slice of
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
// Trailer structs. Trailers are key/value pairs in the last paragraph of a
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
// message, not including any patches or conflicts that may be present.
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
func MessageTrailers(message string) ([]Trailer, error) {
|
||||
|
Can the docstrings from libgit2 be copied (+adapted) as the golang docstrings? For example, this could be Same for Can the docstrings from [libgit2](https://libgit2.org/libgit2/#HEAD/group/message/git_message_trailers) be copied (+adapted) as the golang docstrings? For example, this could be
```go
// MessageTrailers parses trailers out of a message. Trailers are key/value
// pairs in the last paragraph of a message, not including any patches or
// conflicts that may be present.
```
Same for `Trailer` above in L12 (from https://github.com/libgit2/libgit2/blob/849f371ea89257512ef505d0094d77b1ec812c53/include/git2/message.h#L41)
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
var trailersC C.git_message_trailer_array
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
messageC := C.CString(message)
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
defer C.free(unsafe.Pointer(messageC))
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
runtime.LockOSThread()
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
defer runtime.UnlockOSThread()
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
ecode := C.git_message_trailers(&trailersC, messageC)
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
if ecode < 0 {
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
return nil, MakeGitError(ecode)
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
}
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
defer C.git_message_trailer_array_free(&trailersC)
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
trailers := make([]Trailer, trailersC.count)
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
var trailer *C.git_message_trailer
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i+1, p+unsafe.Sizeof(C.git_message_trailer{}) {
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
trailer = (*C.git_message_trailer)(unsafe.Pointer(p))
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
trailers[i] = Trailer{Key: C.GoString(trailer.key), Value: C.GoString(trailer.value)}
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
}
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
return trailers, nil
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
}
|
||||
|
minor nit: (if this was copied from another file, let me know which one and we'll fix that later). minor nit:
```suggestion
```
(if this was copied from another file, let me know which one and we'll fix that later).
maybe for a tiny bit more symmetry between the initialization and post-steps. maybe
```suggestion
for i, p := 0, uintptr(unsafe.Pointer(trailersC.trailers)); i < int(trailersC.count); i, p = i + 1, p + unsafe.Sizeof(C.git_message_trailer{}) {
```
for a tiny bit more symmetry between the initialization and post-steps.
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
package git
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTrailers(t *testing.T) {
|
||||
t.Parallel()
|
||||
tests := []struct {
|
||||
input string
|
||||
expected []Trailer
|
||||
}{
|
||||
{
|
||||
"commit with zero trailers\n",
|
||||
[]Trailer{},
|
||||
},
|
||||
{
|
||||
"commit with one trailer\n\nCo-authored-by: Alice <alice@example.com>\n",
|
||||
[]Trailer{
|
||||
Trailer{Key: "Co-authored-by", Value: "Alice <alice@example.com>"},
|
||||
},
|
||||
},
|
||||
{
|
||||
"commit with two trailers\n\nCo-authored-by: Alice <alice@example.com>\nSigned-off-by: Bob <bob@example.com>\n",
|
||||
[]Trailer{
|
||||
Trailer{Key: "Co-authored-by", Value: "Alice <alice@example.com>"},
|
||||
Trailer{Key: "Signed-off-by", Value: "Bob <bob@example.com>"}},
|
||||
},
|
||||
}
|
||||
for _, test := range tests {
|
||||
fmt.Printf("%s", test.input)
|
||||
actual, err := MessageTrailers(test.input)
|
||||
if err != nil {
|
||||
t.Errorf("Trailers returned an unexpected error: %v", err)
|
||||
}
|
||||
if !reflect.DeepEqual(test.expected, actual) {
|
||||
t.Errorf("expecting %#v\ngot %#v", test.expected, actual)
|
||||
}
|
||||
}
|
||||
}
|
||||
minor nit:
(if this was copied from another file, let me know which one and we'll fix that later).
minor nit:
(if this was copied from another file, let me know which one and we'll fix that later).
maybe
for a tiny bit more symmetry between the initialization and post-steps.
maybe
for a tiny bit more symmetry between the initialization and post-steps.