/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package javax.mail.internet;
import java.io.*;
import java.util.*;
import javax.mail.*;
import javax.mail.internet.HeaderTokenizer;
import javax.mail.internet.ParseException;
import org.junit.Test;
import org.junit.Assert;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
/**
* Test MIME HeaderTokenizer.
*
* @author Bill Shannon
*/
@RunWith(Parameterized.class)
public class HeaderTokenizerTest {
private String header;
private String value;
private String[] expect;
static boolean gen_test_input = false; // output good for input to -p
static boolean parse_mail = false; // parse input in mail format
static boolean return_comments = false; // return comments as tokens
static boolean mime = false; // use MIME specials
static int errors = 0; // number of errors detected
static boolean junit;
static List testData;
public HeaderTokenizerTest(String heder, String value, String[] expect) {
this.header = header;
this.value = value;
this.expect = expect;
}
@Parameters
public static Collection data() throws IOException {
junit = true;
testData = new ArrayList();
parse(new BufferedReader(new InputStreamReader(
InternetAddressTest.class.getResourceAsStream("tokenlist"))));
return testData;
}
@Test
public void test() {
test(header, value, expect);
}
public static void main(String argv[]) throws Exception {
int optind;
for (optind = 0; optind < argv.length; optind++) {
if (argv[optind].equals("-")) {
// ignore
} else if (argv[optind].equals("-g")) {
gen_test_input = true;
} else if (argv[optind].equals("-p")) {
parse_mail = true;
} else if (argv[optind].equals("-c")) {
return_comments = true;
} else if (argv[optind].equals("-m")) {
mime = true;
} else if (argv[optind].equals("--")) {
optind++;
break;
} else if (argv[optind].startsWith("-")) {
System.out.println(
"Usage: tokenizertest [-g] [-p] [-c] [-m] [-] [header ...]");
System.exit(1);
} else {
break;
}
}
/*
* If there's any args left on the command line,
* concatenate them into a string and test that.
*/
if (optind < argv.length) {
StringBuffer sb = new StringBuffer();
for (int i = optind; i < argv.length; i++) {
sb.append(argv[i]);
sb.append(" ");
}
test("To", sb.toString(), null);
} else {
// read from stdin
BufferedReader in =
new BufferedReader(new InputStreamReader(System.in));
String s;
if (parse_mail)
parse(in);
else {
while ((s = in.readLine()) != null)
test("To", s, null);
}
}
System.exit(errors);
}
/*
* Parse the input in "mail" format, extracting the From, To, and Cc
* headers and testing them. The parse is rather crude, but sufficient
* to test against most existing UNIX mailboxes.
*/
public static void parse(BufferedReader in) throws IOException {
String header = "";
for (;;) {
String s = in.readLine();
if (s != null && s.length() > 0) {
char c = s.charAt(0);
if (c == ' ' || c == '\t') {
// a continuation line, add it to the current header
header += '\n' + s;
continue;
}
}
// "s" is the next header, "header" is the last complete header
if (header.startsWith("From: ") ||
header.startsWith("To: ") ||
header.startsWith("Cc: ")) {
int i;
String[] expect = null;
if (s != null && s.startsWith("Expect: ")) {
try {
int nexpect = Integer.parseInt(s.substring(8));
expect = new String[nexpect];
for (i = 0; i < nexpect; i++)
expect[i] = in.readLine().trim();
} catch (NumberFormatException e) {
try {
if (s.substring(8, 17).equals("Exception")) {
expect = new String[1];
expect[0] = "Exception";
}
} catch (StringIndexOutOfBoundsException se) {
// ignore it
}
}
}
i = header.indexOf(':');
try {
if (junit)
testData.add(new Object[] {
header.substring(0, i),
header.substring(i + 2),
expect });
else
test(header.substring(0, i), header.substring(i + 2),
expect);
} catch (StringIndexOutOfBoundsException e) {
// ignore
}
}
if (s == null)
return; // EOF
if (s.length() == 0) {
while ((s = in.readLine()) != null) {
if (s.startsWith("From "))
break;
}
if (s == null)
return;
}
header = s;
}
}
/**
* Test the header's value to see if we can tokenize it as expected.
*/
public static void test(String header, String value, String expect[]) {
PrintStream out = System.out;
if (gen_test_input)
out.println(header + ": " + value);
else if (!junit)
out.println("Test: " + value);
try {
HeaderTokenizer ht = new HeaderTokenizer(value,
mime ? HeaderTokenizer.MIME : HeaderTokenizer.RFC822,
!return_comments);
HeaderTokenizer.Token tok;
Vector toklist = new Vector();
while ((tok = ht.next()).getType() != HeaderTokenizer.Token.EOF)
toklist.addElement(tok);
if (gen_test_input)
out.println("Expect: " + toklist.size());
else {
if (junit) {
Assert.assertEquals("Number of tokens",
expect.length, toklist.size());
} else {
out.println("Got " + toklist.size() + " tokens:");
if (expect != null && toklist.size() != expect.length) {
out.println("Expected " + expect.length + " tokens");
errors++;
}
}
}
for (int i = 0; i < toklist.size(); i++) {
tok = (HeaderTokenizer.Token)toklist.elementAt(i);
if (gen_test_input)
out.println("\t" + type(tok.getType()) +
"\t" + tok.getValue());
else {
if (!junit)
out.println("\t[" + (i+1) + "] " + type(tok.getType()) +
"\t" + tok.getValue());
if (expect != null && i < expect.length) {
HeaderTokenizer.Token t = makeToken(expect[i]);
if (junit) {
Assert.assertEquals("Token type",
t.getType(), tok.getType());
Assert.assertEquals("Token value",
t.getValue(), tok.getValue());
} else {
if (t.getType() != tok.getType() ||
!t.getValue().equals(tok.getValue())) {
out.println("\tExpected:\t" +
type(t.getType()) + "\t" + t.getValue());
errors++;
}
}
}
}
}
} catch (ParseException e) {
if (gen_test_input)
out.println("Expect: Exception " + e);
else {
if (junit) {
Assert.assertTrue("Expected exception",
expect.length == 1 && expect[0].equals("Exception"));
} else {
out.println("Got Exception: " + e);
if (expect != null &&
(expect.length != 1 || !expect[0].equals("Exception"))) {
out.println("Expected " + expect.length + " tokens");
for (int i = 0; i < expect.length; i++)
out.println("\tExpected:\t" + expect[i]);
errors++;
}
}
}
}
}
private static String type(int t) {
if (t == HeaderTokenizer.Token.ATOM)
return "ATOM";
else if (t == HeaderTokenizer.Token.QUOTEDSTRING)
return "QUOTEDSTRING";
else if (t == HeaderTokenizer.Token.COMMENT)
return "COMMENT";
else if (t == HeaderTokenizer.Token.EOF)
return "EOF";
else if (t < 0)
return "UNKNOWN";
else
return "SPECIAL";
}
private static int type(String s) {
if (s.equals("ATOM"))
return HeaderTokenizer.Token.ATOM;
else if (s.equals("QUOTEDSTRING"))
return HeaderTokenizer.Token.QUOTEDSTRING;
else if (s.equals("COMMENT"))
return HeaderTokenizer.Token.COMMENT;
else if (s.equals("EOF"))
return HeaderTokenizer.Token.EOF;
else // if (s.equals("SPECIAL"))
return 0;
}
private static HeaderTokenizer.Token makeToken(String line) {
int i = line.indexOf('\t');
int t = type(line.substring(0, i));
String value = line.substring(i + 1);
if (t == 0)
return new HeaderTokenizer.Token(value.charAt(0), value);
else
return new HeaderTokenizer.Token(t, value);
}
private static final String n(String s) {
return s == null ? "<null>" : s;
}
}