icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/DataDrivenNumberFormatTestUtility.java - external/github.com/unicode-org/icu - Git at Google

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
  *******************************************************************************
  * Copyright (C) 2015, International Business Machines Corporation and         *
  * others. All Rights Reserved.                                                *
  *******************************************************************************
  */
 package com.ibm.icu.dev.test.format;

 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.List;

 import com.ibm.icu.dev.test.TestFmwk;
 import com.ibm.icu.dev.test.TestUtil;
 import com.ibm.icu.impl.Utility;

 /**
  * A collection of methods to run the data driven number format test suite.
  */
 public class DataDrivenNumberFormatTestUtility extends TestFmwk {

     /**
      * Base class for code under test.
      */
     public static abstract class CodeUnderTest {

         /**
          * Returns the ID of the code under test. This ID is used to identify
          * tests that are known to fail for this particular code under test.
          * This implementation returns null which means that by default all
          * tests should work with this code under test.
          * @return 'J' means ICU4J, 'K' means JDK
          */
         public Character Id() {
             return null;
         }

         /**
          *  Runs a single formatting test. On success, returns null.
          *  On failure, returns the error. This implementation just returns null.
          *  Subclasses should override.
          *  @param tuple contains the parameters of the format test.
          */
         public String format(DataDrivenNumberFormatTestData tuple) {
             if (tuple.output != null && tuple.output.equals("fail")) return "fail";
             return null;
         }

         /**
          *  Runs a single toPattern test. On success, returns null.
          *  On failure, returns the error. This implementation just returns null.
          *  Subclasses should override.
          *  @param tuple contains the parameters of the format test.
          */
         public String toPattern(DataDrivenNumberFormatTestData tuple) {
             if (tuple.output != null && tuple.output.equals("fail")) return "fail";
             return null;
         }

         /**
          *  Runs a single parse test. On success, returns null.
          *  On failure, returns the error. This implementation just returns null.
          *  Subclasses should override.
          *  @param tuple contains the parameters of the format test.
          */
         public String parse(DataDrivenNumberFormatTestData tuple) {
             if (tuple.output != null && tuple.output.equals("fail")) return "fail";
             return null;
         }

         /**
          *  Runs a single parse currency test. On success, returns null.
          *  On failure, returns the error. This implementation just returns null.
          *  Subclasses should override.
          *  @param tuple contains the parameters of the format test.
          */
         public String parseCurrency(DataDrivenNumberFormatTestData tuple) {
             if (tuple.output != null && tuple.output.equals("fail")) return "fail";
             return null;
         }

         /**
          * Runs a single select test. On success, returns null.
          *  On failure, returns the error. This implementation just returns null.
          *  Subclasses should override.
          * @param tuple contains the parameters of the format test.
          */
         public String select(DataDrivenNumberFormatTestData tuple) {
             if (tuple.output != null && tuple.output.equals("fail")) return "fail";
             return null;
         }
     }

     private static enum RunMode {
         SKIP_KNOWN_FAILURES,
         INCLUDE_KNOWN_FAILURES,
         CHECK_FOR_UNKNOWN_IDS
     }

     private final CodeUnderTest codeUnderTest;
     private final String allowedIDs;
     private String fileLine = null;
     private int fileLineNumber = 0;
     private String fileTestName = "";
     private DataDrivenNumberFormatTestData tuple = new DataDrivenNumberFormatTestData();

     /**
      * Runs all the tests in the data driven test suite against codeUnderTest.
      * @param fileName The name of the test file. A relative file name under
      *   com/ibm/icu/dev/data such as "data.txt"
      * @param codeUnderTest the code under test
      */

     public static void runSuite(
             String fileName, CodeUnderTest codeUnderTest) {
         new DataDrivenNumberFormatTestUtility(codeUnderTest)
                 .run(fileName, RunMode.SKIP_KNOWN_FAILURES);
     }

     /**
      * Runs every format test in data driven test suite including those
      * that are known to fail.  If a test is supposed to fail but actually
      * passes, an error is printed.
      *
      * @param fileName The name of the test file. A relative file name under
      *   com/ibm/icu/dev/data such as "data.txt"
      * @param codeUnderTest the code under test
      */
     public static void runFormatSuiteIncludingKnownFailures(
             String fileName, CodeUnderTest codeUnderTest) {
         new DataDrivenNumberFormatTestUtility(codeUnderTest)
                 .run(fileName, RunMode.INCLUDE_KNOWN_FAILURES);
     }

     /**
      * Checks the data file for no unknown IDs in "breaks" columns.
      */
     public static void checkNoUnknownIDs(String fileName, String allowedIDs) {
         new DataDrivenNumberFormatTestUtility(allowedIDs).run(fileName, RunMode.CHECK_FOR_UNKNOWN_IDS);
     }

     private DataDrivenNumberFormatTestUtility(CodeUnderTest codeUnderTest) {
         this.codeUnderTest = codeUnderTest;
         this.allowedIDs = null;
     }

     private DataDrivenNumberFormatTestUtility(String allowedIDs) {
         this.codeUnderTest = null;
         this.allowedIDs = allowedIDs;
     }

     private void run(String fileName, RunMode runMode) {
         char codeUnderTestId = (codeUnderTest == null) ? 0 : codeUnderTest.Id();
         BufferedReader in = null;
         try {
             in = TestUtil.getDataReader("numberformattestspecification.txt", "UTF-8");
             // read first line and remove BOM if present
             readLine(in);
             if (fileLine != null && fileLine.charAt(0) == '\uFEFF') {
                 fileLine = fileLine.substring(1);
             }

             int state = 0;
             List<String> columnValues;
             List<String> columnNames = null;
             while (true) {
                 if (fileLine == null || fileLine.length() == 0) {
                     if (!readLine(in)) {
                         break;
                     }
                     if (fileLine.length() == 0 && state == 2) {
                         state = 0;
                     }
                     continue;
                 }
                 if (fileLine.startsWith("//")) {
                     fileLine = null;
                     continue;
                 }
                 // Initial setup of test.
                 if (state == 0) {
                     if (fileLine.startsWith("test ")) {
                         fileTestName = fileLine;
                         tuple = new DataDrivenNumberFormatTestData();
                     } else if (fileLine.startsWith("set ")) {
                         if (!setTupleField()) {
                             return;
                         }
                     } else if(fileLine.startsWith("begin")) {
                         state = 1;
                     } else {
                         showError("Unrecognized verb.");
                         return;
                     }
                 // column specification
                 } else if (state == 1) {
                     columnNames = splitBy((char) 0x09);
                     state = 2;
                     // "breaks" column must be last!
                     if (columnNames.contains("breaks")
                             && columnNames.indexOf("breaks") != columnNames.size() - 1) {
                         showError("'breaks' column must be last!");
                     }
                 // run the tests
                 } else {
                     int columnNamesSize = columnNames.size();
                     columnValues = splitBy(columnNamesSize, (char) 0x09);
                     int columnValuesSize = columnValues.size();
                     for (int i = 0; i < columnValuesSize; ++i) {
                         if (!setField(columnNames.get(i), columnValues.get(i))) {
                             return;
                         }
                     }
                     for (int i = columnValuesSize; i < columnNamesSize; ++i) {
                         if (!clearField(columnNames.get(i))) {
                             return;
                         }
                     }
                     if (runMode == RunMode.CHECK_FOR_UNKNOWN_IDS) {
                         String actualIDs = tuple.breaks;
                         if (actualIDs != null) {
                             // Make sure there are no IDs in actualIDs that are not in allowedIDs.
                             // As a bonus, check that actualIDs are in alphabetical order.
                             char prevID = 0;
                             for (int i=0; i<actualIDs.length(); i++) {
                                 char currID = actualIDs.charAt(i);
                                 if (allowedIDs.indexOf(currID) == -1) {
                                     showError("Unknown ID: " + currID);
                                 }
                                 if (prevID > currID) {
                                     showError("IDs not in alphabetical order: " + actualIDs);
                                 }
                                 prevID = currID;
                             }
                         }
                     } else if (runMode == RunMode.INCLUDE_KNOWN_FAILURES || !breaks(codeUnderTestId)) {
                         String errorMessage;
                         Exception err = null;
                         boolean shouldFail = (tuple.output != null && tuple.output.equals("fail"))
                                 ? !breaks(codeUnderTestId)
                                 : breaks(codeUnderTestId);
                         try {
                             errorMessage = isPass(tuple);
                         } catch (Exception e) {
                             err = e;
                             errorMessage = "Exception: " + e + ": " + e.getCause();
                         }
                         if (shouldFail && errorMessage == null) {
                             showError("Expected failure, but passed");
                         } else if (!shouldFail && errorMessage != null) {
                             if (err != null) {
                                 ByteArrayOutputStream os = new ByteArrayOutputStream();
                                 PrintStream ps = new PrintStream(os);
                                 err.printStackTrace(ps);
                                 String stackTrace = os.toString();
                                 showError(errorMessage + "     Stack trace: " + stackTrace.substring(0, 500));
                             } else {
                                 showError(errorMessage);
                             }
                         }
                     }
                 }
                 fileLine = null;
             }
         } catch (Exception e) {
             ByteArrayOutputStream os = new ByteArrayOutputStream();
             PrintStream ps = new PrintStream(os);
             e.printStackTrace(ps);
             String stackTrace = os.toString();
             showError("MAJOR ERROR: " + e.toString() + "     Stack trace: " + stackTrace.substring(0,500));
         } finally {
             try {
                 if (in != null) {
                     in.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }

     private boolean breaks(char code) {
        String breaks = tuple.breaks == null ? "" : tuple.breaks;
        return (breaks.toUpperCase().indexOf(code) != -1);
     }

     private static boolean isSpace(char c) {
         return (c == 0x09 || c == 0x20 || c == 0x3000);
     }

     private boolean setTupleField() {
         List<String> parts = splitBy(3, (char) 0x20);
         if (parts.size() < 3) {
             showError("Set expects 2 parameters");
             return false;
         }
         return setField(parts.get(1), parts.get(2));
     }

     private boolean setField(String name, String value) {
         try {
             tuple.setField(name,  Utility.unescape(value));
             return true;
         } catch (Exception e) {
             showError("No such field: " + name + ", or bad value: " + value + ": " + e);
             return false;
         }
     }

     private boolean clearField(String name) {
         try {
             tuple.clearField(name);
             return true;
         } catch (Exception e) {
             showError("Field cannot be clared: " + name);
             return false;
         }
     }

     private void showError(String message) {
         TestFmwk.errln(String.format("line %d: %s\n%s\n%s", fileLineNumber, Utility.escape(message), fileTestName,fileLine));
     }

     private List<String> splitBy(char delimiter) {
         return splitBy(Integer.MAX_VALUE, delimiter);
     }

     private List<String> splitBy(int max, char delimiter) {
         ArrayList<String> result = new ArrayList<String>();
         int colIdx = 0;
         int colStart = 0;
         int len = fileLine.length();
         for (int idx = 0; colIdx < max - 1 && idx < len; ++idx) {
             char ch = fileLine.charAt(idx);
             if (ch == delimiter) {
                 result.add(
                         fileLine.substring(colStart, idx));
                 ++colIdx;
                 colStart = idx + 1;
             }
         }
         result.add(fileLine.substring(colStart, len));
         return result;
     }

     private boolean readLine(BufferedReader in) throws IOException {
         String line = in.readLine();
         if (line == null) {
             fileLine = null;
             return false;
         }
         ++fileLineNumber;
         // Strip trailing comments and spaces
         int idx = line.length();
         for (; idx > 0; idx--) {
             if (!isSpace(line.charAt(idx -1))) {
                 break;
             }
         }
         fileLine = idx == 0 ? "" : line;
         return true;
     }

     private String isPass(DataDrivenNumberFormatTestData tuple) {
         StringBuilder result = new StringBuilder();
         if (tuple.format != null && tuple.output != null) {
             String errorMessage = codeUnderTest.format(tuple);
             if (errorMessage != null) {
                 result.append(errorMessage);
             }
         } else if (tuple.toPattern != null || tuple.toLocalizedPattern != null) {
             String errorMessage = codeUnderTest.toPattern(tuple);
             if (errorMessage != null) {
                 result.append(errorMessage);
             }
         } else if (tuple.parse != null && tuple.output != null && tuple.outputCurrency != null) {
             String errorMessage = codeUnderTest.parseCurrency(tuple);
             if (errorMessage != null) {
                 result.append(errorMessage);
             }
         } else if (tuple.parse != null && tuple.output != null) {
             String errorMessage = codeUnderTest.parse(tuple);
             if (errorMessage != null) {
                 result.append(errorMessage);
             }
         } else if (tuple.plural != null) {
             String errorMessage = codeUnderTest.select(tuple);
             if (errorMessage != null) {
                 result.append(errorMessage);
             }
         } else {
             result.append("Unrecognized test type.");
         }
         if (result.length() > 0) {
             result.append(": ");
             result.append(tuple);
             return result.toString();
         }
         return null;
     }
 }
	// © 2016 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html
	/*
	*******************************************************************************
	* Copyright (C) 2015, International Business Machines Corporation and *
	* others. All Rights Reserved. *
	*******************************************************************************
	*/
	package com.ibm.icu.dev.test.format;

	import java.io.BufferedReader;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.PrintStream;
	import java.util.ArrayList;
	import java.util.List;

	import com.ibm.icu.dev.test.TestFmwk;
	import com.ibm.icu.dev.test.TestUtil;
	import com.ibm.icu.impl.Utility;

	/**
	* A collection of methods to run the data driven number format test suite.
	*/
	public class DataDrivenNumberFormatTestUtility extends TestFmwk {

	/**
	* Base class for code under test.
	*/
	public static abstract class CodeUnderTest {

	/**
	* Returns the ID of the code under test. This ID is used to identify
	* tests that are known to fail for this particular code under test.
	* This implementation returns null which means that by default all
	* tests should work with this code under test.
	* @return 'J' means ICU4J, 'K' means JDK
	*/
	public Character Id() {
	return null;
	}

	/**
	* Runs a single formatting test. On success, returns null.
	* On failure, returns the error. This implementation just returns null.
	* Subclasses should override.
	* @param tuple contains the parameters of the format test.
	*/
	public String format(DataDrivenNumberFormatTestData tuple) {
	if (tuple.output != null && tuple.output.equals("fail")) return "fail";
	return null;
	}

	/**
	* Runs a single toPattern test. On success, returns null.
	* On failure, returns the error. This implementation just returns null.
	* Subclasses should override.
	* @param tuple contains the parameters of the format test.
	*/
	public String toPattern(DataDrivenNumberFormatTestData tuple) {
	if (tuple.output != null && tuple.output.equals("fail")) return "fail";
	return null;
	}

	/**
	* Runs a single parse test. On success, returns null.
	* On failure, returns the error. This implementation just returns null.
	* Subclasses should override.
	* @param tuple contains the parameters of the format test.
	*/
	public String parse(DataDrivenNumberFormatTestData tuple) {
	if (tuple.output != null && tuple.output.equals("fail")) return "fail";
	return null;
	}

	/**
	* Runs a single parse currency test. On success, returns null.
	* On failure, returns the error. This implementation just returns null.
	* Subclasses should override.
	* @param tuple contains the parameters of the format test.
	*/
	public String parseCurrency(DataDrivenNumberFormatTestData tuple) {
	if (tuple.output != null && tuple.output.equals("fail")) return "fail";
	return null;
	}

	/**
	* Runs a single select test. On success, returns null.
	* On failure, returns the error. This implementation just returns null.
	* Subclasses should override.
	* @param tuple contains the parameters of the format test.
	*/
	public String select(DataDrivenNumberFormatTestData tuple) {
	if (tuple.output != null && tuple.output.equals("fail")) return "fail";
	return null;
	}
	}

	private static enum RunMode {
	SKIP_KNOWN_FAILURES,
	INCLUDE_KNOWN_FAILURES,
	CHECK_FOR_UNKNOWN_IDS
	}

	private final CodeUnderTest codeUnderTest;
	private final String allowedIDs;
	private String fileLine = null;
	private int fileLineNumber = 0;
	private String fileTestName = "";
	private DataDrivenNumberFormatTestData tuple = new DataDrivenNumberFormatTestData();

	/**
	* Runs all the tests in the data driven test suite against codeUnderTest.
	* @param fileName The name of the test file. A relative file name under
	* com/ibm/icu/dev/data such as "data.txt"
	* @param codeUnderTest the code under test
	*/

	public static void runSuite(
	String fileName, CodeUnderTest codeUnderTest) {
	new DataDrivenNumberFormatTestUtility(codeUnderTest)
	.run(fileName, RunMode.SKIP_KNOWN_FAILURES);
	}

	/**
	* Runs every format test in data driven test suite including those
	* that are known to fail. If a test is supposed to fail but actually
	* passes, an error is printed.
	*
	* @param fileName The name of the test file. A relative file name under
	* com/ibm/icu/dev/data such as "data.txt"
	* @param codeUnderTest the code under test
	*/
	public static void runFormatSuiteIncludingKnownFailures(
	String fileName, CodeUnderTest codeUnderTest) {
	new DataDrivenNumberFormatTestUtility(codeUnderTest)
	.run(fileName, RunMode.INCLUDE_KNOWN_FAILURES);
	}

	/**
	* Checks the data file for no unknown IDs in "breaks" columns.
	*/
	public static void checkNoUnknownIDs(String fileName, String allowedIDs) {
	new DataDrivenNumberFormatTestUtility(allowedIDs).run(fileName, RunMode.CHECK_FOR_UNKNOWN_IDS);
	}

	private DataDrivenNumberFormatTestUtility(CodeUnderTest codeUnderTest) {
	this.codeUnderTest = codeUnderTest;
	this.allowedIDs = null;
	}

	private DataDrivenNumberFormatTestUtility(String allowedIDs) {
	this.codeUnderTest = null;
	this.allowedIDs = allowedIDs;
	}

	private void run(String fileName, RunMode runMode) {
	char codeUnderTestId = (codeUnderTest == null) ? 0 : codeUnderTest.Id();
	BufferedReader in = null;
	try {
	in = TestUtil.getDataReader("numberformattestspecification.txt", "UTF-8");
	// read first line and remove BOM if present
	readLine(in);
	if (fileLine != null && fileLine.charAt(0) == '\uFEFF') {
	fileLine = fileLine.substring(1);
	}

	int state = 0;
	List<String> columnValues;
	List<String> columnNames = null;
	while (true) {
	if (fileLine == null \|\| fileLine.length() == 0) {
	if (!readLine(in)) {
	break;
	}
	if (fileLine.length() == 0 && state == 2) {
	state = 0;
	}
	continue;
	}
	if (fileLine.startsWith("//")) {
	fileLine = null;
	continue;
	}
	// Initial setup of test.
	if (state == 0) {
	if (fileLine.startsWith("test ")) {
	fileTestName = fileLine;
	tuple = new DataDrivenNumberFormatTestData();
	} else if (fileLine.startsWith("set ")) {
	if (!setTupleField()) {
	return;
	}
	} else if(fileLine.startsWith("begin")) {
	state = 1;
	} else {
	showError("Unrecognized verb.");
	return;
	}
	// column specification
	} else if (state == 1) {
	columnNames = splitBy((char) 0x09);
	state = 2;
	// "breaks" column must be last!
	if (columnNames.contains("breaks")
	&& columnNames.indexOf("breaks") != columnNames.size() - 1) {
	showError("'breaks' column must be last!");
	}
	// run the tests
	} else {
	int columnNamesSize = columnNames.size();
	columnValues = splitBy(columnNamesSize, (char) 0x09);
	int columnValuesSize = columnValues.size();
	for (int i = 0; i < columnValuesSize; ++i) {
	if (!setField(columnNames.get(i), columnValues.get(i))) {
	return;
	}
	}
	for (int i = columnValuesSize; i < columnNamesSize; ++i) {
	if (!clearField(columnNames.get(i))) {
	return;
	}
	}
	if (runMode == RunMode.CHECK_FOR_UNKNOWN_IDS) {
	String actualIDs = tuple.breaks;
	if (actualIDs != null) {
	// Make sure there are no IDs in actualIDs that are not in allowedIDs.
	// As a bonus, check that actualIDs are in alphabetical order.
	char prevID = 0;
	for (int i=0; i<actualIDs.length(); i++) {
	char currID = actualIDs.charAt(i);
	if (allowedIDs.indexOf(currID) == -1) {
	showError("Unknown ID: " + currID);
	}
	if (prevID > currID) {
	showError("IDs not in alphabetical order: " + actualIDs);
	}
	prevID = currID;
	}
	}
	} else if (runMode == RunMode.INCLUDE_KNOWN_FAILURES \|\| !breaks(codeUnderTestId)) {
	String errorMessage;
	Exception err = null;
	boolean shouldFail = (tuple.output != null && tuple.output.equals("fail"))
	? !breaks(codeUnderTestId)
	: breaks(codeUnderTestId);
	try {
	errorMessage = isPass(tuple);
	} catch (Exception e) {
	err = e;
	errorMessage = "Exception: " + e + ": " + e.getCause();
	}
	if (shouldFail && errorMessage == null) {
	showError("Expected failure, but passed");
	} else if (!shouldFail && errorMessage != null) {
	if (err != null) {
	ByteArrayOutputStream os = new ByteArrayOutputStream();
	PrintStream ps = new PrintStream(os);
	err.printStackTrace(ps);
	String stackTrace = os.toString();
	showError(errorMessage + " Stack trace: " + stackTrace.substring(0, 500));
	} else {
	showError(errorMessage);
	}
	}
	}
	}
	fileLine = null;
	}
	} catch (Exception e) {
	ByteArrayOutputStream os = new ByteArrayOutputStream();
	PrintStream ps = new PrintStream(os);
	e.printStackTrace(ps);
	String stackTrace = os.toString();
	showError("MAJOR ERROR: " + e.toString() + " Stack trace: " + stackTrace.substring(0,500));
	} finally {
	try {
	if (in != null) {
	in.close();
	}
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	}

	private boolean breaks(char code) {
	String breaks = tuple.breaks == null ? "" : tuple.breaks;
	return (breaks.toUpperCase().indexOf(code) != -1);
	}

	private static boolean isSpace(char c) {
	return (c == 0x09 \|\| c == 0x20 \|\| c == 0x3000);
	}

	private boolean setTupleField() {
	List<String> parts = splitBy(3, (char) 0x20);
	if (parts.size() < 3) {
	showError("Set expects 2 parameters");
	return false;
	}
	return setField(parts.get(1), parts.get(2));
	}

	private boolean setField(String name, String value) {
	try {
	tuple.setField(name, Utility.unescape(value));
	return true;
	} catch (Exception e) {
	showError("No such field: " + name + ", or bad value: " + value + ": " + e);
	return false;
	}
	}

	private boolean clearField(String name) {
	try {
	tuple.clearField(name);
	return true;
	} catch (Exception e) {
	showError("Field cannot be clared: " + name);
	return false;
	}
	}

	private void showError(String message) {
	TestFmwk.errln(String.format("line %d: %s\n%s\n%s", fileLineNumber, Utility.escape(message), fileTestName,fileLine));
	}

	private List<String> splitBy(char delimiter) {
	return splitBy(Integer.MAX_VALUE, delimiter);
	}

	private List<String> splitBy(int max, char delimiter) {
	ArrayList<String> result = new ArrayList<String>();
	int colIdx = 0;
	int colStart = 0;
	int len = fileLine.length();
	for (int idx = 0; colIdx < max - 1 && idx < len; ++idx) {
	char ch = fileLine.charAt(idx);
	if (ch == delimiter) {
	result.add(
	fileLine.substring(colStart, idx));
	++colIdx;
	colStart = idx + 1;
	}
	}
	result.add(fileLine.substring(colStart, len));
	return result;
	}

	private boolean readLine(BufferedReader in) throws IOException {
	String line = in.readLine();
	if (line == null) {
	fileLine = null;
	return false;
	}
	++fileLineNumber;
	// Strip trailing comments and spaces
	int idx = line.length();
	for (; idx > 0; idx--) {
	if (!isSpace(line.charAt(idx -1))) {
	break;
	}
	}
	fileLine = idx == 0 ? "" : line;
	return true;
	}

	private String isPass(DataDrivenNumberFormatTestData tuple) {
	StringBuilder result = new StringBuilder();
	if (tuple.format != null && tuple.output != null) {
	String errorMessage = codeUnderTest.format(tuple);
	if (errorMessage != null) {
	result.append(errorMessage);
	}
	} else if (tuple.toPattern != null \|\| tuple.toLocalizedPattern != null) {
	String errorMessage = codeUnderTest.toPattern(tuple);
	if (errorMessage != null) {
	result.append(errorMessage);
	}
	} else if (tuple.parse != null && tuple.output != null && tuple.outputCurrency != null) {
	String errorMessage = codeUnderTest.parseCurrency(tuple);
	if (errorMessage != null) {
	result.append(errorMessage);
	}
	} else if (tuple.parse != null && tuple.output != null) {
	String errorMessage = codeUnderTest.parse(tuple);
	if (errorMessage != null) {
	result.append(errorMessage);
	}
	} else if (tuple.plural != null) {
	String errorMessage = codeUnderTest.select(tuple);
	if (errorMessage != null) {
	result.append(errorMessage);
	}
	} else {
	result.append("Unrecognized test type.");
	}
	if (result.length() > 0) {
	result.append(": ");
	result.append(tuple);
	return result.toString();
	}
	return null;
	}
	}