reader_test.go

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package quotedprintable
     6  
     7  import (
     8  	"bufio"
     9  	"errors"
    10  	"flag"
    11  	"fmt"
    12  	"io"
    13  	"os/exec"
    14  	"regexp"
    15  	"slices"
    16  	"strings"
    17  	"testing"
    18  	"time"
    19  )
    20  
    21  func TestReader(t *testing.T) {
    22  	tests := []struct {
    23  		in, want string
    24  		err      any
    25  	}{
    26  		{in: "", want: ""},
    27  		{in: "foo bar", want: "foo bar"},
    28  		{in: "foo bar=3D", want: "foo bar="},
    29  		{in: "foo bar=3d", want: "foo bar="}, // lax.
    30  		{in: "foo bar=\n", want: "foo bar"},
    31  		{in: "foo bar\n", want: "foo bar\n"}, // somewhat lax.
    32  		{in: "foo bar=0", want: "foo bar=0"}, // lax
    33  		{in: "foo bar=0D=0A", want: "foo bar\r\n"},
    34  		{in: " A B        \r\n C ", want: " A B\r\n C"},
    35  		{in: " A B =\r\n C ", want: " A B  C"},
    36  		{in: " A B =\n C ", want: " A B  C"}, // lax. treating LF as CRLF
    37  		{in: "foo=\nbar", want: "foobar"},
    38  		{in: "foo\x00bar", want: "foo", err: "quotedprintable: invalid unescaped byte 0x00 in body"},
    39  		{in: "foo bar\xff", want: "foo bar\xff"},
    40  
    41  		// Equal sign.
    42  		{in: "=3D30\n", want: "=30\n"},
    43  		{in: "=00=FF0=\n", want: "\x00\xff0"},
    44  
    45  		// Trailing whitespace
    46  		{in: "foo  \n", want: "foo\n"},
    47  		{in: "foo  \n\nfoo =\n\nfoo=20\n\n", want: "foo\n\nfoo \nfoo \n\n"},
    48  
    49  		// Tests that we allow bare \n and \r through, despite it being strictly
    50  		// not permitted per RFC 2045, Section 6.7 Page 22 bullet (4).
    51  		{in: "foo\nbar", want: "foo\nbar"},
    52  		{in: "foo\rbar", want: "foo\rbar"},
    53  		{in: "foo\r\nbar", want: "foo\r\nbar"},
    54  
    55  		// Different types of soft line-breaks.
    56  		{in: "foo=\r\nbar", want: "foobar"},
    57  		{in: "foo=\nbar", want: "foobar"},
    58  		{in: "foo=\rbar", want: "foo", err: "quotedprintable: invalid hex byte 0x0d"},
    59  		{in: "foo=\r\r\r \nbar", want: "foo", err: `quotedprintable: invalid bytes after =: "\r\r\r \n"`},
    60  		// Issue 15486, accept trailing soft line-break at end of input.
    61  		{in: "foo=", want: "foo"},
    62  		{in: "=", want: "", err: `quotedprintable: invalid bytes after =: ""`},
    63  
    64  		// Example from RFC 2045:
    65  		{in: "Now's the time =\n" + "for all folk to come=\n" + " to the aid of their country.",
    66  			want: "Now's the time for all folk to come to the aid of their country."},
    67  		{in: "accept UTF-8 right quotation mark: ’",
    68  			want: "accept UTF-8 right quotation mark: ’"},
    69  
    70  		// Transport padding
    71  		{in: "foo= \r\nbar", want: "foobar"},
    72  		{in: "foo=\t \r\nbar", want: "foobar"},
    73  	}
    74  	for _, tt := range tests {
    75  		var buf strings.Builder
    76  		_, err := io.Copy(&buf, NewReader(strings.NewReader(tt.in)))
    77  		if got := buf.String(); got != tt.want {
    78  			t.Errorf("for %q, got %q; want %q", tt.in, got, tt.want)
    79  		}
    80  		switch verr := tt.err.(type) {
    81  		case nil:
    82  			if err != nil {
    83  				t.Errorf("for %q, got unexpected error: %v", tt.in, err)
    84  			}
    85  		case string:
    86  			if got := fmt.Sprint(err); got != verr {
    87  				t.Errorf("for %q, got error %q; want %q", tt.in, got, verr)
    88  			}
    89  		case error:
    90  			if err != verr {
    91  				t.Errorf("for %q, got error %q; want %q", tt.in, err, verr)
    92  			}
    93  		}
    94  	}
    95  
    96  }
    97  
    98  func everySequence(base, alpha string, length int, fn func(string)) {
    99  	if len(base) == length {
   100  		fn(base)
   101  		return
   102  	}
   103  	for i := 0; i < len(alpha); i++ {
   104  		everySequence(base+alpha[i:i+1], alpha, length, fn)
   105  	}
   106  }
   107  
   108  var useQprint = flag.Bool("qprint", false, "Compare against the 'qprint' program.")
   109  
   110  var badSoftRx = regexp.MustCompile(`=([^\r\n]+?\n)|([^\r\n]+$)|(\r$)|(\r[^\n]+\n)|( \r\n)`)
   111  
   112  func TestExhaustive(t *testing.T) {
   113  	if *useQprint {
   114  		_, err := exec.LookPath("qprint")
   115  		if err != nil {
   116  			t.Fatalf("Error looking for qprint: %v", err)
   117  		}
   118  	}
   119  
   120  	var buf strings.Builder
   121  	res := make(map[string]int)
   122  	n := 6
   123  	if testing.Short() {
   124  		n = 4
   125  	}
   126  	everySequence("", "0A \r\n=", n, func(s string) {
   127  		if strings.HasSuffix(s, "=") || strings.Contains(s, "==") {
   128  			return
   129  		}
   130  		buf.Reset()
   131  		_, err := io.Copy(&buf, NewReader(strings.NewReader(s)))
   132  		if err != nil {
   133  			errStr := err.Error()
   134  			if strings.Contains(errStr, "invalid bytes after =:") {
   135  				errStr = "invalid bytes after ="
   136  			}
   137  			res[errStr]++
   138  			if strings.Contains(errStr, "invalid hex byte ") {
   139  				if strings.HasSuffix(errStr, "0x20") && (strings.Contains(s, "=0 ") || strings.Contains(s, "=A ") || strings.Contains(s, "= ")) {
   140  					return
   141  				}
   142  				if strings.HasSuffix(errStr, "0x3d") && (strings.Contains(s, "=0=") || strings.Contains(s, "=A=")) {
   143  					return
   144  				}
   145  				if strings.HasSuffix(errStr, "0x0a") || strings.HasSuffix(errStr, "0x0d") {
   146  					// bunch of cases; since whitespace at the end of a line before \n is removed.
   147  					return
   148  				}
   149  			}
   150  			if strings.Contains(errStr, "unexpected EOF") {
   151  				return
   152  			}
   153  			if errStr == "invalid bytes after =" && badSoftRx.MatchString(s) {
   154  				return
   155  			}
   156  			t.Errorf("decode(%q) = %v", s, err)
   157  			return
   158  		}
   159  		if *useQprint {
   160  			cmd := exec.Command("qprint", "-d")
   161  			cmd.Stdin = strings.NewReader(s)
   162  			stderr, err := cmd.StderrPipe()
   163  			if err != nil {
   164  				panic(err)
   165  			}
   166  			qpres := make(chan any, 2)
   167  			go func() {
   168  				br := bufio.NewReader(stderr)
   169  				s, _ := br.ReadString('\n')
   170  				if s != "" {
   171  					qpres <- errors.New(s)
   172  					if cmd.Process != nil {
   173  						// It can get stuck on invalid input, like:
   174  						// echo -n "0000= " | qprint -d
   175  						cmd.Process.Kill()
   176  					}
   177  				}
   178  			}()
   179  			go func() {
   180  				want, err := cmd.Output()
   181  				if err == nil {
   182  					qpres <- want
   183  				}
   184  			}()
   185  			select {
   186  			case got := <-qpres:
   187  				if want, ok := got.([]byte); ok {
   188  					if string(want) != buf.String() {
   189  						t.Errorf("go decode(%q) = %q; qprint = %q", s, want, buf.String())
   190  					}
   191  				} else {
   192  					t.Logf("qprint -d(%q) = %v", s, got)
   193  				}
   194  			case <-time.After(5 * time.Second):
   195  				t.Logf("qprint timeout on %q", s)
   196  			}
   197  		}
   198  		res["OK"]++
   199  	})
   200  	var outcomes []string
   201  	for k, v := range res {
   202  		outcomes = append(outcomes, fmt.Sprintf("%v: %d", k, v))
   203  	}
   204  	slices.Sort(outcomes)
   205  	got := strings.Join(outcomes, "\n")
   206  	want := `OK: 30638
   207  invalid bytes after =: 2243
   208  quotedprintable: invalid hex byte 0x0d: 2050
   209  unexpected EOF: 194`
   210  	if testing.Short() {
   211  		want = `OK: 935
   212  invalid bytes after =: 61
   213  quotedprintable: invalid hex byte 0x0d: 26
   214  unexpected EOF: 3`
   215  	}
   216  
   217  	if got != want {
   218  		t.Errorf("Got:\n%s\nWant:\n%s", got, want)
   219  	}
   220  }
   221
View as plain text