/* * Copyright (C) 2009 The Android Open Source Project * * Licensed 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 com.android.emailcommon.internet; import android.test.AndroidTestCase; import android.test.suitebuilder.annotation.MediumTest; import android.test.suitebuilder.annotation.SmallTest; import com.android.emailcommon.TempDirectory; import com.android.emailcommon.mail.Address; import com.android.emailcommon.mail.Flag; import com.android.emailcommon.mail.Message.RecipientType; import com.android.emailcommon.mail.MessagingException; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Locale; /** * This is a series of unit tests for the MimeMessage class. These tests must be locally * complete - no server(s) required. */ @SmallTest public class MimeMessageTest extends AndroidTestCase { /** up arrow, down arrow, left arrow, right arrow */ private final String SHORT_UNICODE = "\u2191\u2193\u2190\u2192"; private final String SHORT_UNICODE_ENCODED = "=?UTF-8?B?4oaR4oaT4oaQ4oaS?="; /** a string without any unicode */ private final String SHORT_PLAIN = "abcd"; /** longer unicode strings */ private final String LONG_UNICODE_16 = SHORT_UNICODE + SHORT_UNICODE + SHORT_UNICODE + SHORT_UNICODE; private final String LONG_UNICODE_64 = LONG_UNICODE_16 + LONG_UNICODE_16 + LONG_UNICODE_16 + LONG_UNICODE_16; /** longer plain strings (with fold points) */ private final String LONG_PLAIN_16 = "abcdefgh ijklmno"; private final String LONG_PLAIN_64 = LONG_PLAIN_16 + LONG_PLAIN_16 + LONG_PLAIN_16 + LONG_PLAIN_16; private final String LONG_PLAIN_256 = LONG_PLAIN_64 + LONG_PLAIN_64 + LONG_PLAIN_64 + LONG_PLAIN_64; @Override protected void setUp() throws Exception { super.setUp(); TempDirectory.setTempDirectory(getContext()); } /** * Confirms that setSentDate() correctly set the "Date" header of a Mime message. * * We tries a same test twice using two locales, Locale.US and the other, since * MimeMessage depends on the date formatter, which may emit wrong date format * in the locale other than Locale.US. * @throws MessagingException * @throws ParseException */ @MediumTest public void testSetSentDate() throws MessagingException, ParseException { Locale savedLocale = Locale.getDefault(); Locale.setDefault(Locale.US); doTestSetSentDate(); Locale.setDefault(Locale.JAPAN); doTestSetSentDate(); Locale.setDefault(savedLocale); } private void doTestSetSentDate() throws MessagingException, ParseException { // "Thu, 01 Jan 2009 09:00:00 +0000" => 1230800400000L long expectedTime = 1230800400000L; Date date = new Date(expectedTime); MimeMessage message = new MimeMessage(); message.setSentDate(date); String[] headers = message.getHeader("Date"); assertEquals(1, headers.length); // Explicitly specify the locale so that the object does not depend on the default // locale. SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z", Locale.US); Date result = format.parse(headers[0]); assertEquals(expectedTime, result.getTime()); } /** * Simple tests of the new "Message-ID" header */ public void testMessageId() throws MessagingException { // Test 1. Every message gets a default and unique message-id MimeMessage message1 = new MimeMessage(); MimeMessage message2 = new MimeMessage(); String id1 = message1.getMessageId(); String id2 = message2.getMessageId(); assertNotNull(id1); assertNotNull(id2); assertFalse("Message-ID should be unique", id1.equals(id2)); // Test 2. Set and get using API final String testId1 = "test-message-id-one"; message1.setMessageId(testId1); assertEquals("set and get Message-ID", testId1, message1.getMessageId()); // Test 3. Should only be one Message-ID per message final String testId2 = "test-message-id-two"; message2.setMessageId(testId1); message2.setMessageId(testId2); assertEquals("set and get Message-ID", testId2, message2.getMessageId()); } /** * Confirm getContentID() correctly works. */ public void testGetContentId() throws MessagingException { MimeMessage message = new MimeMessage(); // no content-id assertNull(message.getContentId()); // normal case final String cid1 = "cid.1@android.com"; message.setHeader(MimeHeader.HEADER_CONTENT_ID, cid1); assertEquals(cid1, message.getContentId()); // surrounded by optional bracket message.setHeader(MimeHeader.HEADER_CONTENT_ID, "<" + cid1 + ">"); assertEquals(cid1, message.getContentId()); } /** * Confirm that setSubject() works with plain strings */ public void testSetSubjectPlain() throws MessagingException { MimeMessage message = new MimeMessage(); message.setSubject(SHORT_PLAIN); // test 1: readback assertEquals("plain subjects", SHORT_PLAIN, message.getSubject()); // test 2: raw readback is not escaped String rawHeader = message.getFirstHeader("Subject"); assertEquals("plain subject not encoded", -1, rawHeader.indexOf("=?")); // test 3: long subject (shouldn't fold) message.setSubject(LONG_PLAIN_64); rawHeader = message.getFirstHeader("Subject"); String[] split = rawHeader.split("\r\n"); assertEquals("64 shouldn't fold", 1, split.length); // test 4: very long subject (should fold) message.setSubject(LONG_PLAIN_256); rawHeader = message.getFirstHeader("Subject"); split = rawHeader.split("\r\n"); assertTrue("long subject should fold", split.length > 1); for (String s : split) { assertTrue("split lines max length 78", s.length() <= 76); // 76+\r\n = 78 String trimmed = s.trim(); assertFalse("split lines are not encoded", trimmed.startsWith("=?")); } } /** * Confirm that setSubject() works with unicode strings */ public void testSetSubject() throws MessagingException { MimeMessage message = new MimeMessage(); message.setSubject(SHORT_UNICODE); // test 1: readback in unicode assertEquals("unicode readback", SHORT_UNICODE, message.getSubject()); // test 2: raw readback is escaped String rawHeader = message.getFirstHeader("Subject"); assertEquals("raw readback", SHORT_UNICODE_ENCODED, rawHeader); } /** * Confirm folding operations on unicode subjects */ public void testSetLongSubject() throws MessagingException { MimeMessage message = new MimeMessage(); // test 1: long unicode - readback in unicode message.setSubject(LONG_UNICODE_16); assertEquals("unicode readback 16", LONG_UNICODE_16, message.getSubject()); // test 2: longer unicode (will fold) message.setSubject(LONG_UNICODE_64); assertEquals("unicode readback 64", LONG_UNICODE_64, message.getSubject()); // test 3: check folding & encoding String rawHeader = message.getFirstHeader("Subject"); String[] split = rawHeader.split("\r\n"); assertTrue("long subject should fold", split.length > 1); for (String s : split) { assertTrue("split lines max length 78", s.length() <= 76); // 76+\r\n = 78 String trimmed = s.trim(); assertTrue("split lines are encoded", trimmed.startsWith("=?") && trimmed.endsWith("?=")); } } /** * Test for encoding address field. */ public void testEncodingAddressField() throws MessagingException { Address noName1 = new Address("noname1@dom1.com"); Address noName2 = new Address("", ""); Address simpleName = new Address("address3@dom3.org", "simple long and long long name"); Address dquoteName = new Address("address4@dom4.org", "name,4,long long name"); Address quotedName = new Address("bigG@dom5.net", "big \"G\""); Address utf16Name = new Address("", "\"\u65E5\u672C\u8A9E\""); Address utf32Name = new Address("", "\uD834\uDF01\uD834\uDF46"); MimeMessage message = new MimeMessage(); message.setFrom(noName1); message.setRecipient(RecipientType.TO, noName2); message.setRecipients(RecipientType.CC, new Address[] { simpleName, dquoteName }); message.setReplyTo(new Address[] { quotedName, utf16Name, utf32Name }); String[] from = message.getHeader("From"); String[] to = message.getHeader("To"); String[] cc = message.getHeader("Cc"); String[] replyTo = message.getHeader("Reply-to"); assertEquals("from address count", 1, from.length); assertEquals("no name 1", "noname1@dom1.com", from[0]); assertEquals("to address count", 1, to.length); assertEquals("no name 2", "noname2@dom2.com", to[0]); // folded. assertEquals("cc address count", 1, cc.length); assertEquals("simple name & double quoted name", "simple long and long long name , \"name,4,long long\r\n" + " name\" ", cc[0]); // folded and encoded. assertEquals("reply-to address count", 1, replyTo.length); assertEquals("quoted name & encoded name", "\"big \\\"G\\\"\" , =?UTF-8?B?5pel5pys6Kqe?=\r\n" + " , =?UTF-8?B?8J2MgfCdjYY=?= ", replyTo[0]); } /** * Test for parsing address field. */ public void testParsingAddressField() throws MessagingException { MimeMessage message = new MimeMessage(); message.setHeader("From", "noname1@dom1.com"); message.setHeader("To", ""); // folded. message.setHeader("Cc", "simple name ,\r\n" + " \"name,4\" "); // folded and encoded. message.setHeader("Reply-to", "\"big \\\"G\\\"\" ,\r\n" + " =?UTF-8?B?5pel5pys6Kqe?=\r\n" + " ,\n" + " \"=?UTF-8?B?8J2MgfCdjYY=?=\" "); Address[] from = message.getFrom(); Address[] to = message.getRecipients(RecipientType.TO); Address[] cc = message.getRecipients(RecipientType.CC); Address[] replyTo = message.getReplyTo(); assertEquals("from address count", 1, from.length); assertEquals("no name 1 address", "noname1@dom1.com", from[0].getAddress()); assertNull("no name 1 name", from[0].getPersonal()); assertEquals("to address count", 1, to.length); assertEquals("no name 2 address", "noname2@dom2.com", to[0].getAddress()); assertNull("no name 2 name", to[0].getPersonal()); assertEquals("cc address count", 2, cc.length); assertEquals("simple name address", "address3@dom3.org", cc[0].getAddress()); assertEquals("simple name name", "simple name", cc[0].getPersonal()); assertEquals("double quoted name address", "address4@dom4.org", cc[1].getAddress()); assertEquals("double quoted name name", "name,4", cc[1].getPersonal()); assertEquals("reply-to address count", 3, replyTo.length); assertEquals("quoted name address", "bigG@dom5.net", replyTo[0].getAddress()); assertEquals("quoted name name", "big \"G\"", replyTo[0].getPersonal()); assertEquals("utf-16 name address", "address6@co.jp", replyTo[1].getAddress()); assertEquals("utf-16 name name", "\u65E5\u672C\u8A9E", replyTo[1].getPersonal()); assertEquals("utf-32 name address", "address8@ne.jp", replyTo[2].getAddress()); assertEquals("utf-32 name name", "\uD834\uDF01\uD834\uDF46", replyTo[2].getPersonal()); } /* * Test setting & getting store-specific flags */ public void testStoreFlags() throws MessagingException { MimeMessage message = new MimeMessage(); // Message should create with no flags Flag[] flags = message.getFlags(); assertEquals(0, flags.length); // Set a store flag message.setFlag(Flag.X_STORE_1, true); assertTrue(message.isSet(Flag.X_STORE_1)); assertFalse(message.isSet(Flag.X_STORE_2)); // Set another message.setFlag(Flag.X_STORE_2, true); assertTrue(message.isSet(Flag.X_STORE_1)); assertTrue(message.isSet(Flag.X_STORE_2)); // Set some and clear some message.setFlag(Flag.X_STORE_1, false); assertFalse(message.isSet(Flag.X_STORE_1)); assertTrue(message.isSet(Flag.X_STORE_2)); } /* * Test for setExtendedHeader() and getExtendedHeader() */ public void testExtendedHeader() throws MessagingException { MimeMessage message = new MimeMessage(); assertNull("non existent header", message.getExtendedHeader("X-Non-Existent")); message.setExtendedHeader("X-Header1", "value1"); message.setExtendedHeader("X-Header2", "value2\n value3\r\n value4\r\n"); assertEquals("simple value", "value1", message.getExtendedHeader("X-Header1")); assertEquals("multi line value", "value2 value3 value4", message.getExtendedHeader("X-Header2")); assertNull("non existent header 2", message.getExtendedHeader("X-Non-Existent")); message.setExtendedHeader("X-Header1", "value4"); assertEquals("over written value", "value4", message.getExtendedHeader("X-Header1")); message.setExtendedHeader("X-Header1", null); assertNull("remove header", message.getExtendedHeader("X-Header1")); } /* * Test for setExtendedHeaders() and getExtendedheaders() */ public void testExtendedHeaders() throws MessagingException { MimeMessage message = new MimeMessage(); assertNull("new message", message.getExtendedHeaders()); message.setExtendedHeaders(null); assertNull("null headers", message.getExtendedHeaders()); message.setExtendedHeaders(""); assertNull("empty headers", message.getExtendedHeaders()); message.setExtendedHeaders("X-Header1: value1\r\n"); assertEquals("header 1 value", "value1", message.getExtendedHeader("X-Header1")); assertEquals("header 1", "X-Header1: value1\r\n", message.getExtendedHeaders()); message.setExtendedHeaders(null); message.setExtendedHeader("X-Header2", "value2"); message.setExtendedHeader("X-Header3", "value3\n value4\r\n value5\r\n"); assertEquals("headers 2,3", "X-Header2: value2\r\n" + "X-Header3: value3 value4 value5\r\n", message.getExtendedHeaders()); message.setExtendedHeaders( "X-Header3: value3 value4 value5\r\n" + "X-Header2: value2\r\n"); assertEquals("header 2", "value2", message.getExtendedHeader("X-Header2")); assertEquals("header 3", "value3 value4 value5", message.getExtendedHeader("X-Header3")); assertEquals("headers 3,2", "X-Header3: value3 value4 value5\r\n" + "X-Header2: value2\r\n", message.getExtendedHeaders()); } /* * Test for writeTo(), only for header part. * NOTE: This test is fragile because it assumes headers will be written in a specific order */ public void testWriteToHeader() throws Exception { MimeMessage message = new MimeMessage(); message.setHeader("Header1", "value1"); message.setHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA, "value2"); message.setExtendedHeader("X-Header3", "value3"); message.setHeader("Header4", "value4"); message.setExtendedHeader("X-Header5", "value5"); ByteArrayOutputStream out = new ByteArrayOutputStream(); message.writeTo(out); out.close(); String expectedString = "Header1: value1\r\n" + "Header4: value4\r\n" + "Message-ID: " + message.getMessageId() + "\r\n" + "\r\n"; byte[] expected = expectedString.getBytes(); byte[] actual = out.toByteArray(); assertEquals("output length", expected.length, actual.length); for (int i = 0; i < actual.length; ++i) { assertEquals("output byte["+i+"]", expected[i], actual[i]); } } /** * Test for parsing headers with extra whitespace and commennts. * * The lines up to Content-Type were copied directly out of RFC 2822 * "Section A.5. White space, comments, and other oddities" */ public void brokentestWhiteSpace() throws MessagingException, IOException { String entireMessage = "From: Pete(A wonderful \\) chap) \r\n"+ "To:A Group(Some people)\r\n"+ " :Chris Jones ,\r\n"+ " joe@example.org,\r\n"+ " John (my dear friend); (the end of the group)\r\n"+ "Cc:(Empty list)(start)Undisclosed recipients :(nobody(that I know)) ;\r\n"+ "Date: Thu,\r\n"+ " 13\r\n"+ " Feb\r\n"+ " 1969\r\n"+ " 23:32\r\n"+ " -0330 (Newfoundland Time)\r\n"+ "Message-ID: \r\n"+ "Content-Type: \r\n"+ " TEXT/hTML \r\n"+ " ; x-blah=\"y-blah\" ; \r\n"+ " CHARSET=\"us-ascii\" ; (comment)\r\n"+ "\r\n"+ "Testing.\r\n"; MimeMessage mm = null; mm = new MimeMessage(new ByteArrayInputStream( entireMessage.getBytes("us-ascii"))); assertTrue(mm.getMimeType(), MimeUtility.mimeTypeMatches("text/html",mm.getMimeType())); assertEquals(new Date(-27723480000L),mm.getSentDate()); assertEquals("",mm.getMessageId()); Address[] toAddresses = mm.getRecipients(MimeMessage.RecipientType.TO); assertEquals("joe@example.org", toAddresses[1].getAddress()); assertEquals("jdoe@one.test", toAddresses[2].getAddress()); // Note: The parentheses in the middle of email addresses are not removed. //assertEquals("c@public.example", toAddresses[0].getAddress()); //assertEquals("pete@silly.test",mm.getFrom()[0].getAddress()); } /** * Confirm parser doesn't crash when seeing "Undisclosed recipients:;". */ public void testUndisclosedRecipients() throws MessagingException, IOException { String entireMessage = "To:Undisclosed recipients:;\r\n"+ "Cc:Undisclosed recipients:;\r\n"+ "Bcc:Undisclosed recipients:;\r\n"+ "\r\n"; MimeMessage mm = null; mm = new MimeMessage(new ByteArrayInputStream( entireMessage.getBytes("us-ascii"))); assertEquals(0, mm.getRecipients(MimeMessage.RecipientType.TO).length); assertEquals(0, mm.getRecipients(MimeMessage.RecipientType.CC).length); assertEquals(0, mm.getRecipients(MimeMessage.RecipientType.BCC).length); } /** * Confirm parser doesn't crash when seeing invalid headers/addresses. */ public void testInvalidHeaders() throws MessagingException, IOException { String entireMessage = "To:\r\n"+ "Cc:!invalid!address!, a@b.com\r\n"+ "Bcc:Undisclosed recipients;\r\n"+ // no colon at the end "invalid header\r\n"+ "Message-ID:\r\n"+ "\r\n"+ "Testing\r\n"; MimeMessage mm = null; mm = new MimeMessage(new ByteArrayInputStream( entireMessage.getBytes("us-ascii"))); assertEquals(0, mm.getRecipients(MimeMessage.RecipientType.TO).length); assertEquals(1, mm.getRecipients(MimeMessage.RecipientType.CC).length); assertEquals("a@b.com", mm.getRecipients(MimeMessage.RecipientType.CC)[0].getAddress()); assertEquals(0, mm.getRecipients(MimeMessage.RecipientType.BCC).length); assertEquals("", mm.getMessageId()); } /** * Confirm parser w/o a message-id inhibits a local message-id from being generated */ public void testParseNoMessageId() throws MessagingException, IOException { String entireMessage = "To: user@domain.com\r\n" + "\r\n" + "Testing\r\n"; MimeMessage mm = null; mm = new MimeMessage(new ByteArrayInputStream(entireMessage.getBytes("us-ascii"))); assertNull(mm.getMessageId()); } /** * Make sure the parser accepts the "eBay style" date format. * * Messages from ebay have been seen that they use the wrong date format. * @see com.android.emailcommon.utility.Utility#cleanUpMimeDate */ public void testEbayDate() throws MessagingException, IOException { String entireMessage = "To:a@b.com\r\n" + "Date:Thu, 10 Dec 09 15:08:08 GMT-0700" + "\r\n" + "\r\n"; MimeMessage mm = null; mm = new MimeMessage(new ByteArrayInputStream(entireMessage.getBytes("us-ascii"))); Date actual = mm.getSentDate(); Date expected = new Date(Date.UTC(109, 11, 10, 15, 8, 8) + 7 * 60 * 60 * 1000); assertEquals(expected, actual); } // TODO more test for writeTo() }