code review 6212046: mime/multipart: fix handling of empty parts without CRL...

src/pkg/mime/multipart/multipart_test.go

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package multipart
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "io"
         "io/ioutil"
         "net/textproto"
         "os"
         "reflect"
         "strings"
         "testing"
 )
-
-func TestHorizontalWhitespace(t *testing.T) {
-        if !onlyHorizontalWhitespace([]byte(" \t")) {
-                t.Error("expected pass")
-        }
-        if onlyHorizontalWhitespace([]byte("foo bar")) {
-                t.Error("expected failure")
-        }
-}
 
 func TestBoundaryLine(t *testing.T) {
         mr := NewReader(strings.NewReader(""), "myBoundary")
         if !mr.isBoundaryDelimiterLine([]byte("--myBoundary\r\n")) {
                 t.Error("expected")
         }
         if !mr.isBoundaryDelimiterLine([]byte("--myBoundary \r\n")) {
                 t.Error("expected")
         }
         if !mr.isBoundaryDelimiterLine([]byte("--myBoundary \n")) {
@@ skipping 452 matching lines @@
         // Final part empty with newlines after final separator.
         {
                 name: "final part empty then crlf",
                 sep:  "abc",
                 in:   "--abc\r\nFoo: bar\r\n\r\n--abc--\r\n",
                 want: []headerBody{
                         {textproto.MIMEHeader{"Foo": {"bar"}}, ""},
                 },
         },
 
+        // Final part empty with lwsp-chars after final separator.
+        {
+                name: "final part empty then lwsp",
+                sep:  "abc",
+                in:   "--abc\r\nFoo: bar\r\n\r\n--abc-- \t",
+                want: []headerBody{
+                        {textproto.MIMEHeader{"Foo": {"bar"}}, ""},
+                },
+        },
+
         // No parts (empty form as submitted by Chrome)
         {
                 name: "no parts",
                 sep:  "----WebKitFormBoundaryQfEAfzFOiSemeHfA",
                 in:   "------WebKitFormBoundaryQfEAfzFOiSemeHfA--\r\n",
                 want: []headerBody{},
         },
 
         // Part containing data starting with the boundary, but with additional suffix.
         {
                 name: "fake separator as data",
                 sep:  "sep",
                 in:   "--sep\r\nFoo: bar\r\n\r\n--sepFAKE\r\n--sep--",
                 want: []headerBody{
                         {textproto.MIMEHeader{"Foo": {"bar"}}, "--sepFAKE"},
+                },
+        },
+
+        // Part containing a boundary with whitespace following it.
+        {
+                name: "boundary with whitespace",
+                sep:  "sep",
+                in:   "--sep \r\nFoo: bar\r\n\r\ntext\r\n--sep--",
+                want: []headerBody{
+                        {textproto.MIMEHeader{"Foo": {"bar"}}, "text"},
                 },
         },
 
         // With ignored leading line.
         {
                 name: "leading line",
                 sep:  "MyBoundary",
                 in: strings.Replace(`This is a multi-part message.  This line is ignored.
 --MyBoundary
 foo: bar
 
 
 --MyBoundary--`, "\n", "\r\n", -1),
                 want: []headerBody{
                         {textproto.MIMEHeader{"Foo": {"bar"}}, ""},
                 },
         },
 
         roundTripParseTest(),
 }
 
 func TestParse(t *testing.T) {
+Cases:
         for _, tt := range parseTests {
                 r := NewReader(strings.NewReader(tt.in), tt.sep)
                 got := []headerBody{}
                 for {
                         p, err := r.NextPart()
                         if err == io.EOF {
                                 break
                         }
                         if err != nil {
-                                t.Fatalf("in test %q, NextPart: %v", tt.name, err)
+                                t.Errorf("in test %q, NextPart: %v", tt.name, err)
+                                continue Cases
                         }
                         pbody, err := ioutil.ReadAll(p)
                         if err != nil {
-                                t.Fatalf("in test %q, error reading part: %v", tt.name, err)
+                                t.Errorf("in test %q, error reading part: %v", tt.name, err)
+                                continue Cases
                         }
                         got = append(got, headerBody{p.Header, string(pbody)})
                 }
                 if !reflect.DeepEqual(tt.want, got) {
                         t.Errorf("test %q:\n got: %v\nwant: %v", tt.name, got, tt.want)
                         if len(tt.want) != len(got) {
                                 t.Errorf("test %q: got %d parts, want %d", tt.name, len(got), len(tt.want))
-                        } else {
+                        } else if len(got) > 1 {
                                 for pi, wantPart := range tt.want {
                                         if !reflect.DeepEqual(wantPart, got[pi]) {
                                                 t.Errorf("test %q, part %d:\n got: %v\nwant: %v", tt.name, pi, got[pi], wantPart)
                                         }
                                 }
                         }
                 }
         }
 }
 
@@ skipping 18 matching lines @@
                 _, err = pw.Write([]byte(p.body))
                 if err != nil {
                         panic(err)
                 }
         }
         w.Close()
         t.in = buf.String()
         t.sep = w.Boundary()
         return t
 }