/**************************************************************** | |
* Licensed to the Apache Software Foundation (ASF) under one * | |
* or more contributor license agreements. See the NOTICE file * | |
* distributed with this work for additional information * | |
* regarding copyright ownership. The ASF licenses this file * | |
* to you under the Apache License, Version 2.0 (the * | |
* "License"); you may not use this file except in compliance * | |
* with the License. You may obtain a copy of the License at * | |
* * | |
* http://www.apache.org/licenses/LICENSE-2.0 * | |
* * | |
* Unless required by applicable law or agreed to in writing, * | |
* software distributed under the License is distributed on an * | |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * | |
* KIND, either express or implied. See the License for the * | |
* specific language governing permissions and limitations * | |
* under the License. * | |
****************************************************************/ | |
package org.apache.james.mime4j.field.address; | |
import org.apache.james.mime4j.MimeException; | |
import org.apache.james.mime4j.field.address.parser.ParseException; | |
import java.io.BufferedReader; | |
import java.io.InputStream; | |
import java.io.InputStreamReader; | |
import java.io.PipedInputStream; | |
import java.io.PipedOutputStream; | |
import java.io.PrintStream; | |
import java.io.PrintWriter; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.List; | |
import junit.framework.TestCase; | |
public class AddressTest extends TestCase { | |
public void testExceptionTree() { | |
// make sure that our ParseException extends MimeException. | |
assertTrue(MimeException.class.isAssignableFrom(ParseException.class)); | |
} | |
public void testParse1() throws ParseException { | |
AddressList addrList = AddressList.parse("John Doe <jdoe@machine(comment). example>"); | |
assertEquals(1, addrList.size()); | |
Mailbox mailbox = (Mailbox)addrList.get(0); | |
assertEquals("John Doe", mailbox.getName()); | |
assertEquals("jdoe", mailbox.getLocalPart()); | |
assertEquals("machine.example", mailbox.getDomain()); | |
} | |
public void testParse2() throws ParseException { | |
AddressList addrList = AddressList.parse("Mary Smith \t \t\t <mary@example.net>"); | |
assertEquals(1, addrList.size()); | |
Mailbox mailbox = (Mailbox)addrList.get(0); | |
assertEquals("Mary Smith", mailbox.getName()); | |
assertEquals("mary", mailbox.getLocalPart()); | |
assertEquals("example.net", mailbox.getDomain()); | |
} | |
public void testEmptyGroup() throws ParseException { | |
AddressList addrList = AddressList.parse("undisclosed-recipients:;"); | |
assertEquals(1, addrList.size()); | |
Group group = (Group)addrList.get(0); | |
assertEquals(0, group.getMailboxes().size()); | |
assertEquals("undisclosed-recipients", group.getName()); | |
} | |
public void testMessyGroupAndMailbox() throws ParseException { | |
AddressList addrList = AddressList.parse("Marketing folks : Jane Smith < jane @ example . net >, \" Jack \\\"Jackie\\\" Jones \" < jjones@example.com > (comment(comment)); ,, (comment) , <@example . net,@example(ignore\\)).com:(ignore)john@(ignore)example.net>"); | |
assertEquals(2, addrList.size()); | |
Group group = (Group)addrList.get(0); | |
assertEquals("Marketing folks", group.getName()); | |
assertEquals(2, group.getMailboxes().size()); | |
Mailbox mailbox1 = group.getMailboxes().get(0); | |
Mailbox mailbox2 = group.getMailboxes().get(1); | |
assertEquals("Jane Smith", mailbox1.getName()); | |
assertEquals("jane", mailbox1.getLocalPart()); | |
assertEquals("example.net", mailbox1.getDomain()); | |
assertEquals(" Jack \"Jackie\" Jones ", mailbox2.getName()); | |
assertEquals("jjones", mailbox2.getLocalPart()); | |
assertEquals("example.com", mailbox2.getDomain()); | |
Mailbox mailbox = (Mailbox)addrList.get(1); | |
assertEquals("john", mailbox.getLocalPart()); | |
assertEquals("example.net", mailbox.getDomain()); | |
assertEquals(2, mailbox.getRoute().size()); | |
assertEquals("example.net", mailbox.getRoute().get(0)); | |
assertEquals("example.com", mailbox.getRoute().get(1)); | |
} | |
public void testEmptyAddressList() throws ParseException { | |
assertEquals(0, AddressList.parse(" \t \t ").size()); | |
assertEquals(0, AddressList.parse(" \t , , , ,,, , \t ").size()); | |
} | |
public void testSimpleForm() throws ParseException { | |
AddressList addrList = AddressList.parse("\"a b c d e f g\" (comment) @example.net"); | |
assertEquals(1, addrList.size()); | |
Mailbox mailbox = (Mailbox)addrList.get(0); | |
assertEquals("a b c d e f g", mailbox.getLocalPart()); | |
assertEquals("example.net", mailbox.getDomain()); | |
} | |
public void testFlatten() throws ParseException { | |
AddressList addrList = AddressList.parse("dev : one@example.com, two@example.com; , ,,, marketing:three@example.com ,four@example.com;, five@example.com"); | |
assertEquals(3, addrList.size()); | |
assertEquals(5, addrList.flatten().size()); | |
} | |
public void testTortureTest() throws ParseException { | |
// Source: http://mailformat.dan.info/headers/from.html | |
// (Commented out pending confirmation of legality--I think the local-part is illegal.) | |
// AddressList.parse("\"Guy Macon\" <guymacon+\" http://www.guymacon.com/ \"00@spamcop.net>"); | |
// Taken mostly from RFC822. | |
// Just make sure these are recognized as legal address lists; | |
// there shouldn't be any aspect of the RFC that is tested here | |
// but not in the other unit tests. | |
AddressList.parse("Alfred Neuman <Neuman@BBN-TENEXA>"); | |
AddressList.parse("Neuman@BBN-TENEXA"); | |
AddressList.parse("\"George, Ted\" <Shared@Group.Arpanet>"); | |
AddressList.parse("Wilt . (the Stilt) Chamberlain@NBA.US"); | |
// NOTE: In RFC822 8.1.5, the following example did not have "Galloping Gourmet" | |
// in double-quotes. I can only assume this was a typo, since 6.2.4 specifically | |
// disallows spaces in unquoted local-part. | |
AddressList.parse(" Gourmets: Pompous Person <WhoZiWhatZit@Cordon-Bleu>," + | |
" Childs@WGBH.Boston, \"Galloping Gourmet\"@" + | |
" ANT.Down-Under (Australian National Television)," + | |
" Cheapie@Discount-Liquors;," + | |
" Cruisers: Port@Portugal, Jones@SEA;," + | |
" Another@Somewhere.SomeOrg"); | |
// NOTE: In RFC822 8.3.3, the following example ended with a lone ">" after | |
// Tops-20-Host. I can only assume this was a typo, since 6.1 clearly shows | |
// ">" requires a matching "<". | |
AddressList.parse("Important folk:" + | |
" Tom Softwood <Balsa@Tree.Root>," + | |
" \"Sam Irving\"@Other-Host;," + | |
" Standard Distribution:" + | |
" /main/davis/people/standard@Other-Host," + | |
" \"<Jones>standard.dist.3\"@Tops-20-Host;"); | |
// The following are from a Usenet post by Dan J. Bernstein: | |
// http://groups.google.com/groups?selm=1996Aug1418.21.01.28081%40koobera.math.uic.edu | |
AddressList.parse("\":sysmail\"@ Some-Group.\t Some-Org, Muhammed.(I am the greatest) Ali @(the)Vegas.WBA"); | |
AddressList.parse("me@home.com (comment (nested (deeply\\))))"); | |
AddressList.parse("mailing list: me@home.com, route two <you@work.com>, them@play.com ;"); | |
} | |
public void testLexicalError() { | |
// ensure that TokenMgrError doesn't get thrown | |
try { | |
AddressList.parse(")"); | |
fail("Expected parsing error"); | |
} | |
catch (ParseException e) { | |
} | |
} | |
public void testNullConstructorAndBadUsage() { | |
AddressList al = new AddressList(null, false); | |
assertEquals(0, al.size()); | |
try { | |
al.get(-1); | |
fail("Expected index out of bound exception!"); | |
} catch (IndexOutOfBoundsException e) { | |
} | |
try { | |
al.get(0); | |
fail("Expected index out of bound exception!"); | |
} catch (IndexOutOfBoundsException e) { | |
} | |
} | |
public void testAddressList() throws ParseException { | |
AddressList addlist = AddressList.parse("foo@example.com, bar@example.com, third@example.com"); | |
List<Address> al = new ArrayList<Address>(); | |
al.add(addlist.get(0)); | |
// shared arraylist | |
AddressList dl = new AddressList(al, true); | |
assertEquals(1, dl.size()); | |
al.add(addlist.get(1)); | |
assertEquals(2, dl.size()); | |
// cloned arraylist | |
AddressList dlcopy = new AddressList(al, false); | |
assertEquals(2, dlcopy.size()); | |
al.add(addlist.get(2)); | |
assertEquals(2, dlcopy.size()); | |
// check route string | |
assertEquals(2, dlcopy.flatten().size()); | |
} | |
public void testInteractiveMain() throws Exception { | |
PrintStream out_orig = System.out; | |
InputStream in_orig = System.in; | |
PrintStream err_orig = System.err; | |
try { | |
PipedOutputStream piped = new PipedOutputStream(); | |
PipedInputStream newInput = new PipedInputStream(piped); | |
PipedInputStream inOut = new PipedInputStream(); | |
PrintStream outPs = new PrintStream(new PipedOutputStream(inOut)); | |
BufferedReader outReader = new BufferedReader(new InputStreamReader(inOut)); | |
PipedInputStream inErr = new PipedInputStream(); | |
PrintStream errPs = new PrintStream(new PipedOutputStream(inErr)); | |
BufferedReader errReader = new BufferedReader(new InputStreamReader(inErr)); | |
System.setIn(newInput); | |
System.setOut(outPs); | |
System.setErr(errPs); | |
Thread t = new Thread() { | |
@Override | |
public void run() { | |
try { | |
AddressList.main(null); | |
} catch (Exception e) { | |
fail("Catched an exception in main: "+e); | |
} | |
} | |
}; | |
t.start(); | |
PrintWriter input = new PrintWriter(piped); | |
input.write("Test <test@example.com>\r\n"); | |
input.flush(); | |
String out = outReader.readLine(); | |
assertEquals("> Test <test@example.com>", out); | |
input.write("A <foo@example.com>\r\n"); | |
input.flush(); | |
String out2 = outReader.readLine(); | |
assertEquals("> A <foo@example.com>", out2); | |
input.write("\"Foo Bar\" <foo>\r\n"); | |
input.flush(); | |
String out3 = errReader.readLine(); | |
assertNotNull(out3); | |
input.write("quit\r\n"); | |
input.flush(); | |
// we read 2 angular brackets because one was from the previous exception error. | |
String out4 = outReader.readLine(); | |
assertEquals("> > Goodbye.", out4); | |
t.join(); | |
} finally { | |
System.setIn(in_orig); | |
System.setOut(out_orig); | |
System.setErr(err_orig); | |
} | |
} | |
public void testEmptyDomainList() { | |
DomainList dl = new DomainList(null, false); | |
assertEquals(0, dl.size()); | |
try { | |
dl.get(-1); | |
fail("Expected index out of bound exception!"); | |
} catch (IndexOutOfBoundsException e) { | |
} | |
try { | |
dl.get(0); | |
fail("Expected index out of bound exception!"); | |
} catch (IndexOutOfBoundsException e) { | |
} | |
} | |
public void testDomainList() { | |
List<String> al = new ArrayList<String>(); | |
al.add("example.com"); | |
// shared arraylist | |
DomainList dl = new DomainList(al, true); | |
assertEquals(1, dl.size()); | |
al.add("foo.example.com"); | |
assertEquals(2, dl.size()); | |
// cloned arraylist | |
DomainList dlcopy = new DomainList(al, false); | |
assertEquals(2, dlcopy.size()); | |
al.add("bar.example.com"); | |
assertEquals(2, dlcopy.size()); | |
// check route string | |
assertEquals("@example.com,@foo.example.com", dlcopy.toRouteString()); | |
} | |
public void testEmptyMailboxList() { | |
MailboxList ml = new MailboxList(null, false); | |
assertEquals(0, ml.size()); | |
try { | |
ml.get(-1); | |
fail("Expected index out of bound exception!"); | |
} catch (IndexOutOfBoundsException e) { | |
} | |
try { | |
ml.get(0); | |
fail("Expected index out of bound exception!"); | |
} catch (IndexOutOfBoundsException e) { | |
} | |
} | |
public void testMailboxList() { | |
List<Mailbox> al = new ArrayList<Mailbox>(); | |
al.add(new Mailbox("local","example.com")); | |
// shared arraylist | |
MailboxList ml = new MailboxList(al, true); | |
assertEquals(1, ml.size()); | |
al.add(new Mailbox("local2", "foo.example.com")); | |
assertEquals(2, ml.size()); | |
// cloned arraylist | |
MailboxList mlcopy = new MailboxList(al, false); | |
assertEquals(2, mlcopy.size()); | |
al.add(new Mailbox("local3", "bar.example.com")); | |
assertEquals(2, mlcopy.size()); | |
mlcopy.print(); | |
} | |
public void testGroupSerialization() { | |
List<Mailbox> al = new ArrayList<Mailbox>(); | |
al.add(new Mailbox("test", "example.com")); | |
al.add(new Mailbox("Foo!", "foo", "example.com")); | |
DomainList dl = new DomainList(new ArrayList<String>(Arrays.asList(new String[] {"foo.example.com"})), true); | |
Mailbox mailbox = new Mailbox("Foo Bar", dl, "foo2", "example.com"); | |
assertSame(dl, mailbox.getRoute()); | |
al.add(mailbox); | |
Group g = new Group("group", new MailboxList(al, false)); | |
assertEquals("group: test@example.com, Foo! <foo@example.com>, Foo Bar <foo2@example.com>;", g.getDisplayString()); | |
} | |
public void testEmptyQuotedStringBeforeDotAtomInLocalPart() throws Exception { | |
/* | |
* This used to give a StringIndexOutOfBoundsException instead of the expected | |
* ParseException | |
*/ | |
try { | |
AddressList.parse("\"\"bar@bar.com"); | |
fail("ParseException expected"); | |
} catch (ParseException pe) { | |
} | |
} | |
public void testMailboxGetEncodedString() throws Exception { | |
assertEquals("john.doe@acme.org", new Mailbox("john.doe", "acme.org") | |
.getEncodedString()); | |
assertEquals("\"john doe\"@acme.org", new Mailbox("john doe", | |
"acme.org").getEncodedString()); | |
assertEquals("John Doe <john.doe@acme.org>", new Mailbox("John Doe", | |
"john.doe", "acme.org").getEncodedString()); | |
assertEquals("\"John Doe @Home\" <john.doe@acme.org>", new Mailbox( | |
"John Doe @Home", "john.doe", "acme.org").getEncodedString()); | |
assertEquals("=?ISO-8859-1?Q?Hans_M=FCller?= <hans.mueller@acme.org>", | |
new Mailbox("Hans M\374ller", "hans.mueller", "acme.org") | |
.getEncodedString()); | |
} | |
public void testGroupGetEncodedString() throws Exception { | |
List<Mailbox> al = new ArrayList<Mailbox>(); | |
al.add(new Mailbox("test", "example.com")); | |
al.add(new Mailbox("Foo!", "foo", "example.com")); | |
al.add(new Mailbox("Hans M\374ller", "hans.mueller", "acme.org")); | |
Group g = new Group("group @work", new MailboxList(al, false)); | |
assertEquals("\"group @work\": test@example.com, " | |
+ "Foo! <foo@example.com>, =?ISO-8859-1?Q?Hans_M=FCller?=" | |
+ " <hans.mueller@acme.org>;", g.getEncodedString()); | |
} | |
public void testEmptyGroupGetEncodedString() throws Exception { | |
MailboxList emptyMailboxes = new MailboxList(null, true); | |
Group g = new Group("Undisclosed recipients", emptyMailboxes); | |
assertEquals("Undisclosed recipients:;", g.getEncodedString()); | |
} | |
public void testParseAddress() throws Exception { | |
Address address = Address.parse("Mary Smith <mary@example.net>"); | |
assertTrue(address instanceof Mailbox); | |
assertEquals("Mary Smith", ((Mailbox) address).getName()); | |
assertEquals("mary@example.net", ((Mailbox) address).getAddress()); | |
address = Address.parse("group: Mary Smith <mary@example.net>;"); | |
assertTrue(address instanceof Group); | |
assertEquals("group", ((Group) address).getName()); | |
assertEquals("Mary Smith", ((Group) address).getMailboxes().get(0) | |
.getName()); | |
assertEquals("mary@example.net", ((Group) address).getMailboxes() | |
.get(0).getAddress()); | |
try { | |
Group.parse("john.doe@acme.org, jane.doe@acme.org"); | |
fail(); | |
} catch (IllegalArgumentException expected) { | |
} | |
} | |
public void testParseGroup() throws Exception { | |
Group group = Group | |
.parse("group: john.doe@acme.org, Mary Smith <mary@example.net>;"); | |
assertEquals("group", group.getName()); | |
MailboxList mailboxes = group.getMailboxes(); | |
assertEquals(2, mailboxes.size()); | |
Mailbox mailbox1 = mailboxes.get(0); | |
assertNull(mailbox1.getName()); | |
assertEquals("john.doe@acme.org", mailbox1.getAddress()); | |
Mailbox mailbox2 = mailboxes.get(1); | |
assertEquals("Mary Smith", mailbox2.getName()); | |
assertEquals("mary@example.net", mailbox2.getAddress()); | |
try { | |
Group.parse("john.doe@acme.org"); | |
fail(); | |
} catch (IllegalArgumentException expected) { | |
} | |
try { | |
Group.parse("g1: john.doe@acme.org;, g2: mary@example.net;"); | |
fail(); | |
} catch (IllegalArgumentException expected) { | |
} | |
} | |
public void testParseMailbox() throws Exception { | |
Mailbox mailbox1 = Mailbox.parse("john.doe@acme.org"); | |
assertNull(mailbox1.getName()); | |
assertEquals("john.doe@acme.org", mailbox1.getAddress()); | |
Mailbox mailbox2 = Mailbox.parse("Mary Smith <mary@example.net>"); | |
assertEquals("Mary Smith", mailbox2.getName()); | |
assertEquals("mary@example.net", mailbox2.getAddress()); | |
// non-ascii should be allowed in quoted strings | |
Mailbox mailbox3 = Mailbox | |
.parse("\"Hans M\374ller\" <hans.mueller@acme.org>"); | |
assertEquals("Hans M\374ller", mailbox3.getName()); | |
assertEquals("hans.mueller@acme.org", mailbox3.getAddress()); | |
try { | |
Mailbox.parse("g: Mary Smith <mary@example.net>;"); | |
fail(); | |
} catch (IllegalArgumentException expected) { | |
} | |
try { | |
Mailbox.parse("Mary Smith <mary@example.net>, hans.mueller@acme.org"); | |
fail(); | |
} catch (IllegalArgumentException expected) { | |
} | |
} | |
} |