libgo/go/net/mail/message_test.go - gofrontend - Git at Google

 // Copyright 2011 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 mail

 import (
 	"bytes"
 	"io"
 	"io/ioutil"
 	"mime"
 	"reflect"
 	"strings"
 	"testing"
 	"time"
 )

 var parseTests = []struct {
 	in     string
 	header Header
 	body   string
 }{
 	{
 		// RFC 5322, Appendix A.1.1
 		in: `From: John Doe <jdoe@machine.example>
 To: Mary Smith <mary@example.net>
 Subject: Saying Hello
 Date: Fri, 21 Nov 1997 09:55:06 -0600
 Message-ID: <1234@local.machine.example>

 This is a message just to say hello.
 So, "Hello".
 `,
 		header: Header{
 			"From":       []string{"John Doe <jdoe@machine.example>"},
 			"To":         []string{"Mary Smith <mary@example.net>"},
 			"Subject":    []string{"Saying Hello"},
 			"Date":       []string{"Fri, 21 Nov 1997 09:55:06 -0600"},
 			"Message-Id": []string{"<1234@local.machine.example>"},
 		},
 		body: "This is a message just to say hello.\nSo, \"Hello\".\n",
 	},
 }

 func TestParsing(t *testing.T) {
 	for i, test := range parseTests {
 		msg, err := ReadMessage(bytes.NewBuffer([]byte(test.in)))
 		if err != nil {
 			t.Errorf("test #%d: Failed parsing message: %v", i, err)
 			continue
 		}
 		if !headerEq(msg.Header, test.header) {
 			t.Errorf("test #%d: Incorrectly parsed message header.\nGot:\n%+v\nWant:\n%+v",
 				i, msg.Header, test.header)
 		}
 		body, err := ioutil.ReadAll(msg.Body)
 		if err != nil {
 			t.Errorf("test #%d: Failed reading body: %v", i, err)
 			continue
 		}
 		bodyStr := string(body)
 		if bodyStr != test.body {
 			t.Errorf("test #%d: Incorrectly parsed message body.\nGot:\n%+v\nWant:\n%+v",
 				i, bodyStr, test.body)
 		}
 	}
 }

 func headerEq(a, b Header) bool {
 	if len(a) != len(b) {
 		return false
 	}
 	for k, as := range a {
 		bs, ok := b[k]
 		if !ok {
 			return false
 		}
 		if !reflect.DeepEqual(as, bs) {
 			return false
 		}
 	}
 	return true
 }

 func TestDateParsing(t *testing.T) {
 	tests := []struct {
 		dateStr string
 		exp     time.Time
 	}{
 		// RFC 5322, Appendix A.1.1
 		{
 			"Fri, 21 Nov 1997 09:55:06 -0600",
 			time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("", -6*60*60)),
 		},
 		// RFC 5322, Appendix A.6.2
 		// Obsolete date.
 		{
 			"21 Nov 97 09:55:06 GMT",
 			time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("GMT", 0)),
 		},
 		// Commonly found format not specified by RFC 5322.
 		{
 			"Fri, 21 Nov 1997 09:55:06 -0600 (MDT)",
 			time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("", -6*60*60)),
 		},
 	}
 	for _, test := range tests {
 		hdr := Header{
 			"Date": []string{test.dateStr},
 		}
 		date, err := hdr.Date()
 		if err != nil {
 			t.Errorf("Header(Date: %s).Date(): %v", test.dateStr, err)
 		} else if !date.Equal(test.exp) {
 			t.Errorf("Header(Date: %s).Date() = %+v, want %+v", test.dateStr, date, test.exp)
 		}

 		date, err = ParseDate(test.dateStr)
 		if err != nil {
 			t.Errorf("ParseDate(%s): %v", test.dateStr, err)
 		} else if !date.Equal(test.exp) {
 			t.Errorf("ParseDate(%s) = %+v, want %+v", test.dateStr, date, test.exp)
 		}
 	}
 }

 func TestAddressParsingError(t *testing.T) {
 	mustErrTestCases := [...]struct {
 		text        string
 		wantErrText string
 	}{
 		0: {"=?iso-8859-2?Q?Bogl=E1rka_Tak=E1cs?= <unknown@gmail.com>", "charset not supported"},
 		1: {"a@gmail.com b@gmail.com", "expected single address"},
 		2: {string([]byte{0xed, 0xa0, 0x80}) + " <micro@example.net>", "invalid utf-8 in address"},
 		3: {"\"" + string([]byte{0xed, 0xa0, 0x80}) + "\" <half-surrogate@example.com>", "invalid utf-8 in quoted-string"},
 		4: {"\"\\" + string([]byte{0x80}) + "\" <escaped-invalid-unicode@example.net>", "invalid utf-8 in quoted-string"},
 		5: {"\"\x00\" <null@example.net>", "bad character in quoted-string"},
 		6: {"\"\\\x00\" <escaped-null@example.net>", "bad character in quoted-string"},
 	}

 	for i, tc := range mustErrTestCases {
 		_, err := ParseAddress(tc.text)
 		if err == nil || !strings.Contains(err.Error(), tc.wantErrText) {
 			t.Errorf(`mail.ParseAddress(%q) #%d want %q, got %v`, tc.text, i, tc.wantErrText, err)
 		}
 	}
 }

 func TestAddressParsing(t *testing.T) {
 	tests := []struct {
 		addrsStr string
 		exp      []*Address
 	}{
 		// Bare address
 		{
 			`jdoe@machine.example`,
 			[]*Address{{
 				Address: "jdoe@machine.example",
 			}},
 		},
 		// RFC 5322, Appendix A.1.1
 		{
 			`John Doe <jdoe@machine.example>`,
 			[]*Address{{
 				Name:    "John Doe",
 				Address: "jdoe@machine.example",
 			}},
 		},
 		// RFC 5322, Appendix A.1.2
 		{
 			`"Joe Q. Public" <john.q.public@example.com>`,
 			[]*Address{{
 				Name:    "Joe Q. Public",
 				Address: "john.q.public@example.com",
 			}},
 		},
 		{
 			`Mary Smith <mary@x.test>, jdoe@example.org, Who? <one@y.test>`,
 			[]*Address{
 				{
 					Name:    "Mary Smith",
 					Address: "mary@x.test",
 				},
 				{
 					Address: "jdoe@example.org",
 				},
 				{
 					Name:    "Who?",
 					Address: "one@y.test",
 				},
 			},
 		},
 		{
 			`<boss@nil.test>, "Giant; \"Big\" Box" <sysservices@example.net>`,
 			[]*Address{
 				{
 					Address: "boss@nil.test",
 				},
 				{
 					Name:    `Giant; "Big" Box`,
 					Address: "sysservices@example.net",
 				},
 			},
 		},
 		// RFC 5322, Appendix A.1.3
 		// TODO(dsymonds): Group addresses.

 		// RFC 2047 "Q"-encoded ISO-8859-1 address.
 		{
 			`=?iso-8859-1?q?J=F6rg_Doe?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg Doe`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// RFC 2047 "Q"-encoded US-ASCII address. Dumb but legal.
 		{
 			`=?us-ascii?q?J=6Frg_Doe?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jorg Doe`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// RFC 2047 "Q"-encoded UTF-8 address.
 		{
 			`=?utf-8?q?J=C3=B6rg_Doe?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg Doe`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// RFC 2047, Section 8.
 		{
 			`=?ISO-8859-1?Q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>`,
 			[]*Address{
 				{
 					Name:    `André Pirard`,
 					Address: "PIRARD@vm1.ulg.ac.be",
 				},
 			},
 		},
 		// Custom example of RFC 2047 "B"-encoded ISO-8859-1 address.
 		{
 			`=?ISO-8859-1?B?SvZyZw==?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// Custom example of RFC 2047 "B"-encoded UTF-8 address.
 		{
 			`=?UTF-8?B?SsO2cmc=?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// Custom example with "." in name. For issue 4938
 		{
 			`Asem H. <noreply@example.com>`,
 			[]*Address{
 				{
 					Name:    `Asem H.`,
 					Address: "noreply@example.com",
 				},
 			},
 		},
 		// RFC 6532 3.2.3, qtext /= UTF8-non-ascii
 		{
 			`"Gø Pher" <gopher@example.com>`,
 			[]*Address{
 				{
 					Name:    `Gø Pher`,
 					Address: "gopher@example.com",
 				},
 			},
 		},
 		// RFC 6532 3.2, atext /= UTF8-non-ascii
 		{
 			`µ <micro@example.com>`,
 			[]*Address{
 				{
 					Name:    `µ`,
 					Address: "micro@example.com",
 				},
 			},
 		},
 		// RFC 6532 3.2.2, local address parts allow UTF-8
 		{
 			`Micro <µ@example.com>`,
 			[]*Address{
 				{
 					Name:    `Micro`,
 					Address: "µ@example.com",
 				},
 			},
 		},
 		// RFC 6532 3.2.4, domains parts allow UTF-8
 		{
 			`Micro <micro@µ.example.com>`,
 			[]*Address{
 				{
 					Name:    `Micro`,
 					Address: "micro@µ.example.com",
 				},
 			},
 		},
 		// Issue 14866
 		{
 			`"" <emptystring@example.com>`,
 			[]*Address{
 				{
 					Name:    "",
 					Address: "emptystring@example.com",
 				},
 			},
 		},
 	}
 	for _, test := range tests {
 		if len(test.exp) == 1 {
 			addr, err := ParseAddress(test.addrsStr)
 			if err != nil {
 				t.Errorf("Failed parsing (single) %q: %v", test.addrsStr, err)
 				continue
 			}
 			if !reflect.DeepEqual([]*Address{addr}, test.exp) {
 				t.Errorf("Parse (single) of %q: got %+v, want %+v", test.addrsStr, addr, test.exp)
 			}
 		}

 		addrs, err := ParseAddressList(test.addrsStr)
 		if err != nil {
 			t.Errorf("Failed parsing (list) %q: %v", test.addrsStr, err)
 			continue
 		}
 		if !reflect.DeepEqual(addrs, test.exp) {
 			t.Errorf("Parse (list) of %q: got %+v, want %+v", test.addrsStr, addrs, test.exp)
 		}
 	}
 }

 func TestAddressParser(t *testing.T) {
 	tests := []struct {
 		addrsStr string
 		exp      []*Address
 	}{
 		// Bare address
 		{
 			`jdoe@machine.example`,
 			[]*Address{{
 				Address: "jdoe@machine.example",
 			}},
 		},
 		// RFC 5322, Appendix A.1.1
 		{
 			`John Doe <jdoe@machine.example>`,
 			[]*Address{{
 				Name:    "John Doe",
 				Address: "jdoe@machine.example",
 			}},
 		},
 		// RFC 5322, Appendix A.1.2
 		{
 			`"Joe Q. Public" <john.q.public@example.com>`,
 			[]*Address{{
 				Name:    "Joe Q. Public",
 				Address: "john.q.public@example.com",
 			}},
 		},
 		{
 			`Mary Smith <mary@x.test>, jdoe@example.org, Who? <one@y.test>`,
 			[]*Address{
 				{
 					Name:    "Mary Smith",
 					Address: "mary@x.test",
 				},
 				{
 					Address: "jdoe@example.org",
 				},
 				{
 					Name:    "Who?",
 					Address: "one@y.test",
 				},
 			},
 		},
 		{
 			`<boss@nil.test>, "Giant; \"Big\" Box" <sysservices@example.net>`,
 			[]*Address{
 				{
 					Address: "boss@nil.test",
 				},
 				{
 					Name:    `Giant; "Big" Box`,
 					Address: "sysservices@example.net",
 				},
 			},
 		},
 		// RFC 2047 "Q"-encoded ISO-8859-1 address.
 		{
 			`=?iso-8859-1?q?J=F6rg_Doe?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg Doe`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// RFC 2047 "Q"-encoded US-ASCII address. Dumb but legal.
 		{
 			`=?us-ascii?q?J=6Frg_Doe?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jorg Doe`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// RFC 2047 "Q"-encoded ISO-8859-15 address.
 		{
 			`=?ISO-8859-15?Q?J=F6rg_Doe?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg Doe`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// RFC 2047 "B"-encoded windows-1252 address.
 		{
 			`=?windows-1252?q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>`,
 			[]*Address{
 				{
 					Name:    `André Pirard`,
 					Address: "PIRARD@vm1.ulg.ac.be",
 				},
 			},
 		},
 		// Custom example of RFC 2047 "B"-encoded ISO-8859-15 address.
 		{
 			`=?ISO-8859-15?B?SvZyZw==?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// Custom example of RFC 2047 "B"-encoded UTF-8 address.
 		{
 			`=?UTF-8?B?SsO2cmc=?= <joerg@example.com>`,
 			[]*Address{
 				{
 					Name:    `Jörg`,
 					Address: "joerg@example.com",
 				},
 			},
 		},
 		// Custom example with "." in name. For issue 4938
 		{
 			`Asem H. <noreply@example.com>`,
 			[]*Address{
 				{
 					Name:    `Asem H.`,
 					Address: "noreply@example.com",
 				},
 			},
 		},
 	}

 	ap := AddressParser{WordDecoder: &mime.WordDecoder{
 		CharsetReader: func(charset string, input io.Reader) (io.Reader, error) {
 			in, err := ioutil.ReadAll(input)
 			if err != nil {
 				return nil, err
 			}

 			switch charset {
 			case "iso-8859-15":
 				in = bytes.Replace(in, []byte("\xf6"), []byte("ö"), -1)
 			case "windows-1252":
 				in = bytes.Replace(in, []byte("\xe9"), []byte("é"), -1)
 			}

 			return bytes.NewReader(in), nil
 		},
 	}}

 	for _, test := range tests {
 		if len(test.exp) == 1 {
 			addr, err := ap.Parse(test.addrsStr)
 			if err != nil {
 				t.Errorf("Failed parsing (single) %q: %v", test.addrsStr, err)
 				continue
 			}
 			if !reflect.DeepEqual([]*Address{addr}, test.exp) {
 				t.Errorf("Parse (single) of %q: got %+v, want %+v", test.addrsStr, addr, test.exp)
 			}
 		}

 		addrs, err := ap.ParseList(test.addrsStr)
 		if err != nil {
 			t.Errorf("Failed parsing (list) %q: %v", test.addrsStr, err)
 			continue
 		}
 		if !reflect.DeepEqual(addrs, test.exp) {
 			t.Errorf("Parse (list) of %q: got %+v, want %+v", test.addrsStr, addrs, test.exp)
 		}
 	}
 }

 func TestAddressString(t *testing.T) {
 	tests := []struct {
 		addr *Address
 		exp  string
 	}{
 		{
 			&Address{Address: "bob@example.com"},
 			"<bob@example.com>",
 		},
 		{ // quoted local parts: RFC 5322, 3.4.1. and 3.2.4.
 			&Address{Address: `my@idiot@address@example.com`},
 			`<"my@idiot@address"@example.com>`,
 		},
 		{ // quoted local parts
 			&Address{Address: ` @example.com`},
 			`<" "@example.com>`,
 		},
 		{
 			&Address{Name: "Bob", Address: "bob@example.com"},
 			`"Bob" <bob@example.com>`,
 		},
 		{
 			// note the ö (o with an umlaut)
 			&Address{Name: "Böb", Address: "bob@example.com"},
 			`=?utf-8?q?B=C3=B6b?= <bob@example.com>`,
 		},
 		{
 			&Address{Name: "Bob Jane", Address: "bob@example.com"},
 			`"Bob Jane" <bob@example.com>`,
 		},
 		{
 			&Address{Name: "Böb Jacöb", Address: "bob@example.com"},
 			`=?utf-8?q?B=C3=B6b_Jac=C3=B6b?= <bob@example.com>`,
 		},
 		{ // https://golang.org/issue/12098
 			&Address{Name: "Rob", Address: ""},
 			`"Rob" <@>`,
 		},
 		{ // https://golang.org/issue/12098
 			&Address{Name: "Rob", Address: "@"},
 			`"Rob" <@>`,
 		},
 		{
 			&Address{Name: "Böb, Jacöb", Address: "bob@example.com"},
 			`=?utf-8?b?QsO2YiwgSmFjw7Zi?= <bob@example.com>`,
 		},
 		{
 			&Address{Name: "=??Q?x?=", Address: "hello@world.com"},
 			`"=??Q?x?=" <hello@world.com>`,
 		},
 		{
 			&Address{Name: "=?hello", Address: "hello@world.com"},
 			`"=?hello" <hello@world.com>`,
 		},
 		{
 			&Address{Name: "world?=", Address: "hello@world.com"},
 			`"world?=" <hello@world.com>`,
 		},
 		{
 			// should q-encode even for invalid utf-8.
 			&Address{Name: string([]byte{0xed, 0xa0, 0x80}), Address: "invalid-utf8@example.net"},
 			"=?utf-8?q?=ED=A0=80?= <invalid-utf8@example.net>",
 		},
 	}
 	for _, test := range tests {
 		s := test.addr.String()
 		if s != test.exp {
 			t.Errorf("Address%+v.String() = %v, want %v", *test.addr, s, test.exp)
 			continue
 		}

 		// Check round-trip.
 		if test.addr.Address != "" && test.addr.Address != "@" {
 			a, err := ParseAddress(test.exp)
 			if err != nil {
 				t.Errorf("ParseAddress(%#q): %v", test.exp, err)
 				continue
 			}
 			if a.Name != test.addr.Name || a.Address != test.addr.Address {
 				t.Errorf("ParseAddress(%#q) = %#v, want %#v", test.exp, a, test.addr)
 			}
 		}
 	}
 }

 // Check if all valid addresses can be parsed, formatted and parsed again
 func TestAddressParsingAndFormatting(t *testing.T) {

 	// Should pass
 	tests := []string{
 		`<Bob@example.com>`,
 		`<bob.bob@example.com>`,
 		`<".bob"@example.com>`,
 		`<" "@example.com>`,
 		`<some.mail-with-dash@example.com>`,
 		`<"dot.and space"@example.com>`,
 		`<"very.unusual.@.unusual.com"@example.com>`,
 		`<admin@mailserver1>`,
 		`<postmaster@localhost>`,
 		"<#!$%&'*+-/=?^_`{}|~@example.org>",
 		`<"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com>`, // escaped quotes
 		`<"()<>[]:,;@\\\"!#$%&'*+-/=?^_{}| ~.a"@example.org>`,                      // escaped backslashes
 		`<"Abc\\@def"@example.com>`,
 		`<"Joe\\Blow"@example.com>`,
 		`<test1/test2=test3@example.com>`,
 		`<def!xyz%abc@example.com>`,
 		`<_somename@example.com>`,
 		`<joe@uk>`,
 		`<~@example.com>`,
 		`<"..."@test.com>`,
 		`<"john..doe"@example.com>`,
 		`<"john.doe."@example.com>`,
 		`<".john.doe"@example.com>`,
 		`<"."@example.com>`,
 		`<".."@example.com>`,
 		`<"0:"@0>`,
 	}

 	for _, test := range tests {
 		addr, err := ParseAddress(test)
 		if err != nil {
 			t.Errorf("Couldn't parse address %s: %s", test, err.Error())
 			continue
 		}
 		str := addr.String()
 		addr, err = ParseAddress(str)
 		if err != nil {
 			t.Errorf("ParseAddr(%q) error: %v", test, err)
 			continue
 		}

 		if addr.String() != test {
 			t.Errorf("String() round-trip = %q; want %q", addr, test)
 			continue
 		}

 	}

 	// Should fail
 	badTests := []string{
 		`<Abc.example.com>`,
 		`<A@b@c@example.com>`,
 		`<a"b(c)d,e:f;g<h>i[j\k]l@example.com>`,
 		`<just"not"right@example.com>`,
 		`<this is"not\allowed@example.com>`,
 		`<this\ still\"not\\allowed@example.com>`,
 		`<john..doe@example.com>`,
 		`<john.doe@example..com>`,
 		`<john.doe@example..com>`,
 		`<john.doe.@example.com>`,
 		`<john.doe.@.example.com>`,
 		`<.john.doe@example.com>`,
 		`<@example.com>`,
 		`<.@example.com>`,
 		`<test@.>`,
 		`< @example.com>`,
 		`<""test""blah""@example.com>`,
 		`<""@0>`,
 	}

 	for _, test := range badTests {
 		_, err := ParseAddress(test)
 		if err == nil {
 			t.Errorf("Should have failed to parse address: %s", test)
 			continue
 		}

 	}

 }

 func TestAddressFormattingAndParsing(t *testing.T) {
 	tests := []*Address{
 		{Name: "@lïce", Address: "alice@example.com"},
 		{Name: "Böb O'Connor", Address: "bob@example.com"},
 		{Name: "???", Address: "bob@example.com"},
 		{Name: "Böb ???", Address: "bob@example.com"},
 		{Name: "Böb (Jacöb)", Address: "bob@example.com"},
 		{Name: "à#$%&'(),.:;<>@[]^`{|}~'", Address: "bob@example.com"},
 		// https://golang.org/issue/11292
 		{Name: "\"\\\x1f,\"", Address: "0@0"},
 		// https://golang.org/issue/12782
 		{Name: "naé, mée", Address: "test.mail@gmail.com"},
 	}

 	for i, test := range tests {
 		parsed, err := ParseAddress(test.String())
 		if err != nil {
 			t.Errorf("test #%d: ParseAddr(%q) error: %v", i, test.String(), err)
 			continue
 		}
 		if parsed.Name != test.Name {
 			t.Errorf("test #%d: Parsed name = %q; want %q", i, parsed.Name, test.Name)
 		}
 		if parsed.Address != test.Address {
 			t.Errorf("test #%d: Parsed address = %q; want %q", i, parsed.Address, test.Address)
 		}
 	}
 }
	// Copyright 2011 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 mail

	import (
	"bytes"
	"io"
	"io/ioutil"
	"mime"
	"reflect"
	"strings"
	"testing"
	"time"
	)

	var parseTests = []struct {
	in string
	header Header
	body string
	}{
	{
	// RFC 5322, Appendix A.1.1
	in: `From: John Doe <jdoe@machine.example>
	To: Mary Smith <mary@example.net>
	Subject: Saying Hello
	Date: Fri, 21 Nov 1997 09:55:06 -0600
	Message-ID: <1234@local.machine.example>

	This is a message just to say hello.
	So, "Hello".
	`,
	header: Header{
	"From": []string{"John Doe <jdoe@machine.example>"},
	"To": []string{"Mary Smith <mary@example.net>"},
	"Subject": []string{"Saying Hello"},
	"Date": []string{"Fri, 21 Nov 1997 09:55:06 -0600"},
	"Message-Id": []string{"<1234@local.machine.example>"},
	},
	body: "This is a message just to say hello.\nSo, \"Hello\".\n",
	},
	}

	func TestParsing(t *testing.T) {
	for i, test := range parseTests {
	msg, err := ReadMessage(bytes.NewBuffer([]byte(test.in)))
	if err != nil {
	t.Errorf("test #%d: Failed parsing message: %v", i, err)
	continue
	}
	if !headerEq(msg.Header, test.header) {
	t.Errorf("test #%d: Incorrectly parsed message header.\nGot:\n%+v\nWant:\n%+v",
	i, msg.Header, test.header)
	}
	body, err := ioutil.ReadAll(msg.Body)
	if err != nil {
	t.Errorf("test #%d: Failed reading body: %v", i, err)
	continue
	}
	bodyStr := string(body)
	if bodyStr != test.body {
	t.Errorf("test #%d: Incorrectly parsed message body.\nGot:\n%+v\nWant:\n%+v",
	i, bodyStr, test.body)
	}
	}
	}

	func headerEq(a, b Header) bool {
	if len(a) != len(b) {
	return false
	}
	for k, as := range a {
	bs, ok := b[k]
	if !ok {
	return false
	}
	if !reflect.DeepEqual(as, bs) {
	return false
	}
	}
	return true
	}

	func TestDateParsing(t *testing.T) {
	tests := []struct {
	dateStr string
	exp time.Time
	}{
	// RFC 5322, Appendix A.1.1
	{
	"Fri, 21 Nov 1997 09:55:06 -0600",
	time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("", -66060)),
	},
	// RFC 5322, Appendix A.6.2
	// Obsolete date.
	{
	"21 Nov 97 09:55:06 GMT",
	time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("GMT", 0)),
	},
	// Commonly found format not specified by RFC 5322.
	{
	"Fri, 21 Nov 1997 09:55:06 -0600 (MDT)",
	time.Date(1997, 11, 21, 9, 55, 6, 0, time.FixedZone("", -66060)),
	},
	}
	for _, test := range tests {
	hdr := Header{
	"Date": []string{test.dateStr},
	}
	date, err := hdr.Date()
	if err != nil {
	t.Errorf("Header(Date: %s).Date(): %v", test.dateStr, err)
	} else if !date.Equal(test.exp) {
	t.Errorf("Header(Date: %s).Date() = %+v, want %+v", test.dateStr, date, test.exp)
	}

	date, err = ParseDate(test.dateStr)
	if err != nil {
	t.Errorf("ParseDate(%s): %v", test.dateStr, err)
	} else if !date.Equal(test.exp) {
	t.Errorf("ParseDate(%s) = %+v, want %+v", test.dateStr, date, test.exp)
	}
	}
	}

	func TestAddressParsingError(t *testing.T) {
	mustErrTestCases := [...]struct {
	text string
	wantErrText string
	}{
	0: {"=?iso-8859-2?Q?Bogl=E1rka_Tak=E1cs?= <unknown@gmail.com>", "charset not supported"},
	1: {"a@gmail.com b@gmail.com", "expected single address"},
	2: {string([]byte{0xed, 0xa0, 0x80}) + " <micro@example.net>", "invalid utf-8 in address"},
	3: {"\"" + string([]byte{0xed, 0xa0, 0x80}) + "\" <half-surrogate@example.com>", "invalid utf-8 in quoted-string"},
	4: {"\"\\" + string([]byte{0x80}) + "\" <escaped-invalid-unicode@example.net>", "invalid utf-8 in quoted-string"},
	5: {"\"\x00\" <null@example.net>", "bad character in quoted-string"},
	6: {"\"\\\x00\" <escaped-null@example.net>", "bad character in quoted-string"},
	}

	for i, tc := range mustErrTestCases {
	_, err := ParseAddress(tc.text)
	if err == nil \|\| !strings.Contains(err.Error(), tc.wantErrText) {
	t.Errorf(`mail.ParseAddress(%q) #%d want %q, got %v`, tc.text, i, tc.wantErrText, err)
	}
	}
	}

	func TestAddressParsing(t *testing.T) {
	tests := []struct {
	addrsStr string
	exp []*Address
	}{
	// Bare address
	{
	`jdoe@machine.example`,
	[]*Address{{
	Address: "jdoe@machine.example",
	}},
	},
	// RFC 5322, Appendix A.1.1
	{
	`John Doe <jdoe@machine.example>`,
	[]*Address{{
	Name: "John Doe",
	Address: "jdoe@machine.example",
	}},
	},
	// RFC 5322, Appendix A.1.2
	{
	`"Joe Q. Public" <john.q.public@example.com>`,
	[]*Address{{
	Name: "Joe Q. Public",
	Address: "john.q.public@example.com",
	}},
	},
	{
	`Mary Smith <mary@x.test>, jdoe@example.org, Who? <one@y.test>`,
	[]*Address{
	{
	Name: "Mary Smith",
	Address: "mary@x.test",
	},
	{
	Address: "jdoe@example.org",
	},
	{
	Name: "Who?",
	Address: "one@y.test",
	},
	},
	},
	{
	`<boss@nil.test>, "Giant; \"Big\" Box" <sysservices@example.net>`,
	[]*Address{
	{
	Address: "boss@nil.test",
	},
	{
	Name: `Giant; "Big" Box`,
	Address: "sysservices@example.net",
	},
	},
	},
	// RFC 5322, Appendix A.1.3
	// TODO(dsymonds): Group addresses.

	// RFC 2047 "Q"-encoded ISO-8859-1 address.
	{
	`=?iso-8859-1?q?J=F6rg_Doe?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg Doe`,
	Address: "joerg@example.com",
	},
	},
	},
	// RFC 2047 "Q"-encoded US-ASCII address. Dumb but legal.
	{
	`=?us-ascii?q?J=6Frg_Doe?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jorg Doe`,
	Address: "joerg@example.com",
	},
	},
	},
	// RFC 2047 "Q"-encoded UTF-8 address.
	{
	`=?utf-8?q?J=C3=B6rg_Doe?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg Doe`,
	Address: "joerg@example.com",
	},
	},
	},
	// RFC 2047, Section 8.
	{
	`=?ISO-8859-1?Q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>`,
	[]*Address{
	{
	Name: `André Pirard`,
	Address: "PIRARD@vm1.ulg.ac.be",
	},
	},
	},
	// Custom example of RFC 2047 "B"-encoded ISO-8859-1 address.
	{
	`=?ISO-8859-1?B?SvZyZw==?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg`,
	Address: "joerg@example.com",
	},
	},
	},
	// Custom example of RFC 2047 "B"-encoded UTF-8 address.
	{
	`=?UTF-8?B?SsO2cmc=?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg`,
	Address: "joerg@example.com",
	},
	},
	},
	// Custom example with "." in name. For issue 4938
	{
	`Asem H. <noreply@example.com>`,
	[]*Address{
	{
	Name: `Asem H.`,
	Address: "noreply@example.com",
	},
	},
	},
	// RFC 6532 3.2.3, qtext /= UTF8-non-ascii
	{
	`"Gø Pher" <gopher@example.com>`,
	[]*Address{
	{
	Name: `Gø Pher`,
	Address: "gopher@example.com",
	},
	},
	},
	// RFC 6532 3.2, atext /= UTF8-non-ascii
	{
	`µ <micro@example.com>`,
	[]*Address{
	{
	Name: `µ`,
	Address: "micro@example.com",
	},
	},
	},
	// RFC 6532 3.2.2, local address parts allow UTF-8
	{
	`Micro <µ@example.com>`,
	[]*Address{
	{
	Name: `Micro`,
	Address: "µ@example.com",
	},
	},
	},
	// RFC 6532 3.2.4, domains parts allow UTF-8
	{
	`Micro <micro@µ.example.com>`,
	[]*Address{
	{
	Name: `Micro`,
	Address: "micro@µ.example.com",
	},
	},
	},
	// Issue 14866
	{
	`"" <emptystring@example.com>`,
	[]*Address{
	{
	Name: "",
	Address: "emptystring@example.com",
	},
	},
	},
	}
	for _, test := range tests {
	if len(test.exp) == 1 {
	addr, err := ParseAddress(test.addrsStr)
	if err != nil {
	t.Errorf("Failed parsing (single) %q: %v", test.addrsStr, err)
	continue
	}
	if !reflect.DeepEqual([]*Address{addr}, test.exp) {
	t.Errorf("Parse (single) of %q: got %+v, want %+v", test.addrsStr, addr, test.exp)
	}
	}

	addrs, err := ParseAddressList(test.addrsStr)
	if err != nil {
	t.Errorf("Failed parsing (list) %q: %v", test.addrsStr, err)
	continue
	}
	if !reflect.DeepEqual(addrs, test.exp) {
	t.Errorf("Parse (list) of %q: got %+v, want %+v", test.addrsStr, addrs, test.exp)
	}
	}
	}

	func TestAddressParser(t *testing.T) {
	tests := []struct {
	addrsStr string
	exp []*Address
	}{
	// Bare address
	{
	`jdoe@machine.example`,
	[]*Address{{
	Address: "jdoe@machine.example",
	}},
	},
	// RFC 5322, Appendix A.1.1
	{
	`John Doe <jdoe@machine.example>`,
	[]*Address{{
	Name: "John Doe",
	Address: "jdoe@machine.example",
	}},
	},
	// RFC 5322, Appendix A.1.2
	{
	`"Joe Q. Public" <john.q.public@example.com>`,
	[]*Address{{
	Name: "Joe Q. Public",
	Address: "john.q.public@example.com",
	}},
	},
	{
	`Mary Smith <mary@x.test>, jdoe@example.org, Who? <one@y.test>`,
	[]*Address{
	{
	Name: "Mary Smith",
	Address: "mary@x.test",
	},
	{
	Address: "jdoe@example.org",
	},
	{
	Name: "Who?",
	Address: "one@y.test",
	},
	},
	},
	{
	`<boss@nil.test>, "Giant; \"Big\" Box" <sysservices@example.net>`,
	[]*Address{
	{
	Address: "boss@nil.test",
	},
	{
	Name: `Giant; "Big" Box`,
	Address: "sysservices@example.net",
	},
	},
	},
	// RFC 2047 "Q"-encoded ISO-8859-1 address.
	{
	`=?iso-8859-1?q?J=F6rg_Doe?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg Doe`,
	Address: "joerg@example.com",
	},
	},
	},
	// RFC 2047 "Q"-encoded US-ASCII address. Dumb but legal.
	{
	`=?us-ascii?q?J=6Frg_Doe?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jorg Doe`,
	Address: "joerg@example.com",
	},
	},
	},
	// RFC 2047 "Q"-encoded ISO-8859-15 address.
	{
	`=?ISO-8859-15?Q?J=F6rg_Doe?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg Doe`,
	Address: "joerg@example.com",
	},
	},
	},
	// RFC 2047 "B"-encoded windows-1252 address.
	{
	`=?windows-1252?q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>`,
	[]*Address{
	{
	Name: `André Pirard`,
	Address: "PIRARD@vm1.ulg.ac.be",
	},
	},
	},
	// Custom example of RFC 2047 "B"-encoded ISO-8859-15 address.
	{
	`=?ISO-8859-15?B?SvZyZw==?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg`,
	Address: "joerg@example.com",
	},
	},
	},
	// Custom example of RFC 2047 "B"-encoded UTF-8 address.
	{
	`=?UTF-8?B?SsO2cmc=?= <joerg@example.com>`,
	[]*Address{
	{
	Name: `Jörg`,
	Address: "joerg@example.com",
	},
	},
	},
	// Custom example with "." in name. For issue 4938
	{
	`Asem H. <noreply@example.com>`,
	[]*Address{
	{
	Name: `Asem H.`,
	Address: "noreply@example.com",
	},
	},
	},
	}

	ap := AddressParser{WordDecoder: &mime.WordDecoder{
	CharsetReader: func(charset string, input io.Reader) (io.Reader, error) {
	in, err := ioutil.ReadAll(input)
	if err != nil {
	return nil, err
	}

	switch charset {
	case "iso-8859-15":
	in = bytes.Replace(in, []byte("\xf6"), []byte("ö"), -1)
	case "windows-1252":
	in = bytes.Replace(in, []byte("\xe9"), []byte("é"), -1)
	}

	return bytes.NewReader(in), nil
	},
	}}

	for _, test := range tests {
	if len(test.exp) == 1 {
	addr, err := ap.Parse(test.addrsStr)
	if err != nil {
	t.Errorf("Failed parsing (single) %q: %v", test.addrsStr, err)
	continue
	}
	if !reflect.DeepEqual([]*Address{addr}, test.exp) {
	t.Errorf("Parse (single) of %q: got %+v, want %+v", test.addrsStr, addr, test.exp)
	}
	}

	addrs, err := ap.ParseList(test.addrsStr)
	if err != nil {
	t.Errorf("Failed parsing (list) %q: %v", test.addrsStr, err)
	continue
	}
	if !reflect.DeepEqual(addrs, test.exp) {
	t.Errorf("Parse (list) of %q: got %+v, want %+v", test.addrsStr, addrs, test.exp)
	}
	}
	}

	func TestAddressString(t *testing.T) {
	tests := []struct {
	addr *Address
	exp string
	}{
	{
	&Address{Address: "bob@example.com"},
	"<bob@example.com>",
	},
	{ // quoted local parts: RFC 5322, 3.4.1. and 3.2.4.
	&Address{Address: `my@idiot@address@example.com`},
	`<"my@idiot@address"@example.com>`,
	},
	{ // quoted local parts
	&Address{Address: ` @example.com`},
	`<" "@example.com>`,
	},
	{
	&Address{Name: "Bob", Address: "bob@example.com"},
	`"Bob" <bob@example.com>`,
	},
	{
	// note the ö (o with an umlaut)
	&Address{Name: "Böb", Address: "bob@example.com"},
	`=?utf-8?q?B=C3=B6b?= <bob@example.com>`,
	},
	{
	&Address{Name: "Bob Jane", Address: "bob@example.com"},
	`"Bob Jane" <bob@example.com>`,
	},
	{
	&Address{Name: "Böb Jacöb", Address: "bob@example.com"},
	`=?utf-8?q?B=C3=B6b_Jac=C3=B6b?= <bob@example.com>`,
	},
	{ // https://golang.org/issue/12098
	&Address{Name: "Rob", Address: ""},
	`"Rob" <@>`,
	},
	{ // https://golang.org/issue/12098
	&Address{Name: "Rob", Address: "@"},
	`"Rob" <@>`,
	},
	{
	&Address{Name: "Böb, Jacöb", Address: "bob@example.com"},
	`=?utf-8?b?QsO2YiwgSmFjw7Zi?= <bob@example.com>`,
	},
	{
	&Address{Name: "=??Q?x?=", Address: "hello@world.com"},
	`"=??Q?x?=" <hello@world.com>`,
	},
	{
	&Address{Name: "=?hello", Address: "hello@world.com"},
	`"=?hello" <hello@world.com>`,
	},
	{
	&Address{Name: "world?=", Address: "hello@world.com"},
	`"world?=" <hello@world.com>`,
	},
	{
	// should q-encode even for invalid utf-8.
	&Address{Name: string([]byte{0xed, 0xa0, 0x80}), Address: "invalid-utf8@example.net"},
	"=?utf-8?q?=ED=A0=80?= <invalid-utf8@example.net>",
	},
	}
	for _, test := range tests {
	s := test.addr.String()
	if s != test.exp {
	t.Errorf("Address%+v.String() = %v, want %v", *test.addr, s, test.exp)
	continue
	}

	// Check round-trip.
	if test.addr.Address != "" && test.addr.Address != "@" {
	a, err := ParseAddress(test.exp)
	if err != nil {
	t.Errorf("ParseAddress(%#q): %v", test.exp, err)
	continue
	}
	if a.Name != test.addr.Name \|\| a.Address != test.addr.Address {
	t.Errorf("ParseAddress(%#q) = %#v, want %#v", test.exp, a, test.addr)
	}
	}
	}
	}

	// Check if all valid addresses can be parsed, formatted and parsed again
	func TestAddressParsingAndFormatting(t *testing.T) {

	// Should pass
	tests := []string{
	`<Bob@example.com>`,
	`<bob.bob@example.com>`,
	`<".bob"@example.com>`,
	`<" "@example.com>`,
	`<some.mail-with-dash@example.com>`,
	`<"dot.and space"@example.com>`,
	`<"very.unusual.@.unusual.com"@example.com>`,
	`<admin@mailserver1>`,
	`<postmaster@localhost>`,
	"<#!$%&'*+-/=?^_`{}\|~@example.org>",
	`<"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com>`, // escaped quotes
	`<"()<>[]:,;@\\\"!#$%&'*+-/=?^_{}\| ~.a"@example.org>`, // escaped backslashes
	`<"Abc\\@def"@example.com>`,
	`<"Joe\\Blow"@example.com>`,
	`<test1/test2=test3@example.com>`,
	`<def!xyz%abc@example.com>`,
	`<_somename@example.com>`,
	`<joe@uk>`,
	`<~@example.com>`,
	`<"..."@test.com>`,
	`<"john..doe"@example.com>`,
	`<"john.doe."@example.com>`,
	`<".john.doe"@example.com>`,
	`<"."@example.com>`,
	`<".."@example.com>`,
	`<"0:"@0>`,
	}

	for _, test := range tests {
	addr, err := ParseAddress(test)
	if err != nil {
	t.Errorf("Couldn't parse address %s: %s", test, err.Error())
	continue
	}
	str := addr.String()
	addr, err = ParseAddress(str)
	if err != nil {
	t.Errorf("ParseAddr(%q) error: %v", test, err)
	continue
	}

	if addr.String() != test {
	t.Errorf("String() round-trip = %q; want %q", addr, test)
	continue
	}

	}

	// Should fail
	badTests := []string{
	`<Abc.example.com>`,
	`<A@b@c@example.com>`,
	`<a"b(c)d,e:f;g<h>i[j\k]l@example.com>`,
	`<just"not"right@example.com>`,
	`<this is"not\allowed@example.com>`,
	`<this\ still\"not\\allowed@example.com>`,
	`<john..doe@example.com>`,
	`<john.doe@example..com>`,
	`<john.doe@example..com>`,
	`<john.doe.@example.com>`,
	`<john.doe.@.example.com>`,
	`<.john.doe@example.com>`,
	`<@example.com>`,
	`<.@example.com>`,
	`<test@.>`,
	`< @example.com>`,
	`<""test""blah""@example.com>`,
	`<""@0>`,
	}

	for _, test := range badTests {
	_, err := ParseAddress(test)
	if err == nil {
	t.Errorf("Should have failed to parse address: %s", test)
	continue
	}

	}

	}

	func TestAddressFormattingAndParsing(t *testing.T) {
	tests := []*Address{
	{Name: "@lïce", Address: "alice@example.com"},
	{Name: "Böb O'Connor", Address: "bob@example.com"},
	{Name: "???", Address: "bob@example.com"},
	{Name: "Böb ???", Address: "bob@example.com"},
	{Name: "Böb (Jacöb)", Address: "bob@example.com"},
	{Name: "à#$%&'(),.:;<>@[]^`{\|}~'", Address: "bob@example.com"},
	// https://golang.org/issue/11292
	{Name: "\"\\\x1f,\"", Address: "0@0"},
	// https://golang.org/issue/12782
	{Name: "naé, mée", Address: "test.mail@gmail.com"},
	}

	for i, test := range tests {
	parsed, err := ParseAddress(test.String())
	if err != nil {
	t.Errorf("test #%d: ParseAddr(%q) error: %v", i, test.String(), err)
	continue
	}
	if parsed.Name != test.Name {
	t.Errorf("test #%d: Parsed name = %q; want %q", i, parsed.Name, test.Name)
	}
	if parsed.Address != test.Address {
	t.Errorf("test #%d: Parsed address = %q; want %q", i, parsed.Address, test.Address)
	}
	}
	}