1 /*
  2  * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 
 24 /**
 25  * @test
 26  * @bug 4018937
 27  * @library /java/text/testlib
 28  * @build FormatIteratorTest PParser IntlTest
 29  * @run main FormatIteratorTest
 30  * @summary Tests the formatToCharacterIterator method of SimpleDateFormat,
 31  *          MessageFormat and DecimalFormat.
 32  */
 33 
 34 import java.io.*;
 35 import java.lang.reflect.*;
 36 import java.text.*;
 37 import java.util.*;
 38 import java.util.concurrent.atomic.AtomicInteger;
 39 import java.util.concurrent.atomic.AtomicLong;
 40 import java.text.AttributedCharacterIterator.Attribute;
 41 
 42 /**
 43  * FormatTester creates Formats, and tests the resulting FieldPositions
 44  * and AttributedCharacterIterator based on a file. The file is a hierarchical
 45  * set of key/value pairs, where each value can also be an array or map. The
 46  * top map must contain a tests entry, which will be an array consisting
 47  * of pairs of maps. The first map specifies the Format that
 48  * should be created, and consists of:
 49  * <pre>
 50  *   class = className
 51  *   args = (arg1 arg2 ...)
 52  *   valueClass = className
 53  *   valueArgs = (arg1 arg2 ...)
 54  * </pre>
 55  * The second map dictates what to test, and should consist of the following:
 56  * <pre>
 57  *   length = lengthOfFormattedString
 58  *   text = Result of Formatting
 59  *   0...lengthOfFormattedString = (arg1 arg2 ...)
 60  *   limits = ( range1 range2 ...)
 61  *   fieldPositions = ( fp1 fp2 ...)
 62  * </pre>
 63  * <code>lengthOfFormattedString</code> indicate the total length of formatted
 64  * string. <code>text</code> indicates the resulting string.
 65  * <code>0...x</code> where x == <code>lengthOfFormattedString - 1</code> is
 66  * an array of the attributes that should exist at the particular
 67  * location. <code>limits</code> is an array of maps, where each map
 68  * can be used to test the bounds of a set of attributes. Each map will
 69  * consist of:
 70  * <pre>
 71  *   attributes = array of attributes
 72  *   begin = start location
 73  *   begin2 = second start location
 74  *   end = limit location
 75  *   end2 = second limit location
 76  * </pre>
 77  * These are tested by iterating from begin to end in the CharacterIterator
 78  * and doing the following at each index:
 79  * <pre>
 80  *   getRunStart() == begin
 81  *   getRunStart(attributes) == begin2
 82  *   getRunLimit() == end
 83  *   getRunLimit(attributes) == end2
 84  * </pre>
 85  * <code>fieldPositions</code> is used to test the results of invoking
 86  * <code>format</code> with a <code>FieldPosition</code>.
 87  * <code>fieldPositions</code> is an array of maps, where each map contains
 88  * the following:
 89  * <pre>
 90  *   field = Integer field reference (optional)
 91  *   fieldID = Object reference
 92  *   begin = begin index of FieldPosition after formatting
 93  *   end = end index of FieldPosition after formatting
 94  * </pre>
 95  * Any lines starting with {@code '#'} are comment lines and ignored.
 96  */
 97 public class FormatIteratorTest extends IntlTest {
 98     private Format format;
 99     private Object value;
100     private String text;
101 
102     public static final Object ARG0_FIELD_ID = MessageFormat.
103                                                      Field.ARGUMENT;
104     public static final Object ARG1_FIELD_ID = MessageFormat.
105                                                      Field.ARGUMENT;
106     public static final Object ARG2_FIELD_ID = MessageFormat.
107                                                      Field.ARGUMENT;
108     public static final Object ARG3_FIELD_ID = MessageFormat.
109                                                      Field.ARGUMENT;
110 
111     public static void main(String[] args) throws Exception {
112         Locale reservedLocale = Locale.getDefault();
113         TimeZone reservedTimeZone = TimeZone.getDefault();
114         try {
115             // The current tests are only appropriate for US. If tests are
116             // added for other locales are added, then a property should be
117             // added to each file (test) to be able to specify the locale.
118             Locale.setDefault(Locale.US);
119             TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
120             new FormatIteratorTest().run(args);
121         } finally {
122             // restore the reserved locale and time zone
123             Locale.setDefault(reservedLocale);
124             TimeZone.setDefault(reservedTimeZone);
125         }
126     }
127 
128     public FormatIteratorTest() {
129     }
130 
131     public void testDecimalFormat() {
132         _test(new File(System.getProperty("test.src", "."),
133                        "decimalFormat.props"));
134     }
135 
136     public void testMessageFormat() {
137         _test(new File(System.getProperty("test.src", "."),
138                        "messageFormat.props"));
139     }
140 
141     public void testDateFormat() {
142         _test(new File(System.getProperty("test.src", "."),
143                        "dateFormat.props"));
144     }
145 
146     @SuppressWarnings("unchecked")
147     private void _test(File file) {
148         try {
149             logln("testing: " + file);
150             PParser parser = new PParser();
151             Map<String,Object> contents = parser.parse(new BufferedReader(
152                 new FileReader(file)));
153             List<Object> test = (List)contents.get("tests");
154 
155             for (int counter = 0; counter < test.size(); counter++) {
156                 logln("creating: " + (counter / 2));
157 
158                 AttributedCharacterIterator iterator =
159                     create((Map)test.get(counter));
160 
161                 logln("verifying: " + (counter / 2));
162                 verify(iterator, (Map)test.get(++counter));
163             }
164         } catch (IOException ioe) {
165             errln("Error reading: " + ioe);
166         }
167     }
168 
169     @SuppressWarnings("unchecked")
170     public void verify(AttributedCharacterIterator iterator,Map<String,Object> table) {
171         int length = Integer.parseInt((String)table.get("length"));
172 
173         // Verify the text
174         if (!getText(iterator).equals(
175                 escapeIfNecessary((String)table.get("text")))) {
176             String text = getText(iterator);
177 
178             errln("text doesn't match, got: " + getText(iterator));
179         }
180         if (iterator.getBeginIndex() != 0) {
181             errln("Bogus start: " + iterator.getBeginIndex());
182         }
183         if (iterator.getEndIndex() != length) {
184             errln("Bogus end: " + iterator.getEndIndex());
185         }
186         for (int counter = 0; counter < length; counter++) {
187             iterator.setIndex(counter);
188             if (!verifyAttributes(iterator.getAttributes().keySet(),
189                     makeAttributes((List)table.get(Integer.
190                                                       toString(counter))))) {
191                 errln("Attributes don't match at " + counter + " expecting " +
192                       makeAttributes((List)table.get(Integer.toString
193                                                        (counter))) + " got " +
194                       iterator.getAttributes().keySet());
195             }
196         }
197         for (int counter = length - 1; counter >= 0; counter--) {
198             iterator.setIndex(counter);
199             if (!verifyAttributes(iterator.getAttributes().keySet(),
200                     makeAttributes((List)table.get(Integer.
201                                                       toString(counter))))) {
202                 errln("Attributes don't match at " + counter + " expecting " +
203                       makeAttributes((List)table.get(Integer.toString
204                                                        (counter))) + " got " +
205                       iterator.getAttributes().keySet());
206             }
207         }
208         verifyLimits(iterator, table);
209 
210         text = escapeIfNecessary((String)table.get("text"));
211         List<Object> fps = (List)table.get("fieldPositions");
212 
213         if (fps != null) {
214             for (int counter = 0; counter < fps.size(); counter++) {
215                 verifyFieldPosition(counter,(Map)fps.get(counter));
216             }
217         }
218     }
219 
220     @SuppressWarnings("unchecked")
221     private void verifyLimits(AttributedCharacterIterator iterator,
222                               Map<String,Object> table) {
223         List<Object> limits = (List)table.get("limits");
224 
225         if (limits != null) {
226             for (int counter = 0; counter < limits.size(); counter++) {
227                 verifyLimit(iterator, (Map)limits.get(counter));
228             }
229         }
230     }
231 
232     private void verifyLimit(AttributedCharacterIterator iterator,
233                              Map<String,Object> table) {
234         int begin = Integer.parseInt((String)table.get("begin"));
235         int end = Integer.parseInt((String)table.get("end"));
236         @SuppressWarnings("unchecked")
237         Set<Attribute> attrs = makeAttributes((List)table.get("attributes"));
238         String begin2S = (String)table.get("begin2");
239         int begin2 = (begin2S != null) ? Integer.parseInt(begin2S) : begin;
240         String end2S = (String)table.get("end2");
241         int end2 = (end2S != null) ? Integer.parseInt(end2S) : end;
242 
243         for (int counter = begin; counter < end; counter++) {
244             iterator.setIndex(counter);
245             if (iterator.getRunStart() != begin) {
246                 errln("Begin doesn't match want " + begin + " got " +
247                       iterator.getRunStart() + " at " + counter + " attrs " +
248                       attrs);
249             }
250             if (iterator.getRunStart(attrs) != begin2) {
251                 errln("Begin2 doesn't match want " + begin2 + " got " +
252                       iterator.getRunStart(attrs) + " at " + counter +
253                       " attrs " + attrs);
254             }
255             if (iterator.getRunLimit() != end) {
256                 errln("End doesn't match want " + end + " got " +
257                       iterator.getRunLimit() + " at " + counter + " attrs " +
258                       attrs);
259             }
260             if (iterator.getRunLimit(attrs) != end2) {
261                 errln("End2 doesn't match want " + end2 + " got " +
262                       iterator.getRunLimit(attrs) + " at " + counter +
263                       " attrs " + attrs);
264             }
265         }
266     }
267 
268     private boolean verifyAttributes(Set<Attribute> a, Set<Attribute> b) {
269         boolean aEmpty = a.isEmpty();
270         boolean bEmpty = b.isEmpty();
271 
272         if (aEmpty && bEmpty) {
273             return true;
274         }
275         else if (aEmpty || bEmpty) {
276             return false;
277         }
278         return a.equals(b);
279     }
280 
281     private String getText(AttributedCharacterIterator iterator) {
282         StringBuffer buffer = new StringBuffer();
283 
284         for (int counter = 0; counter < iterator.getEndIndex(); counter++) {
285             buffer.append(iterator.setIndex(counter));
286         }
287         return buffer.toString();
288     }
289 
290     private void verifyFieldPosition(int index, Map<String,Object> table) {
291         Object o = table.get("field");
292         int begin = Integer.parseInt((String)table.get("begin"));
293         int end = Integer.parseInt((String)table.get("end"));
294 
295         if (o != null) {
296             FieldPosition fp = new FieldPosition(((Integer)
297                                           lookupField((String)o)));
298 
299             verifyFieldPosition(fp, begin, end, index);
300         }
301         o = table.get("fieldID");
302         if (o != null) {
303             FieldPosition fp = new FieldPosition((Format.Field)
304                                                  lookupField((String)o));
305             verifyFieldPosition(fp, begin, end, index);
306         }
307     }
308 
309     private void verifyFieldPosition(FieldPosition fp, int begin, int end,
310                                      int index) {
311         StringBuffer buffer = new StringBuffer();
312 
313         format.format(value, buffer, fp);
314         if (fp.getBeginIndex() != begin) {
315             errln("bogus begin want " + begin + " got " + fp.getBeginIndex() +
316                   " for " + fp + " at " + index);
317         }
318         if (fp.getEndIndex() != end) {
319             errln("bogus end want " + end + " got " + fp.getEndIndex() +
320                   " for " + fp + " at " + index);
321         }
322         if (!buffer.toString().equals(text)) {
323             errln("Text does not match, want !" + buffer.toString() +
324                   "! got !" + text + "!");
325         }
326     }
327 
328     public AttributedCharacterIterator create(Map<String,Object> table) {
329         format = (Format)createInstance((String)table.get("class"),
330                                         ((List)table.get("args")).toArray());
331         value = createInstance((String)table.get("valueClass"),
332                                ((List)table.get("valueArgs")).toArray());
333 
334         logln("Created format: " + format + " value " + value);
335         AttributedCharacterIterator aci = format.
336                            formatToCharacterIterator(value);
337 
338         logln("Obtained Iterator: " + aci);
339         return aci;
340     }
341 
342     public Format.Field makeAttribute(String name) {
343         return (Format.Field)lookupField(name);
344     }
345 
346     private Object createInstance(String className, Object[] args) {
347         if (className.equals("java.lang.reflect.Array")) {
348             for (int counter = 0; counter < args.length; counter++) {
349                 if (args[counter] instanceof List) {
350                     @SuppressWarnings("unchecked")
351                     List<Object> v = (List<Object>)args[counter];
352 
353                     args[counter] = createInstance((String)v.get(0),
354                                                ((List)v.get(1)).toArray());
355                 }
356             }
357             return args;
358         }
359         for (int counter = 0; counter < args.length; counter++) {
360             args[counter] = escapeIfNecessary((String)args[counter]);
361         }
362         try {
363             if (className.equals("java.util.concurrent.atomic.AtomicInteger")) {
364                 return new AtomicInteger(Integer.valueOf((String)args[0]));
365             } else if (className.equals("java.util.concurrent.atomic.AtomicLong")) {
366                 return new AtomicLong(Long.valueOf((String)args[0]));
367             } else {
368                 Class<?> klass = lookupClass(className);
369                 Constructor<?> cons = klass.getConstructor(
370                     new Class<?>[] { String.class });
371                 Object value = cons.newInstance(args);
372 
373                 return value;
374             }
375         } catch (Throwable th) {
376             errln("Error creating instance " + th);
377             return null;
378         }
379     }
380 
381     private  Class<?> lookupClass(String name) throws ClassNotFoundException {
382         try {
383             Class<?> klass = Class.forName(name);
384 
385             return klass;
386         } catch (ClassNotFoundException e1) {}
387 
388         try {
389             Class<?> klass = Class.forName("java.lang." + name);
390 
391             return klass;
392         } catch (ClassNotFoundException e1) {}
393 
394         Class<?> klass = Class.forName("java.text." + name);
395 
396         return klass;
397     }
398 
399     private Object lookupField(String name) {
400         Throwable error = null;
401 
402         try {
403             int dotIndex = name.indexOf('.');
404             Class<?> klass = lookupClass(name.substring(0, dotIndex));
405             String fieldName = name.substring(dotIndex + 1);
406             Field[] fields = klass.getFields();
407 
408             for (int counter = fields.length - 1; counter >= 0; counter--) {
409                 if (fields[counter].getName().equals(fieldName)) {
410                     return fields[counter].get(null);
411                 }
412             }
413         } catch (Throwable th) {
414             error = th;
415         }
416         errln("Could not lookup field " + name + " " + error);
417         return null;
418     }
419 
420     protected String escapeIfNecessary(String string) {
421         if (string != null) {
422             int index;
423 
424             if ((index = string.indexOf("\\u")) != -1) {
425                 StringBuffer sb = new StringBuffer(string.substring(0, index));
426 
427                 sb.append((char)Integer.parseInt(
428                     string.substring(index + 2, index + 6), 16));
429                 sb.append(string.substring(index + 6));
430                 string = sb.toString();
431             }
432         }
433         return string;
434     }
435 
436     public Set<Attribute> makeAttributes(List<Object> names) {
437         Set<Attribute> set = HashSet.newHashSet(names.size());
438 
439         for (int counter = 0; counter < names.size(); counter++) {
440             set.add(makeAttribute((String)names.get(counter)));
441         }
442         return set;
443     }
444 }