Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void shouldConvertToZeroWhenNull() { assertThat(converter.convert(null, byte.class), is(equalTo((byte) 0))); }
@Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenEmpty() { assertThat(converter.convert("", byte.class), is(equalTo((byte) 0))); }
@Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); }
PrimitiveByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return (byte) 0; } try { return Byte.parseByte(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldFindNonAnnotatedNonStaticPublicMethodWithComponentNameInVariableCamelCaseConventionAsURI() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/add"); assertThat(route, canHandle(ClientsController.class, "add")); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldBeAbleToConvertNumbers(){ assertThat(converter.convert("2", long.class), is(equalTo(2L))); }
@Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", long.class); }
@Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutNull() { assertThat(converter.convert(null, long.class), is(nullValue())); }
@Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutEmpty() { assertThat(converter.convert("", long.class), is(nullValue())); }
@Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); }
LongConverter implements Converter<Long> { @Override public Long convert(String value, Class<? extends Long> type) { if (isNullOrEmpty(value)) { return null; } try { return Long.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Long convert(String value, Class<? extends Long> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithPTBR() { assertThat(converter.convert("10,00", float.class), is(equalTo(Float.parseFloat("10.00")))); assertThat(converter.convert("10,01", float.class), is(equalTo(Float.parseFloat("10.01")))); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithENUS() { converter = new PrimitiveFloatConverter(new Locale("en", "US")); assertThat(converter.convert("10.00", float.class), is(equalTo(Float.parseFloat("10.00")))); assertThat(converter.convert("10.01", float.class), is(equalTo(Float.parseFloat("10.01")))); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", float.class), is(equalTo(0f))); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, float.class), is(equalTo(0f))); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("vr3.9 is not a valid number.")); converter.convert("vr3.9", float.class); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
PrimitiveFloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return 0f; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected PrimitiveFloatConverter(); @Inject PrimitiveFloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertCharacters() { assertThat(converter.convert("Z", Character.class), is(equalTo('Z'))); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldFindSeveralPathsForMethodWithManyValue() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/path1"); assertThat(route, canHandle(ClientsController.class, "manyPaths")); Route route2 = getRouteMatching(routes, "/path2"); assertThat(route2, canHandle(ClientsController.class, "manyPaths")); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldComplainAboutStringTooBig() { exception.expect(hasConversionException("--- is not a valid character.")); converter.convert("---", Character.class); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutNullAndEmpty() { assertThat(converter.convert(null, Character.class), is(nullValue())); assertThat(converter.convert("", Character.class), is(nullValue())); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
CharacterConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return null; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNumbers(){ assertThat(converter.convert("5", short.class), is(equalTo((short) 5))); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", short.class); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenNull() { assertThat(converter.convert(null, short.class), is(equalTo((short) 0))); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenEmpty() { assertThat(converter.convert("", short.class), is(equalTo((short) 0))); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
PrimitiveShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return (short) 0; } try { return Short.parseShort(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("2", int.class), is(equalTo(2))); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", int.class); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenNull() { assertThat(converter.convert(null, int.class), is(equalTo(0))); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenEmpty() { assertThat(converter.convert("", int.class), is(equalTo(0))); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
PrimitiveIntConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return 0; } try { return Integer.parseInt(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotMatchIfAControllerHasTheWrongWebMethod() throws SecurityException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/remove"); assertThat(route.allowedMethods(), not(contains(HttpMethod.POST))); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("2", Byte.class), is(equalTo((byte) 2))); }
@Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", Byte.class); }
@Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutNull() { assertThat(converter.convert(null, Byte.class), is(nullValue())); }
@Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutEmpty() { assertThat(converter.convert("", Byte.class), is(nullValue())); }
@Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); }
ByteConverter implements Converter<Byte> { @Override public Byte convert(String value, Class<? extends Byte> type) { if (isNullOrEmpty(value)) { return null; } try { return Byte.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Byte convert(String value, Class<? extends Byte> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("r", char.class), is(equalTo('r'))); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid character.")); converter.convert("---", char.class); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenNull() { assertThat(converter.convert(null, char.class), is(equalTo('\u0000'))); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertToZeroWhenEmpty() { assertThat(converter.convert("", char.class), is(equalTo('\u0000'))); }
@Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); }
PrimitiveCharConverter implements Converter<Character> { @Override public Character convert(String value, Class<? extends Character> type) { if (isNullOrEmpty(value)) { return '\u0000'; } if (value.length() != 1) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } return value.charAt(0); } @Override Character convert(String value, Class<? extends Character> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithPTBR() { assertThat(converter.convert("10,00", BigDecimal.class), is(equalTo(new BigDecimal("10.00")))); assertThat(converter.convert("10,01", BigDecimal.class), is(equalTo(new BigDecimal("10.01")))); }
@Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
@Test public void shouldBeAbleToConvertWithENUS() { converter = new BigDecimalConverter(new Locale("en", "US")); assertThat(converter.convert("10.00", BigDecimal.class), is(equalTo(new BigDecimal("10.00")))); assertThat(converter.convert("10.01", BigDecimal.class), is(equalTo(new BigDecimal("10.01")))); }
@Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
@Test public void shouldAcceptAResultWithASpecificWebMethod() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/head"); assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.HEAD))); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", BigDecimal.class), is(nullValue())); }
@Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, BigDecimal.class), is(nullValue())); }
@Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("vr3.9 is not a valid number.")); converter.convert("vr3.9", BigDecimal.class); }
@Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
BigDecimalConverter implements Converter<BigDecimal> { @Override public BigDecimal convert(String value, Class<? extends BigDecimal> type) { if (isNullOrEmpty(value)) { return null; } try { return (BigDecimal) getNumberFormat().parse(value); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected BigDecimalConverter(); @Inject BigDecimalConverter(Locale locale); @Override BigDecimal convert(String value, Class<? extends BigDecimal> type); }
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("2", Integer.class), is(equalTo(2))); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", Integer.class); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutNull() { assertThat(converter.convert(null, Integer.class), is(nullValue())); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutEmpty() { assertThat(converter.convert("", Integer.class), is(nullValue())); }
@Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); }
IntegerConverter implements Converter<Integer> { @Override public Integer convert(String value, Class<? extends Integer> type) { if (isNullOrEmpty(value)) { return null; } try { return Integer.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Integer convert(String value, Class<? extends Integer> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertIntegerNumbers() { assertThat(converter.convert("3", BigInteger.class), is(equalTo(new BigInteger("3")))); }
@Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutNonIntegerNumbers() { exception.expect(hasConversionException("2.3 is not a valid number.")); converter.convert("2.3", BigInteger.class); }
@Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", BigInteger.class); }
@Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldAcceptAResultWithOptionsWebMethod() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/options"); assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.OPTIONS))); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldNotComplainAboutNull() { assertThat(converter.convert(null, BigInteger.class), is(nullValue())); }
@Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldNotComplainAboutEmpty() { assertThat(converter.convert("", BigInteger.class), is(nullValue())); }
@Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); }
BigIntegerConverter implements Converter<BigInteger> { @Override public BigInteger convert(String value, Class<? extends BigInteger> type) { if (isNullOrEmpty(value)) { return null; } try { return new BigInteger(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override BigInteger convert(String value, Class<? extends BigInteger> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithPTBR() { assertThat(converter.convert("10,00", Double.class), is(equalTo(new Double("10.00")))); assertThat(converter.convert("10,01", Double.class), is(equalTo(new Double("10.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithENUS() { converter = new DoubleConverter(new Locale("en", "US")); assertThat(converter.convert("10.00", Double.class), is(equalTo(new Double("10.00")))); assertThat(converter.convert("10.01", Double.class), is(equalTo(new Double("10.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithGroupingAndPTBR() { assertThat(converter.convert("1.000.000,00", Double.class), is(equalTo(new Double("1000000.00")))); assertThat(converter.convert("1.001.000,01", Double.class), is(equalTo(new Double("1001000.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithGroupingAndENUS() { converter = new DoubleConverter(new Locale("en", "US")); assertThat(converter.convert("1,000,000.00", Double.class), is(equalTo(new Double("1000000.00")))); assertThat(converter.convert("1,001,000.01", Double.class), is(equalTo(new Double("1001000.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", Double.class), is(nullValue())); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, Double.class), is(nullValue())); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("vr3.9 is not a valid number.")); converter.convert("vr3.9", Double.class); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
DoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected DoubleConverter(); @Inject DoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertTrueAndFalse(){ assertThat(converter.convert("true", Boolean.class), is(equalTo(true))); assertThat(converter.convert("false", Boolean.class), is(equalTo(false))); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldAcceptAResultWithPatchWebMethod() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(ClientsController.class)); Route route = getRouteMatching(routes, "/clients/update"); assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.PATCH))); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldConvertEmptyToNull() { assertThat(converter.convert("", Boolean.class), is(nullValue())); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldNotComplainAboutNull() { assertThat(converter.convert(null, Boolean.class), is(nullValue())); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldConvertYesNo() { assertThat(converter.convert("yes", Boolean.class), is(equalTo(true))); assertThat(converter.convert("no", Boolean.class), is(equalTo(false))); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldConvertYN() { assertThat(converter.convert("y", Boolean.class), is(equalTo(true))); assertThat(converter.convert("n", Boolean.class), is(equalTo(false))); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldConvertOnOff() { assertThat(converter.convert("on", Boolean.class), is(equalTo(true))); assertThat(converter.convert("off", Boolean.class), is(equalTo(false))); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldConvertIgnoringCase() { assertThat(converter.convert("truE", Boolean.class), is(equalTo(true))); assertThat(converter.convert("FALSE", Boolean.class), is(equalTo(false))); assertThat(converter.convert("On", Boolean.class), is(equalTo(true))); assertThat(converter.convert("oFf", Boolean.class), is(equalTo(false))); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldThrowExceptionForInvalidString() { exception.expect(hasConversionException("NOT A BOOLEAN! is not a valid boolean. Please use true/false, yes/no, y/n or on/off")); converter.convert("not a boolean!", Boolean.class); }
@Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
BooleanConverter implements Converter<Boolean> { @Override public Boolean convert(String value, Class<? extends Boolean> type) { if (isNullOrEmpty(value)) { return null; } value = value.toUpperCase(); if (matches(IS_TRUE, value)) { return true; } else if (matches(IS_FALSE, value)) { return false; } throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } @Override Boolean convert(String value, Class<? extends Boolean> type); }
@Test public void shouldBeAbleToConvertWithPTBR() { assertThat(converter.convert("10,00", Float.class), is(equalTo(new Float("10.00")))); assertThat(converter.convert("10,01", Float.class), is(equalTo(new Float("10.01")))); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithENUS() { converter = new FloatConverter(new Locale("en", "US")); assertThat(converter.convert("10.00", Float.class), is(equalTo(new Float("10.00")))); assertThat(converter.convert("10.01", Float.class), is(equalTo(new Float("10.01")))); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", Float.class), is(nullValue())); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void findsInheritedMethodsWithDefaultNames() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(NiceClients.class)); Route route = getRouteMatching(routes, "/niceClients/toInherit"); assertTrue(route.canHandle(NiceClients.class, ClientsController.class.getDeclaredMethod("toInherit"))); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, Float.class), is(nullValue())); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("vr3.9 is not a valid number.")); converter.convert("vr3.9", Float.class); }
@Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); }
FloatConverter implements Converter<Float> { @Override public Float convert(String value, Class<? extends Float> type) { if (isNullOrEmpty(value)) { return null; } try { return getNumberFormat().parse(value).floatValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } protected FloatConverter(); @Inject FloatConverter(Locale locale); @Override Float convert(String value, Class<? extends Float> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNumbers() { assertThat(converter.convert("2", Short.class), is(equalTo((short) 2))); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("--- is not a valid number.")); converter.convert("---", Short.class); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutNull() { assertThat(converter.convert(null, Short.class), is(nullValue())); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutEmpty() { assertThat(converter.convert("", Short.class), is(nullValue())); }
@Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); }
ShortConverter implements Converter<Short> { @Override public Short convert(String value, Class<? extends Short> type) { if (isNullOrEmpty(value)) { return null; } try { return Short.valueOf(value); } catch (NumberFormatException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } @Override Short convert(String value, Class<? extends Short> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertByOrdinal() { Enum value = converter.convert("1", MyCustomEnum.class); MyCustomEnum second = MyCustomEnum.SECOND; assertEquals(value, second); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertByName() { Enum value = converter.convert("FIRST", MyCustomEnum.class); MyCustomEnum first = MyCustomEnum.FIRST; assertEquals(value, first); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldConvertEmptyToNull() { assertThat(converter.convert("", MyCustomEnum.class), is(nullValue())); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidIndex() { exception.expect(hasConversionException("3200 is not a valid option.")); converter.convert("3200", MyCustomEnum.class); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void supportMethodOverriding() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(NiceClients.class)); Route route = getRouteMatching(routes, "/niceClients/add"); assertThat(route, canHandle(NiceClients.class, "add")); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldComplainAboutInvalidNumber() { exception.expect(hasConversionException("32a00 is not a valid option.")); converter.convert("32a00", MyCustomEnum.class); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldComplainAboutInvalidOrdinal() { exception.expect(hasConversionException("THIRD is not a valid option.")); converter.convert("THIRD", MyCustomEnum.class); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldAcceptNull() { assertThat(converter.convert(null, MyCustomEnum.class), is(nullValue())); }
@Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); }
EnumConverter implements Converter { @Override public Object convert(String value, Class type) { if (isNullOrEmpty(value)) { return null; } if (Character.isDigit(value.charAt(0))) { return resolveByOrdinal(value, type); } else { return resolveByName(value, type); } } @Override Object convert(String value, Class type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithPTBR() { assertThat(converter.convert("10,00", double.class), is(equalTo(Double.parseDouble("10.00")))); assertThat(converter.convert("10,01", double.class), is(equalTo(Double.parseDouble("10.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithENUS() { converter = new PrimitiveDoubleConverter(new Locale("en", "US")); assertThat(converter.convert("10.00", double.class), is(equalTo(Double.parseDouble("10.00")))); assertThat(converter.convert("10.01", double.class), is(equalTo(Double.parseDouble("10.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithGroupingAndPTBR() { assertThat(converter.convert("1.000.000,00", double.class), is(equalTo(Double.parseDouble("1000000.00")))); assertThat(converter.convert("1.001.000,01", double.class), is(equalTo(Double.parseDouble("1001000.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertWithGroupingAndENUS() { converter = new PrimitiveDoubleConverter(new Locale("en", "US")); assertThat(converter.convert("1,000,000.00", double.class), is(equalTo(Double.parseDouble("1000000.00")))); assertThat(converter.convert("1,001,000.01", double.class), is(equalTo(Double.parseDouble("1001000.01")))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertEmpty() { assertThat(converter.convert("", double.class), is(equalTo(0d))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldBeAbleToConvertNull() { assertThat(converter.convert(null, double.class), is(equalTo(0d))); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void shouldThrowExceptionWhenUnableToParse() { exception.expect(hasConversionException("vr3.9 is not a valid number.")); converter.convert("vr3.9", double.class); }
@Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); }
PrimitiveDoubleConverter implements Converter<Double> { @Override public Double convert(String value, Class<? extends Double> type) { if (isNullOrEmpty(value)) { return 0d; } try { return getNumberFormat().parse(value).doubleValue(); } catch (ParseException e) { throw new ConversionException(new ConversionMessage(INVALID_MESSAGE_KEY, value)); } } PrimitiveDoubleConverter(); @Inject PrimitiveDoubleConverter(Locale locale); @Override Double convert(String value, Class<? extends Double> type); static final String INVALID_MESSAGE_KEY; }
@Test public void supportTypeHttpMethodAnnotation() throws SecurityException, NoSuchMethodException { List<Route> routes = parser.rulesFor(new DefaultBeanClass(AnnotatedController.class)); Route route = getRouteMatching(routes, "/annotated/test"); assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.POST))); }
@Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
PathAnnotationRoutesParser implements RoutesParser { @Override public List<Route> rulesFor(BeanClass controller) { Class<?> baseType = controller.getType(); return registerRulesFor(baseType); } protected PathAnnotationRoutesParser(); @Inject PathAnnotationRoutesParser(Router router, ReflectionProvider reflectionProvider); @Override List<Route> rulesFor(BeanClass controller); }
@Test public void shouldLoginWhenUserExists() { when(dao.find(user.getLogin(), user.getPassword())).thenReturn(user); controller.login(user.getLogin(), user.getPassword()); assertThat(validator.getErrors(), empty()); }
@Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
@Test(expected=ValidationException.class) public void shouldNotLoginWhenUserDoesNotExists() { when(dao.find(user.getLogin(), user.getPassword())).thenReturn(null); controller.login(user.getLogin(), user.getPassword()); }
@Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
@Test public void shouldNotLoginWhenUserDoesNotExistsAndHasOneError() { when(dao.find(user.getLogin(), user.getPassword())).thenReturn(null); try { controller.login(user.getLogin(), user.getPassword()); fail("Should throw an exception."); } catch (ValidationException e) { List<Message> errors = e.getErrors(); assertThat(errors, hasSize(1)); assertTrue(errors.contains(new SimpleMessage("login", "invalid_login_or_password"))); } }
@Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
HomeController { @Post @Public public void login(String login, String password) { final User currentUser = dao.find(login, password); validator.check(currentUser != null, new SimpleMessage("login", "invalid_login_or_password")); validator.onErrorUsePageOf(this).login(); userInfo.login(currentUser); result.redirectTo(UsersController.class).home(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
@Test public void shouldLogoutUser() { controller.logout(); verify(userInfo).logout(); }
public void logout() { userInfo.logout(); result.redirectTo(this).login(); }
HomeController { public void logout() { userInfo.logout(); result.redirectTo(this).login(); } }
HomeController { public void logout() { userInfo.logout(); result.redirectTo(this).login(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); }
HomeController { public void logout() { userInfo.logout(); result.redirectTo(this).login(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
HomeController { public void logout() { userInfo.logout(); result.redirectTo(this).login(); } protected HomeController(); @Inject HomeController(UserDao dao, UserInfo userInfo, Result result, Validator validator); @Post @Public void login(String login, String password); void logout(); @Public @Get void login(); @Public @Get void about(); }
@Test public void shouldOpenHomeWithMusicTypes() { controller.home(); MusicType[] musicsType = (MusicType[]) result.included().get("musicTypes"); assertThat(Arrays.asList(musicsType), hasSize(MusicType.values().length)); }
@Get("/") public void home() { result.include("musicTypes", MusicType.values()); }
UsersController { @Get("/") public void home() { result.include("musicTypes", MusicType.values()); } }
UsersController { @Get("/") public void home() { result.include("musicTypes", MusicType.values()); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); }
UsersController { @Get("/") public void home() { result.include("musicTypes", MusicType.values()); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
UsersController { @Get("/") public void home() { result.include("musicTypes", MusicType.values()); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
@SuppressWarnings("unchecked") @Test public void shouldListAllUsers() { when(userDao.listAll()).thenReturn(Arrays.asList(user, anotherUser)); controller.list(); assertThat((List<User>)result.included().get("users"), contains(user, anotherUser)); }
@Get("/users") public void list() { result.include("users", userDao.listAll()); }
UsersController { @Get("/users") public void list() { result.include("users", userDao.listAll()); } }
UsersController { @Get("/users") public void list() { result.include("users", userDao.listAll()); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); }
UsersController { @Get("/users") public void list() { result.include("users", userDao.listAll()); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
UsersController { @Get("/users") public void list() { result.include("users", userDao.listAll()); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
@Test public void shouldAddUser() { controller.add(user); verify(userDao).add(user); assertThat(result.included().get("notice").toString(), is("User " + user.getName() + " successfully added")); }
@Path("/users") @Post @Public public void add(@Valid @LoginAvailable User user) { validator.onErrorUsePageOf(HomeController.class).login(); userDao.add(user); result.include("notice", "User " + user.getName() + " successfully added"); result.redirectTo(HomeController.class).login(); }
UsersController { @Path("/users") @Post @Public public void add(@Valid @LoginAvailable User user) { validator.onErrorUsePageOf(HomeController.class).login(); userDao.add(user); result.include("notice", "User " + user.getName() + " successfully added"); result.redirectTo(HomeController.class).login(); } }
UsersController { @Path("/users") @Post @Public public void add(@Valid @LoginAvailable User user) { validator.onErrorUsePageOf(HomeController.class).login(); userDao.add(user); result.include("notice", "User " + user.getName() + " successfully added"); result.redirectTo(HomeController.class).login(); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); }
UsersController { @Path("/users") @Post @Public public void add(@Valid @LoginAvailable User user) { validator.onErrorUsePageOf(HomeController.class).login(); userDao.add(user); result.include("notice", "User " + user.getName() + " successfully added"); result.redirectTo(HomeController.class).login(); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
UsersController { @Path("/users") @Post @Public public void add(@Valid @LoginAvailable User user) { validator.onErrorUsePageOf(HomeController.class).login(); userDao.add(user); result.include("notice", "User " + user.getName() + " successfully added"); result.redirectTo(HomeController.class).login(); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
@Test public void shouldShowUser() { when(userDao.find(user.getLogin())).thenReturn(user); controller.show(user); assertThat((User) result.included().get("user"), is(user)); }
@Path("/users/{user.login}") @Get public void show(User user) { result.include("user", userDao.find(user.getLogin())); result.forwardTo("/WEB-INF/jsp/users/view.jsp"); }
UsersController { @Path("/users/{user.login}") @Get public void show(User user) { result.include("user", userDao.find(user.getLogin())); result.forwardTo("/WEB-INF/jsp/users/view.jsp"); } }
UsersController { @Path("/users/{user.login}") @Get public void show(User user) { result.include("user", userDao.find(user.getLogin())); result.forwardTo("/WEB-INF/jsp/users/view.jsp"); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); }
UsersController { @Path("/users/{user.login}") @Get public void show(User user) { result.include("user", userDao.find(user.getLogin())); result.forwardTo("/WEB-INF/jsp/users/view.jsp"); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
UsersController { @Path("/users/{user.login}") @Get public void show(User user) { result.include("user", userDao.find(user.getLogin())); result.forwardTo("/WEB-INF/jsp/users/view.jsp"); } protected UsersController(); @Inject UsersController(UserDao dao, Result result, Validator validator, UserInfo userInfo, MusicDao musicDao); @Get("/") void home(); @Get("/users") void list(); @Path("/users") @Post @Public void add(@Valid @LoginAvailable User user); @Path("/users/{user.login}") @Get void show(User user); @Path("/users/{user.login}/musics/{music.id}") @Put void addToMyList(User user, Music music); }
@Test public void shouldAddMusic() { when(userInfo.getUser()).thenReturn(user); controller.add(music, uploadFile); verify(dao).add(music); verify(musics).save(uploadFile, music); assertThat(result.included().get("notice").toString(), is(music.getTitle() + " music added")); }
@Path("/musics") @Post public void add(final @NotNull @Valid Music music, UploadedFile file) { validator.onErrorForwardTo(UsersController.class).home(); musicDao.add(music); User currentUser = userInfo.getUser(); userDao.refresh(currentUser); currentUser.add(music); if (file != null) { musics.save(file, music); logger.info("Uploaded file: {}", file.getFileName()); } result.include("notice", music.getTitle() + " music added"); result.redirectTo(UsersController.class).home(); }
MusicController { @Path("/musics") @Post public void add(final @NotNull @Valid Music music, UploadedFile file) { validator.onErrorForwardTo(UsersController.class).home(); musicDao.add(music); User currentUser = userInfo.getUser(); userDao.refresh(currentUser); currentUser.add(music); if (file != null) { musics.save(file, music); logger.info("Uploaded file: {}", file.getFileName()); } result.include("notice", music.getTitle() + " music added"); result.redirectTo(UsersController.class).home(); } }
MusicController { @Path("/musics") @Post public void add(final @NotNull @Valid Music music, UploadedFile file) { validator.onErrorForwardTo(UsersController.class).home(); musicDao.add(music); User currentUser = userInfo.getUser(); userDao.refresh(currentUser); currentUser.add(music); if (file != null) { musics.save(file, music); logger.info("Uploaded file: {}", file.getFileName()); } result.include("notice", music.getTitle() + " music added"); result.redirectTo(UsersController.class).home(); } protected MusicController(); @Inject MusicController(MusicDao musicDao, UserInfo userInfo, Result result, Validator validator, Musics musics, UserDao userDao); }
MusicController { @Path("/musics") @Post public void add(final @NotNull @Valid Music music, UploadedFile file) { validator.onErrorForwardTo(UsersController.class).home(); musicDao.add(music); User currentUser = userInfo.getUser(); userDao.refresh(currentUser); currentUser.add(music); if (file != null) { musics.save(file, music); logger.info("Uploaded file: {}", file.getFileName()); } result.include("notice", music.getTitle() + " music added"); result.redirectTo(UsersController.class).home(); } protected MusicController(); @Inject MusicController(MusicDao musicDao, UserInfo userInfo, Result result, Validator validator, Musics musics, UserDao userDao); @Path("/musics") @Post void add(final @NotNull @Valid Music music, UploadedFile file); @Path("/musics/{music.id}") @Get void show(Music music); @Get("/musics/search") void search(Music music); @Path("/musics/download/{m.id}") @Get Download download(Music m); @Public @Path("/musics/list/json") void showAllMusicsAsJSON(); @Public @Path("/musics/list/xml") void showAllMusicsAsXML(); @Public @Path("/musics/list/http") void showAllMusicsAsHTTP(); @Public @Path("/musics/list/form") void listForm(); @Public @Path("musics/listAs") void listAs(); }
MusicController { @Path("/musics") @Post public void add(final @NotNull @Valid Music music, UploadedFile file) { validator.onErrorForwardTo(UsersController.class).home(); musicDao.add(music); User currentUser = userInfo.getUser(); userDao.refresh(currentUser); currentUser.add(music); if (file != null) { musics.save(file, music); logger.info("Uploaded file: {}", file.getFileName()); } result.include("notice", music.getTitle() + " music added"); result.redirectTo(UsersController.class).home(); } protected MusicController(); @Inject MusicController(MusicDao musicDao, UserInfo userInfo, Result result, Validator validator, Musics musics, UserDao userDao); @Path("/musics") @Post void add(final @NotNull @Valid Music music, UploadedFile file); @Path("/musics/{music.id}") @Get void show(Music music); @Get("/musics/search") void search(Music music); @Path("/musics/download/{m.id}") @Get Download download(Music m); @Public @Path("/musics/list/json") void showAllMusicsAsJSON(); @Public @Path("/musics/list/xml") void showAllMusicsAsXML(); @Public @Path("/musics/list/http") void showAllMusicsAsHTTP(); @Public @Path("/musics/list/form") void listForm(); @Public @Path("musics/listAs") void listAs(); }