Source file src/mime/encodedword_test.go

     1  // Copyright 2015 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 mime
     6  
     7  import (
     8  	"errors"
     9  	"io"
    10  	"strings"
    11  	"testing"
    12  )
    13  
    14  func TestEncodeWord(t *testing.T) {
    15  	utf8, iso88591 := "utf-8", "iso-8859-1"
    16  	tests := []struct {
    17  		enc      WordEncoder
    18  		charset  string
    19  		src, exp string
    20  	}{
    21  		{QEncoding, utf8, "François-Jérôme", "=?utf-8?q?Fran=C3=A7ois-J=C3=A9r=C3=B4me?="},
    22  		{BEncoding, utf8, "Café", "=?utf-8?b?Q2Fmw6k=?="},
    23  		{QEncoding, iso88591, "La Seleção", "=?iso-8859-1?q?La_Sele=C3=A7=C3=A3o?="},
    24  		{QEncoding, utf8, "", ""},
    25  		{QEncoding, utf8, "A", "A"},
    26  		{QEncoding, iso88591, "a", "a"},
    27  		{QEncoding, utf8, "123 456", "123 456"},
    28  		{QEncoding, utf8, "\t !\"#$%&'()*+,-./ :;<>?@[\\]^_`{|}~", "\t !\"#$%&'()*+,-./ :;<>?@[\\]^_`{|}~"},
    29  		{QEncoding, utf8, strings.Repeat("é", 10), "=?utf-8?q?" + strings.Repeat("=C3=A9", 10) + "?="},
    30  		{QEncoding, utf8, strings.Repeat("é", 11), "=?utf-8?q?" + strings.Repeat("=C3=A9", 10) + "?= =?utf-8?q?=C3=A9?="},
    31  		{QEncoding, iso88591, strings.Repeat("\xe9", 22), "=?iso-8859-1?q?" + strings.Repeat("=E9", 22) + "?="},
    32  		{QEncoding, utf8, strings.Repeat("\x80", 22), "=?utf-8?q?" + strings.Repeat("=80", 21) + "?= =?utf-8?q?=80?="},
    33  		{BEncoding, iso88591, strings.Repeat("\xe9", 45), "=?iso-8859-1?b?" + strings.Repeat("6enp", 15) + "?="},
    34  		{BEncoding, utf8, strings.Repeat("\x80", 48), "=?utf-8?b?" + strings.Repeat("gICA", 15) + "?= =?utf-8?b?gICA?="},
    35  	}
    36  
    37  	for _, test := range tests {
    38  		if s := test.enc.Encode(test.charset, test.src); s != test.exp {
    39  			t.Errorf("Encode(%q) = %q, want %q", test.src, s, test.exp)
    40  		}
    41  	}
    42  }
    43  
    44  func TestEncodedWordLength(t *testing.T) {
    45  	tests := []struct {
    46  		enc WordEncoder
    47  		src string
    48  	}{
    49  		{QEncoding, strings.Repeat("à", 30)},
    50  		{QEncoding, strings.Repeat("é", 60)},
    51  		{BEncoding, strings.Repeat("ï", 25)},
    52  		{BEncoding, strings.Repeat("ô", 37)},
    53  		{BEncoding, strings.Repeat("\x80", 50)},
    54  		{QEncoding, "{$firstname} Bienvendio a Apostolica, aquà inicia el camino de tu"},
    55  	}
    56  
    57  	for _, test := range tests {
    58  		s := test.enc.Encode("utf-8", test.src)
    59  		wordLen := 0
    60  		for i := 0; i < len(s); i++ {
    61  			if s[i] == ' ' {
    62  				wordLen = 0
    63  				continue
    64  			}
    65  
    66  			wordLen++
    67  			if wordLen > maxEncodedWordLen {
    68  				t.Errorf("Encode(%q) has more than %d characters: %q",
    69  					test.src, maxEncodedWordLen, s)
    70  			}
    71  		}
    72  	}
    73  }
    74  
    75  func TestDecodeWord(t *testing.T) {
    76  	tests := []struct {
    77  		src, exp string
    78  		hasErr   bool
    79  	}{
    80  		{"=?UTF-8?Q?=C2=A1Hola,_se=C3=B1or!?=", "¡Hola, señor!", false},
    81  		{"=?UTF-8?Q?Fran=C3=A7ois-J=C3=A9r=C3=B4me?=", "François-Jérôme", false},
    82  		{"=?UTF-8?q?ascii?=", "ascii", false},
    83  		{"=?utf-8?B?QW5kcsOp?=", "André", false},
    84  		{"=?ISO-8859-1?Q?Rapha=EBl_Dupont?=", "Raphaël Dupont", false},
    85  		{"=?utf-8?b?IkFudG9uaW8gSm9zw6kiIDxqb3NlQGV4YW1wbGUub3JnPg==?=", `"Antonio José" <jose@example.org>`, false},
    86  		{"=?UTF-8?A?Test?=", "", true},
    87  		{"=?UTF-8?Q?A=B?=", "", true},
    88  		{"=?UTF-8?Q?=A?=", "", true},
    89  		{"=?UTF-8?A?A?=", "", true},
    90  		{"=????=", "", true},
    91  		{"=?UTF-8???=", "", true},
    92  		{"=?UTF-8?Q??=", "", false},
    93  	}
    94  
    95  	for _, test := range tests {
    96  		dec := new(WordDecoder)
    97  		s, err := dec.Decode(test.src)
    98  		if test.hasErr && err == nil {
    99  			t.Errorf("Decode(%q) should return an error", test.src)
   100  			continue
   101  		}
   102  		if !test.hasErr && err != nil {
   103  			t.Errorf("Decode(%q): %v", test.src, err)
   104  			continue
   105  		}
   106  		if s != test.exp {
   107  			t.Errorf("Decode(%q) = %q, want %q", test.src, s, test.exp)
   108  		}
   109  	}
   110  }
   111  
   112  func TestDecodeHeader(t *testing.T) {
   113  	tests := []struct {
   114  		src, exp string
   115  	}{
   116  		{"=?UTF-8?Q?=C2=A1Hola,_se=C3=B1or!?=", "¡Hola, señor!"},
   117  		{"=?UTF-8?Q?Fran=C3=A7ois-J=C3=A9r=C3=B4me?=", "François-Jérôme"},
   118  		{"=?UTF-8?q?ascii?=", "ascii"},
   119  		{"=?utf-8?B?QW5kcsOp?=", "André"},
   120  		{"=?ISO-8859-1?Q?Rapha=EBl_Dupont?=", "Raphaël Dupont"},
   121  		{"Jean", "Jean"},
   122  		{"=?utf-8?b?IkFudG9uaW8gSm9zw6kiIDxqb3NlQGV4YW1wbGUub3JnPg==?=", `"Antonio José" <jose@example.org>`},
   123  		{"=?UTF-8?A?Test?=", "=?UTF-8?A?Test?="},
   124  		{"=?UTF-8?Q?A=B?=", "=?UTF-8?Q?A=B?="},
   125  		{"=?UTF-8?Q?=A?=", "=?UTF-8?Q?=A?="},
   126  		{"=?UTF-8?A?A?=", "=?UTF-8?A?A?="},
   127  		// Incomplete words
   128  		{"=?", "=?"},
   129  		{"=?UTF-8?", "=?UTF-8?"},
   130  		{"=?UTF-8?=", "=?UTF-8?="},
   131  		{"=?UTF-8?Q", "=?UTF-8?Q"},
   132  		{"=?UTF-8?Q?", "=?UTF-8?Q?"},
   133  		{"=?UTF-8?Q?=", "=?UTF-8?Q?="},
   134  		{"=?UTF-8?Q?A", "=?UTF-8?Q?A"},
   135  		{"=?UTF-8?Q?A?", "=?UTF-8?Q?A?"},
   136  		// Tests from RFC 2047
   137  		{"=?ISO-8859-1?Q?a?=", "a"},
   138  		{"=?ISO-8859-1?Q?a?= b", "a b"},
   139  		{"=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?=", "ab"},
   140  		{"=?ISO-8859-1?Q?a?=  =?ISO-8859-1?Q?b?=", "ab"},
   141  		{"=?ISO-8859-1?Q?a?= \r\n\t =?ISO-8859-1?Q?b?=", "ab"},
   142  		{"=?ISO-8859-1?Q?a_b?=", "a b"},
   143  	}
   144  
   145  	for _, test := range tests {
   146  		dec := new(WordDecoder)
   147  		s, err := dec.DecodeHeader(test.src)
   148  		if err != nil {
   149  			t.Errorf("DecodeHeader(%q): %v", test.src, err)
   150  		}
   151  		if s != test.exp {
   152  			t.Errorf("DecodeHeader(%q) = %q, want %q", test.src, s, test.exp)
   153  		}
   154  	}
   155  }
   156  
   157  func TestCharsetDecoder(t *testing.T) {
   158  	tests := []struct {
   159  		src      string
   160  		want     string
   161  		charsets []string
   162  		content  []string
   163  	}{
   164  		{"=?utf-8?b?Q2Fmw6k=?=", "Café", nil, nil},
   165  		{"=?ISO-8859-1?Q?caf=E9?=", "café", nil, nil},
   166  		{"=?US-ASCII?Q?foo_bar?=", "foo bar", nil, nil},
   167  		{"=?utf-8?Q?=?=", "=?utf-8?Q?=?=", nil, nil},
   168  		{"=?utf-8?Q?=A?=", "=?utf-8?Q?=A?=", nil, nil},
   169  		{
   170  			"=?ISO-8859-15?Q?f=F5=F6?=  =?windows-1252?Q?b=E0r?=",
   171  			"f\xf5\xf6b\xe0r",
   172  			[]string{"iso-8859-15", "windows-1252"},
   173  			[]string{"f\xf5\xf6", "b\xe0r"},
   174  		},
   175  	}
   176  
   177  	for _, test := range tests {
   178  		i := 0
   179  		dec := &WordDecoder{
   180  			CharsetReader: func(charset string, input io.Reader) (io.Reader, error) {
   181  				if charset != test.charsets[i] {
   182  					t.Errorf("DecodeHeader(%q), got charset %q, want %q", test.src, charset, test.charsets[i])
   183  				}
   184  				content, err := io.ReadAll(input)
   185  				if err != nil {
   186  					t.Errorf("DecodeHeader(%q), error in reader: %v", test.src, err)
   187  				}
   188  				got := string(content)
   189  				if got != test.content[i] {
   190  					t.Errorf("DecodeHeader(%q), got content %q, want %q", test.src, got, test.content[i])
   191  				}
   192  				i++
   193  
   194  				return strings.NewReader(got), nil
   195  			},
   196  		}
   197  		got, err := dec.DecodeHeader(test.src)
   198  		if err != nil {
   199  			t.Errorf("DecodeHeader(%q): %v", test.src, err)
   200  		}
   201  		if got != test.want {
   202  			t.Errorf("DecodeHeader(%q) = %q, want %q", test.src, got, test.want)
   203  		}
   204  	}
   205  }
   206  
   207  func TestCharsetDecoderError(t *testing.T) {
   208  	dec := &WordDecoder{
   209  		CharsetReader: func(charset string, input io.Reader) (io.Reader, error) {
   210  			return nil, errors.New("Test error")
   211  		},
   212  	}
   213  
   214  	if _, err := dec.DecodeHeader("=?charset?Q?foo?="); err == nil {
   215  		t.Error("DecodeHeader should return an error")
   216  	}
   217  }
   218  
   219  func BenchmarkQEncodeWord(b *testing.B) {
   220  	for i := 0; i < b.N; i++ {
   221  		QEncoding.Encode("UTF-8", "¡Hola, señor!")
   222  	}
   223  }
   224  
   225  func BenchmarkQDecodeWord(b *testing.B) {
   226  	dec := new(WordDecoder)
   227  
   228  	for i := 0; i < b.N; i++ {
   229  		dec.Decode("=?utf-8?q?=C2=A1Hola,_se=C3=B1or!?=")
   230  	}
   231  }
   232  
   233  func BenchmarkQDecodeHeader(b *testing.B) {
   234  	dec := new(WordDecoder)
   235  
   236  	for i := 0; i < b.N; i++ {
   237  		dec.DecodeHeader("=?utf-8?q?=C2=A1Hola,_se=C3=B1or!?=")
   238  	}
   239  }
   240  

View as plain text