java.util.IllegalFormatWidthException Java Examples

@Test
public void usesTheClosestFallback() throws Exception {
    final String expected = "Fallback from IllegalFormatException";
    MatcherAssert.assertThat(
        "Can't find the closest fallback",
        new FuncWithFallback<>(
            input -> {
                throw new IllegalFormatWidthException(1);
            },
            new IterableOf<>(
                new FallbackFrom<>(
                    IllegalArgumentException.class,
                    exp -> "Fallback from IllegalArgumentException"
                ),
                new FallbackFrom<>(
                    IllegalFormatException.class,
                    exp -> expected
                )
            )
        ),
        new FuncApplies<>(1, expected)
    );
}
 

@Test
public void usesTheClosestFallback() throws Exception {
    final String expected = "Fallback from IllegalFormatException";
    new Assertion<>(
        "Must find the closest fallback",
        new ScalarWithFallback<>(
            () -> {
                throw new IllegalFormatWidthException(1);
            },
            new IterableOf<>(
                new FallbackFrom<>(
                    new IterableOf<>(IllegalArgumentException.class),
                    exp -> "Fallback from IllegalArgumentException"
                ),
                new FallbackFrom<>(
                    new IterableOf<>(IllegalFormatException.class),
                    exp -> expected
                )
            )
        ),
        new ScalarHasValue<>(expected)
    ).affirm();
}
 

private void checkNumeric() {
	if (width != -1 && width < 0)
		throw new IllegalFormatWidthException(width);

	if (precision != -1 && precision < 0)
		throw new IllegalFormatPrecisionException(precision);

	// '-' and '0' require a width
	if (width == -1
			&& (f.contains(Flags.LEFT_JUSTIFY) || f
					.contains(Flags.ZERO_PAD)))
		throw new MissingFormatWidthException(toString());

	// bad combination
	if ((f.contains(Flags.PLUS) && f.contains(Flags.LEADING_SPACE))
			|| (f.contains(Flags.LEFT_JUSTIFY) && f
					.contains(Flags.ZERO_PAD)))
		throw new IllegalFormatFlagsException(f.toString());
}
 

private void checkText() {
	if (precision != -1)
		throw new IllegalFormatPrecisionException(precision);
	switch (c) {
	case Conversion.PERCENT_SIGN:
		if (f.valueOf() != Flags.LEFT_JUSTIFY.valueOf()
				&& f.valueOf() != Flags.NONE.valueOf())
			throw new IllegalFormatFlagsException(f.toString());
		// '-' requires a width
		if (width == -1 && f.contains(Flags.LEFT_JUSTIFY))
			throw new MissingFormatWidthException(toString());
		break;
	case Conversion.LINE_SEPARATOR:
		if (width != -1)
			throw new IllegalFormatWidthException(width);
		if (f.valueOf() != Flags.NONE.valueOf())
			throw new IllegalFormatFlagsException(f.toString());
		break;
	default:
           throw new UnknownFormatConversionException(String.valueOf(c));
	}
}
 

@Test(expected = Exception.class)
public void noFallbackIsProvided() throws Exception {
    new FuncWithFallback<>(
        input -> {
            throw new IllegalFormatWidthException(1);
        },
        new IterableOf<>()
    ).apply(1);
}
 

@Test(expected = Exception.class)
public void noFallbackIsProvided() throws Exception {
    new ScalarWithFallback<>(
        () -> {
            throw new IllegalFormatWidthException(1);
        },
        new IterableOf<>()
    ).value();
}
 

/**
 * java.util.IllegalFormatWidthException#IllegalFormatWidthException(int)
 */
public void test_illegalFormatWidthException() {
    int width = Integer.MAX_VALUE;
    IllegalFormatWidthException illegalFormatWidthException = new IllegalFormatWidthException(
            width);
    assertEquals(width, illegalFormatWidthException.getWidth());

}
 

/**
 * java.util.IllegalFormatWidthException#getWidth()
 */
public void test_getWidth() {
    int width = 12345;
    IllegalFormatWidthException illegalFormatWidthException = new IllegalFormatWidthException(
            width);
    assertEquals(width, illegalFormatWidthException.getWidth());

}
 

/**
 * java.util.IllegalFormatWidthException#getMessage()
 */
public void test_getMessage() {
    int width = 12345;
    IllegalFormatWidthException illegalFormatWidthException = new IllegalFormatWidthException(
            width);
    assertTrue(null != illegalFormatWidthException.getMessage());

}
 

public void assertDeserialized(Serializable initial,
        Serializable deserialized) {

    SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial,
            deserialized);

    IllegalFormatWidthException initEx = (IllegalFormatWidthException) initial;
    IllegalFormatWidthException desrEx = (IllegalFormatWidthException) deserialized;

    assertEquals("Width", initEx.getWidth(), desrEx.getWidth());
}
 

private int width(String s) throws FormatterNumberFormatException {
	width = -1;
	if (s != null) {
		try {
			width = Integer.parseInt(s);
			if (width < 0)
				throw new IllegalFormatWidthException(width);
		} catch (NumberFormatException x) {
               throw new FormatterNumberFormatException(s, "width");
		}
	}
	return width;
}
 

/**
 * serialization/deserialization.
 */
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new IllegalFormatWidthException(12345),
            exComparator);
}
 

/**
 * serialization/deserialization compatibility with RI.
 */
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this, new IllegalFormatWidthException(
            12345), exComparator);
}