コード例 #1
0
  /**
   * @tests java.text.MessageFormat#setFormat(int, Format) Test of method
   *     java.text.MessageFormat#setFormat(int, Format). Case 1: Compare getFormats() results after
   *     calls to setFormat(). Case 2: Try to call setFormat() using incorrect index.
   */
  @TestTargetNew(
      level = TestLevel.COMPLETE,
      notes = "",
      method = "setFormat",
      args = {int.class, java.text.Format.class})
  public void test_setFormatILjava_text_Format() {
    try {
      // case 1: Compare getFormats() results after calls to setFormat()
      MessageFormat f1 = (MessageFormat) format1.clone();
      f1.setFormat(0, DateFormat.getTimeInstance());
      f1.setFormat(1, DateFormat.getTimeInstance());
      f1.setFormat(2, NumberFormat.getInstance());
      f1.setFormat(3, new ChoiceFormat("0#off|1#on"));
      f1.setFormat(4, new ChoiceFormat("1#few|2#ok|3#a lot"));
      f1.setFormat(5, DateFormat.getTimeInstance());

      Format[] formats = f1.getFormats();
      formats = f1.getFormats();

      Format[] correctFormats =
          new Format[] {
            DateFormat.getTimeInstance(),
            DateFormat.getTimeInstance(),
            NumberFormat.getInstance(),
            new ChoiceFormat("0#off|1#on"),
            new ChoiceFormat("1#few|2#ok|3#a lot"),
            DateFormat.getTimeInstance()
          };

      assertEquals(
          "Test1A:Returned wrong number of formats:", correctFormats.length, formats.length);
      for (int i = 0; i < correctFormats.length; i++) {
        assertEquals(
            "Test1B:wrong format for pattern index " + i + ":", correctFormats[i], formats[i]);
      }

      // case 2: Try to setFormat using incorrect index
      try {
        f1.setFormat(-1, DateFormat.getDateInstance());
        fail("Expected ArrayIndexOutOfBoundsException was not thrown");
        f1.setFormat(f1.getFormats().length, DateFormat.getDateInstance());
        fail("Expected ArrayIndexOutOfBoundsException was not thrown");
      } catch (ArrayIndexOutOfBoundsException e) {
        // expected
      }
    } catch (Exception e) {
      fail("Unexpected exception " + e.toString());
    }
  }
コード例 #2
0
  /** @tests java.text.MessageFormat#getFormats() */
  @TestTargetNew(
      level = TestLevel.COMPLETE,
      notes = "",
      method = "getFormats",
      args = {})
  public void test_getFormats() {
    // Test for method java.text.Format []
    // java.text.MessageFormat.getFormats()

    // test with repeating formats and max argument index < max offset
    Format[] formats = format1.getFormats();
    Format[] correctFormats =
        new Format[] {
          NumberFormat.getCurrencyInstance(),
          DateFormat.getTimeInstance(),
          NumberFormat.getPercentInstance(),
          null,
          new ChoiceFormat("0#off|1#on"),
          DateFormat.getDateInstance(),
        };

    assertEquals("Test1:Returned wrong number of formats:", correctFormats.length, formats.length);
    for (int i = 0; i < correctFormats.length; i++) {
      assertEquals(
          "Test1:wrong format for pattern index " + i + ":", correctFormats[i], formats[i]);
    }

    // test with max argument index > max offset
    formats = format2.getFormats();
    correctFormats =
        new Format[] {
          NumberFormat.getCurrencyInstance(),
          DateFormat.getTimeInstance(),
          NumberFormat.getPercentInstance(),
          null,
          new ChoiceFormat("0#off|1#on"),
          DateFormat.getDateInstance()
        };

    assertEquals("Test2:Returned wrong number of formats:", correctFormats.length, formats.length);
    for (int i = 0; i < correctFormats.length; i++) {
      assertEquals(
          "Test2:wrong format for pattern index " + i + ":", correctFormats[i], formats[i]);
    }

    // test with argument number being zero
    formats = format3.getFormats();
    assertEquals("Test3: Returned wrong number of formats:", 0, formats.length);
  }
コード例 #3
0
  /** @tests java.text.MessageFormat#MessageFormat(java.lang.String, java.util.Locale) */
  @TestTargetNew(
      level = TestLevel.PARTIAL_COMPLETE,
      notes = "IllegalArgumentException is not verified.",
      method = "MessageFormat",
      args = {java.lang.String.class, java.util.Locale.class})
  public void test_ConstructorLjava_lang_StringLjava_util_Locale() {
    // Test for method java.text.MessageFormat(java.lang.String,
    // java.util.Locale)
    Locale mk = new Locale("mk", "MK");
    MessageFormat format =
        new MessageFormat(
            "Date: {0,date} Currency: {1, number, currency} Integer: {2, number, integer}", mk);

    assertTrue("Wrong locale1", format.getLocale().equals(mk));
    assertTrue(
        "Wrong locale2",
        format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.DEFAULT, mk)));
    assertTrue(
        "Wrong locale3", format.getFormats()[1].equals(NumberFormat.getCurrencyInstance(mk)));
    assertTrue("Wrong locale4", format.getFormats()[2].equals(NumberFormat.getIntegerInstance(mk)));
  }
コード例 #4
0
 /** @tests java.text.MessageFormat#setLocale(java.util.Locale) */
 @TestTargetNew(
     level = TestLevel.COMPLETE,
     notes = "",
     method = "setLocale",
     args = {java.util.Locale.class})
 public void test_setLocaleLjava_util_Locale() {
   // Test for method void
   // java.text.MessageFormat.setLocale(java.util.Locale)
   MessageFormat format = new MessageFormat("date {0,date}");
   format.setLocale(Locale.CHINA);
   assertEquals("Wrong locale1", Locale.CHINA, format.getLocale());
   format.applyPattern("{1,date}");
   assertEquals(
       "Wrong locale3",
       DateFormat.getDateInstance(DateFormat.DEFAULT, Locale.CHINA),
       format.getFormats()[0]);
 }
コード例 #5
0
 /** @tests java.text.MessageFormat#clone() */
 @TestTargetNew(
     level = TestLevel.COMPLETE,
     notes = "",
     method = "clone",
     args = {})
 public void test_clone() {
   // Test for method java.lang.Object java.text.MessageFormat.clone()
   MessageFormat format = new MessageFormat("'{'choice'}'{0}");
   MessageFormat clone = (MessageFormat) format.clone();
   assertTrue("Clone not equal", format.equals(clone));
   assertEquals("Wrong answer", "{choice}{0}", format.format(new Object[] {}));
   clone.setFormat(0, DateFormat.getInstance());
   assertTrue("Clone shares format data", !format.equals(clone));
   format = (MessageFormat) clone.clone();
   Format[] formats = clone.getFormats();
   ((SimpleDateFormat) formats[0]).applyPattern("adk123");
   assertTrue("Clone shares format data", !format.equals(clone));
 }
コード例 #6
0
  /**
   * @tests java.text.MessageFormat#setFormats(Format[]) Test of method
   *     java.text.MessageFormat#setFormats(Format[]). Case 1: Test with repeating formats and max
   *     argument index < max offset compare getFormats() results after calls to
   *     setFormats(Format[]) Case 2: Try to pass null argument to setFormats().
   */
  @TestTargetNew(
      level = TestLevel.COMPLETE,
      notes = "",
      method = "setFormats",
      args = {java.text.Format[].class})
  public void test_setFormats$Ljava_text_Format() {
    try {
      MessageFormat f1 = (MessageFormat) format1.clone();

      // case 1: Test with repeating formats and max argument index < max
      // offset
      // compare getFormats() results after calls to setFormats(Format[])
      Format[] correctFormats =
          new Format[] {
            DateFormat.getTimeInstance(),
            new ChoiceFormat("0#off|1#on"),
            DateFormat.getTimeInstance(),
            NumberFormat.getCurrencyInstance(),
            new ChoiceFormat("1#few|2#ok|3#a lot")
          };

      f1.setFormats(correctFormats);
      Format[] formats = f1.getFormats();

      assertTrue(
          "Test1A:Returned wrong number of formats:", correctFormats.length <= formats.length);
      for (int i = 0; i < correctFormats.length; i++) {
        assertEquals(
            "Test1B:wrong format for argument index " + i + ":", correctFormats[i], formats[i]);
      }

      // case 2: Try to pass null argument to setFormats().
      try {
        f1.setFormats(null);
        fail("Expected exception NullPointerException was not thrown");
      } catch (NullPointerException e) {
        // expected
      }
    } catch (Exception e) {
      fail("Unexpected exception " + e.toString());
    }
  }
コード例 #7
0
  /**
   * Do something TODO.
   *
   * <p>Details of the function.
   */
  private void applyFormats(MessageFormat subFormat) {

    for (Format format : subFormat.getFormats()) {
      if (!(format instanceof ChoiceFormat)) {
        continue;
      }

      ChoiceFormat choice = (ChoiceFormat) format;
      String[] choiceFormats = (String[]) choice.getFormats();
      for (int i = 0; i < choiceFormats.length; i++) {
        String innerFormat = choiceFormats[i];
        if (innerFormat.contains("{")) {
          BeanMessageFormat recursive = new BeanMessageFormat(innerFormat, root);
          choiceFormats[i] = recursive.inner.toPattern();
        }
      }

      choice.setChoices(choice.getLimits(), choiceFormats);
    }
  }
コード例 #8
0
  /** @tests java.text.MessageFormat#MessageFormat(java.lang.String) */
  @TestTargetNew(
      level = TestLevel.COMPLETE,
      method = "MessageFormat",
      args = {java.lang.String.class})
  public void test_ConstructorLjava_lang_String() {
    // Test for method java.text.MessageFormat(java.lang.String)
    MessageFormat format =
        new MessageFormat(
            "abc {4,time} def {3,date} ghi {2,number} jkl {1,choice,0#low|1#high} mnop {0}");
    assertTrue("Not a MessageFormat", format.getClass() == MessageFormat.class);
    Format[] formats = format.getFormats();
    assertNotNull("null formats", formats);
    assertTrue("Wrong format count: " + formats.length, formats.length >= 5);
    assertTrue("Wrong time format", formats[0].equals(DateFormat.getTimeInstance()));
    assertTrue("Wrong date format", formats[1].equals(DateFormat.getDateInstance()));
    assertTrue("Wrong number format", formats[2].equals(NumberFormat.getInstance()));
    assertTrue("Wrong choice format", formats[3].equals(new ChoiceFormat("0.0#low|1.0#high")));
    assertNull("Wrong string format", formats[4]);

    Date date = new Date();
    FieldPosition pos = new FieldPosition(-1);
    StringBuffer buffer = new StringBuffer();
    format.format(new Object[] {"123", new Double(1.6), new Double(7.2), date, date}, buffer, pos);
    String result = buffer.toString();
    buffer.setLength(0);
    buffer.append("abc ");
    buffer.append(DateFormat.getTimeInstance().format(date));
    buffer.append(" def ");
    buffer.append(DateFormat.getDateInstance().format(date));
    buffer.append(" ghi ");
    buffer.append(NumberFormat.getInstance().format(new Double(7.2)));
    buffer.append(" jkl high mnop 123");
    assertTrue("Wrong answer:\n" + result + "\n" + buffer, result.equals(buffer.toString()));

    assertEquals(
        "Simple string", "Test message", new MessageFormat("Test message").format(new Object[0]));

    result = new MessageFormat("Don't").format(new Object[0]);
    assertTrue("Should not throw IllegalArgumentException: " + result, "Dont".equals(result));

    try {
      new MessageFormat("Invalid {1,foobar} format descriptor!");
      fail("Expected test_ConstructorLjava_lang_String to throw IAE.");
    } catch (IllegalArgumentException ex) {
      // expected
    }

    try {
      new MessageFormat("Invalid {1,date,invalid-spec} format descriptor!");
    } catch (IllegalArgumentException ex) {
      // expected
    }

    checkSerialization(new MessageFormat(""));
    checkSerialization(new MessageFormat("noargs"));
    checkSerialization(new MessageFormat("{0}"));
    checkSerialization(new MessageFormat("a{0}"));
    checkSerialization(new MessageFormat("{0}b"));
    checkSerialization(new MessageFormat("a{0}b"));

    // Regression for HARMONY-65
    try {
      new MessageFormat("{0,number,integer");
      fail("Assert 0: Failed to detect unmatched brackets.");
    } catch (IllegalArgumentException e) {
      // expected
    }
  }
コード例 #9
0
  /** @tests java.text.MessageFormat#setFormatsByArgumentIndex(java.text.Format[]) */
  @TestTargetNew(
      level = TestLevel.COMPLETE,
      notes = "",
      method = "setFormatsByArgumentIndex",
      args = {java.text.Format[].class})
  public void test_setFormatsByArgumentIndex$Ljava_text_Format() {
    // test for method setFormatByArgumentIndex(Format[])
    MessageFormat f1 = (MessageFormat) format1.clone();

    // test with repeating formats and max argument index < max offset
    // compare getFormatsByArgumentIndex() results after calls to
    // setFormatsByArgumentIndex(Format[])
    Format[] correctFormats =
        new Format[] {
          DateFormat.getTimeInstance(),
          new ChoiceFormat("0#off|1#on"),
          DateFormat.getTimeInstance(),
          NumberFormat.getCurrencyInstance(),
          new ChoiceFormat("1#few|2#ok|3#a lot")
        };

    f1.setFormatsByArgumentIndex(correctFormats);
    Format[] formats = f1.getFormatsByArgumentIndex();

    assertEquals("Test1A:Returned wrong number of formats:", correctFormats.length, formats.length);
    for (int i = 0; i < correctFormats.length; i++) {
      assertEquals(
          "Test1B:wrong format for argument index " + i + ":", correctFormats[i], formats[i]);
    }

    // compare getFormats() results after calls to
    // setFormatByArgumentIndex()
    formats = f1.getFormats();
    correctFormats =
        new Format[] {
          NumberFormat.getCurrencyInstance(),
          DateFormat.getTimeInstance(),
          DateFormat.getTimeInstance(),
          new ChoiceFormat("1#few|2#ok|3#a lot"),
          new ChoiceFormat("0#off|1#on"),
          DateFormat.getTimeInstance(),
        };

    assertEquals("Test1C:Returned wrong number of formats:", correctFormats.length, formats.length);
    for (int i = 0; i < correctFormats.length; i++) {
      assertEquals(
          "Test1D:wrong format for pattern index " + i + ":", correctFormats[i], formats[i]);
    }

    // test setting argumentIndexes that are not used
    MessageFormat f2 = (MessageFormat) format2.clone();
    Format[] inputFormats =
        new Format[] {
          DateFormat.getDateInstance(),
          new ChoiceFormat("0#off|1#on"),
          NumberFormat.getPercentInstance(),
          NumberFormat.getCurrencyInstance(),
          DateFormat.getTimeInstance(),
          null,
          null,
          null,
          DateFormat.getTimeInstance()
        };
    f2.setFormatsByArgumentIndex(inputFormats);

    formats = f2.getFormatsByArgumentIndex();
    correctFormats = format2.getFormatsByArgumentIndex();

    assertEquals("Test2A:Returned wrong number of formats:", correctFormats.length, formats.length);
    for (int i = 0; i < correctFormats.length; i++) {
      assertEquals(
          "Test2B:wrong format for argument index " + i + ":", correctFormats[i], formats[i]);
    }

    formats = f2.getFormats();
    correctFormats =
        new Format[] {
          NumberFormat.getCurrencyInstance(),
          DateFormat.getTimeInstance(),
          DateFormat.getDateInstance(),
          null,
          new ChoiceFormat("0#off|1#on"),
          DateFormat.getDateInstance()
        };

    assertEquals("Test2C:Returned wrong number of formats:", correctFormats.length, formats.length);
    for (int i = 0; i < correctFormats.length; i++) {
      assertEquals(
          "Test2D:wrong format for pattern index " + i + ":", correctFormats[i], formats[i]);
    }

    // test exceeding the argumentIndex number
    MessageFormat f3 = (MessageFormat) format3.clone();
    f3.setFormatsByArgumentIndex(inputFormats);

    formats = f3.getFormatsByArgumentIndex();
    assertEquals("Test3A:Returned wrong number of formats:", 0, formats.length);

    formats = f3.getFormats();
    assertEquals("Test3B:Returned wrong number of formats:", 0, formats.length);
  }
コード例 #10
0
  /** @tests java.text.MessageFormat#applyPattern(java.lang.String) */
  @TestTargetNew(
      level = TestLevel.COMPLETE,
      method = "applyPattern",
      args = {java.lang.String.class})
  public void test_applyPatternLjava_lang_String() {
    // Test for method void
    // java.text.MessageFormat.applyPattern(java.lang.String)
    MessageFormat format = new MessageFormat("test");
    format.applyPattern("xx {0}");
    assertEquals("Invalid number", "xx 46", format.format(new Object[] {new Integer(46)}));
    Date date = new Date();
    String result = format.format(new Object[] {date});
    String expected = "xx " + DateFormat.getInstance().format(date);
    assertTrue("Invalid date:\n" + result + "\n" + expected, result.equals(expected));
    format = new MessageFormat("{0,date}{1,time}{2,number,integer}");
    format.applyPattern("nothing");
    assertEquals("Found formats", "nothing", format.toPattern());

    format.applyPattern("{0}");
    assertNull("Wrong format", format.getFormats()[0]);
    assertEquals("Wrong pattern", "{0}", format.toPattern());

    format.applyPattern("{0, \t\u001ftime }");
    assertTrue("Wrong time format", format.getFormats()[0].equals(DateFormat.getTimeInstance()));
    assertEquals("Wrong time pattern", "{0,time}", format.toPattern());
    format.applyPattern("{0,Time, Short\n}");
    assertTrue(
        "Wrong short time format",
        format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.SHORT)));
    assertEquals("Wrong short time pattern", "{0,time,short}", format.toPattern());
    format.applyPattern("{0,TIME,\nmedium  }");
    assertTrue(
        "Wrong medium time format",
        format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.MEDIUM)));
    assertEquals("Wrong medium time pattern", "{0,time}", format.toPattern());
    format.applyPattern("{0,time,LONG}");
    assertTrue(
        "Wrong long time format",
        format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.LONG)));
    assertEquals("Wrong long time pattern", "{0,time,long}", format.toPattern());
    format.setLocale(Locale.FRENCH); // use French since English has the
    // same LONG and FULL time patterns
    format.applyPattern("{0,time, Full}");
    assertTrue(
        "Wrong full time format",
        format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.FULL, Locale.FRENCH)));
    // Outsourced to _AndroidFailure:
    //
    //        assertEquals("Wrong full time pattern", "{0,time,full}", format
    //                .toPattern());
    format.setLocale(Locale.getDefault());

    format.applyPattern("{0, date}");
    assertTrue("Wrong date format", format.getFormats()[0].equals(DateFormat.getDateInstance()));
    assertEquals("Wrong date pattern", "{0,date}", format.toPattern());
    format.applyPattern("{0, date, short}");
    assertTrue(
        "Wrong short date format",
        format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.SHORT)));
    assertEquals("Wrong short date pattern", "{0,date,short}", format.toPattern());
    format.applyPattern("{0, date, medium}");
    assertTrue(
        "Wrong medium date format",
        format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.MEDIUM)));
    assertEquals("Wrong medium date pattern", "{0,date}", format.toPattern());
    format.applyPattern("{0, date, long}");
    assertTrue(
        "Wrong long date format",
        format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.LONG)));
    assertEquals("Wrong long date pattern", "{0,date,long}", format.toPattern());
    format.applyPattern("{0, date, full}");
    assertTrue(
        "Wrong full date format",
        format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.FULL)));
    assertEquals("Wrong full date pattern", "{0,date,full}", format.toPattern());

    format.applyPattern("{0, date, MMM d {hh:mm:ss}}");
    assertEquals(
        "Wrong time/date format",
        " MMM d {hh:mm:ss}",
        ((SimpleDateFormat) (format.getFormats()[0])).toPattern());
    assertEquals("Wrong time/date pattern", "{0,date, MMM d {hh:mm:ss}}", format.toPattern());

    format.applyPattern("{0, number}");
    assertTrue(
        "Wrong number format", format.getFormats()[0].equals(NumberFormat.getNumberInstance()));
    assertEquals("Wrong number pattern", "{0,number}", format.toPattern());
    format.applyPattern("{0, number, currency}");
    assertTrue(
        "Wrong currency number format",
        format.getFormats()[0].equals(NumberFormat.getCurrencyInstance()));
    assertEquals("Wrong currency number pattern", "{0,number,currency}", format.toPattern());
    format.applyPattern("{0, number, percent}");
    assertTrue(
        "Wrong percent number format",
        format.getFormats()[0].equals(NumberFormat.getPercentInstance()));
    assertEquals("Wrong percent number pattern", "{0,number,percent}", format.toPattern());
    format.applyPattern("{0, number, integer}");
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMaximumFractionDigits(0);
    nf.setParseIntegerOnly(true);
    assertTrue("Wrong integer number format", format.getFormats()[0].equals(nf));
    assertEquals("Wrong integer number pattern", "{0,number,integer}", format.toPattern());

    format.applyPattern("{0, number, {'#'}##0.0E0}");

    /*
     * TODO validate these assertions String actual =
     * ((DecimalFormat)(format.getFormats()[0])).toPattern();
     * assertEquals("Wrong pattern number format", "' {#}'##0.0E0", actual);
     * assertEquals("Wrong pattern number pattern", "{0,number,'
     * {#}'##0.0E0}", format.toPattern());
     *
     */

    format.applyPattern("{0, choice,0#no|1#one|2#{1,number}}");
    assertEquals(
        "Wrong choice format",
        "0.0#no|1.0#one|2.0#{1,number}",
        ((ChoiceFormat) format.getFormats()[0]).toPattern());
    assertEquals(
        "Wrong choice pattern", "{0,choice,0.0#no|1.0#one|2.0#{1,number}}", format.toPattern());
    assertEquals(
        "Wrong formatted choice",
        "3.6",
        format.format(new Object[] {new Integer(2), new Float(3.6)}));

    try {
      format.applyPattern("WRONG MESSAGE FORMAT {0,number,{}");
      fail("Expected IllegalArgumentException for invalid pattern");
    } catch (IllegalArgumentException e) {
    }

    // Regression for HARMONY-65
    MessageFormat mf = new MessageFormat("{0,number,integer}");
    String badpattern = "{0,number,#";
    try {
      mf.applyPattern(badpattern);
      fail("Assert 0: Failed to detect unmatched brackets.");
    } catch (IllegalArgumentException e) {
      // expected
    }
  }