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 testFastValidate() { User user = new User(); try { ValidateUtils.validate(user, false); } catch (Exception e) { String str = e.getMessage(); String [] arrays = str.split(","); assertEquals(arrays.length, 2); } } | public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } static void validate(T bean, Class<?>... groups); static void validate(T bean, boolean flag, Class<?>... groups); } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } static void validate(T bean, Class<?>... groups); static void validate(T bean, boolean flag, Class<?>... groups); } |
@Test public void testValidateSuccess() { User user = new User(); user.setId(1L); user.setRealName("a"); ValidateUtils.validate(user); } | public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } static void validate(T bean, Class<?>... groups); static void validate(T bean, boolean flag, Class<?>... groups); } | ValidateUtils { public static <T> void validate(T bean, Class<?>... groups) { validate(bean, true, groups); } static void validate(T bean, Class<?>... groups); static void validate(T bean, boolean flag, Class<?>... groups); } |
@Test public void testWriteTwoEqualMaxSheetExcel() { List<ExcelDto> excelDtos = ExcelDataList.getList(); excelDtos.remove(65535); List<ExcelDto> excelDtos1 = ExcelDataList.getList(); excelDtos1.remove(65535); FileExcelWrite.build(fileName) .setLargeDataMode(false) .deal(getTitle(), get(), excelDtos) .deal(getTitle(), g... | public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } } | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } private FileExcelWrite(); } | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } private FileExcelWrite(); @Override Out... | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } private FileExcelWrite(); @Override Out... |
@Test public void testInitSalt() { assertNotNull(PBE.initSalt()); } | public static byte[] initSalt() { byte[] salt = new byte[8]; Random random = new Random(); random.nextBytes(salt); return salt; } | PBE { public static byte[] initSalt() { byte[] salt = new byte[8]; Random random = new Random(); random.nextBytes(salt); return salt; } } | PBE { public static byte[] initSalt() { byte[] salt = new byte[8]; Random random = new Random(); random.nextBytes(salt); return salt; } } | PBE { public static byte[] initSalt() { byte[] salt = new byte[8]; Random random = new Random(); random.nextBytes(salt); return salt; } static byte[] encrypt(byte[] data, byte[] key, byte[] salt); static byte[] decrypt(byte[] data, byte[] key, byte[] salt); static Key generateRandomKey(byte[] key); static AlgorithmPar... | PBE { public static byte[] initSalt() { byte[] salt = new byte[8]; Random random = new Random(); random.nextBytes(salt); return salt; } static byte[] encrypt(byte[] data, byte[] key, byte[] salt); static byte[] decrypt(byte[] data, byte[] key, byte[] salt); static Key generateRandomKey(byte[] key); static AlgorithmPar... |
@Test public void encrypt() { String data = "root1"; byte[] key = "1111111111111111".getBytes(); byte[] encryption = AES.encrypt(data.getBytes(), key); assertEquals(Base64.getEncoder().encodeToString(encryption), "8/mudtZ/bQOhcV/K6JFrug=="); String decryptData = new String(AES.decrypt(encryption, key)); assertEquals(de... | public static byte[] encrypt(byte[] data, byte[] key) { validation(data, key); Key secretKeySpec = Symmetry.generateRandomKey(key, AES_ALGORITHM); return Symmetry.encrypt(AES_ALGORITHM, secretKeySpec, data); } | AES { public static byte[] encrypt(byte[] data, byte[] key) { validation(data, key); Key secretKeySpec = Symmetry.generateRandomKey(key, AES_ALGORITHM); return Symmetry.encrypt(AES_ALGORITHM, secretKeySpec, data); } } | AES { public static byte[] encrypt(byte[] data, byte[] key) { validation(data, key); Key secretKeySpec = Symmetry.generateRandomKey(key, AES_ALGORITHM); return Symmetry.encrypt(AES_ALGORITHM, secretKeySpec, data); } } | AES { public static byte[] encrypt(byte[] data, byte[] key) { validation(data, key); Key secretKeySpec = Symmetry.generateRandomKey(key, AES_ALGORITHM); return Symmetry.encrypt(AES_ALGORITHM, secretKeySpec, data); } static byte[] encrypt(byte[] data, byte[] key); static byte[] decrypt(byte[] data, byte[] key); static ... | AES { public static byte[] encrypt(byte[] data, byte[] key) { validation(data, key); Key secretKeySpec = Symmetry.generateRandomKey(key, AES_ALGORITHM); return Symmetry.encrypt(AES_ALGORITHM, secretKeySpec, data); } static byte[] encrypt(byte[] data, byte[] key); static byte[] decrypt(byte[] data, byte[] key); static ... |
@Test public void testInitMacKey() { assertNotNull(HMAC.initMacKey()); } | public static byte[] initMacKey() { try { KeyGenerator keyGenerator = KeyGenerator.getInstance(ISecurity.HMAC_ALGORITHM); SecretKey secretKey = keyGenerator.generateKey(); return secretKey.getEncoded(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("获取自增密钥错误", e); } } | HMAC { public static byte[] initMacKey() { try { KeyGenerator keyGenerator = KeyGenerator.getInstance(ISecurity.HMAC_ALGORITHM); SecretKey secretKey = keyGenerator.generateKey(); return secretKey.getEncoded(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("获取自增密钥错误", e); } } } | HMAC { public static byte[] initMacKey() { try { KeyGenerator keyGenerator = KeyGenerator.getInstance(ISecurity.HMAC_ALGORITHM); SecretKey secretKey = keyGenerator.generateKey(); return secretKey.getEncoded(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("获取自增密钥错误", e); } } } | HMAC { public static byte[] initMacKey() { try { KeyGenerator keyGenerator = KeyGenerator.getInstance(ISecurity.HMAC_ALGORITHM); SecretKey secretKey = keyGenerator.generateKey(); return secretKey.getEncoded(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("获取自增密钥错误", e); } } static byte[] encrypt(b... | HMAC { public static byte[] initMacKey() { try { KeyGenerator keyGenerator = KeyGenerator.getInstance(ISecurity.HMAC_ALGORITHM); SecretKey secretKey = keyGenerator.generateKey(); return secretKey.getEncoded(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("获取自增密钥错误", e); } } static byte[] encrypt(b... |
@Test public void testEncrypt() { byte[] key = Base64.getDecoder().decode("aDoeS0jpEa7R6YssPU7gZvf95RYH4slqbQgr2gpijhviXyOa16xxOAYmlg0VqBKTE0QPYB26wySLruNJNsbO3A=="); byte[] data = "aaaa".getBytes(); byte[] encryptData = HMAC.encrypt(data, key); String result = Base64.getEncoder().encodeToString(encryptData); assertEqu... | public static byte[] encrypt(byte[] data, byte[] key) { try { SecretKey secretKey = new SecretKeySpec(key, ISecurity.HMAC_ALGORITHM); Mac mac = Mac.getInstance(secretKey.getAlgorithm()); mac.init(secretKey); return mac.doFinal(data); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此算法错误", e); } catc... | HMAC { public static byte[] encrypt(byte[] data, byte[] key) { try { SecretKey secretKey = new SecretKeySpec(key, ISecurity.HMAC_ALGORITHM); Mac mac = Mac.getInstance(secretKey.getAlgorithm()); mac.init(secretKey); return mac.doFinal(data); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此算法错误", e);... | HMAC { public static byte[] encrypt(byte[] data, byte[] key) { try { SecretKey secretKey = new SecretKeySpec(key, ISecurity.HMAC_ALGORITHM); Mac mac = Mac.getInstance(secretKey.getAlgorithm()); mac.init(secretKey); return mac.doFinal(data); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此算法错误", e);... | HMAC { public static byte[] encrypt(byte[] data, byte[] key) { try { SecretKey secretKey = new SecretKeySpec(key, ISecurity.HMAC_ALGORITHM); Mac mac = Mac.getInstance(secretKey.getAlgorithm()); mac.init(secretKey); return mac.doFinal(data); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此算法错误", e);... | HMAC { public static byte[] encrypt(byte[] data, byte[] key) { try { SecretKey secretKey = new SecretKeySpec(key, ISecurity.HMAC_ALGORITHM); Mac mac = Mac.getInstance(secretKey.getAlgorithm()); mac.init(secretKey); return mac.doFinal(data); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此算法错误", e);... |
@Test public void testDigest() { byte[] data = "aaa".getBytes(); String result = SHA.digest(data); assertEquals(result, "7e240de74fb1ed08fa08d38063f6a6a91462a815"); } | public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.SHA_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.SHA_ALGORITHM + "]算法", e)... | SHA { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.SHA_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.SHA_ALGORITHM + "]算... | SHA { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.SHA_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.SHA_ALGORITHM + "]算... | SHA { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.SHA_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.SHA_ALGORITHM + "]算... | SHA { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.SHA_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.SHA_ALGORITHM + "]算... |
@Test public void testDigest() { byte[] data = "aaa".getBytes(); String result = MD5.digest(data); assertEquals(result, "47bce5c74f589f4867dbd57e9ca9f808"); } | public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.MD5_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.MD5_ALGORITHM + "]算法", e)... | MD5 { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.MD5_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.MD5_ALGORITHM + "]算... | MD5 { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.MD5_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.MD5_ALGORITHM + "]算... | MD5 { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.MD5_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.MD5_ALGORITHM + "]算... | MD5 { public static String digest(byte[] bytes) { try { MessageDigest md = MessageDigest.getInstance(ISecurity.MD5_ALGORITHM); BigInteger bigInteger = new BigInteger(md.digest(bytes)); return bigInteger.toString(16); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("无此[" + ISecurity.MD5_ALGORITHM + "]算... |
@Test public void testExecuteGet() { try { String type = "forecast_f"; String appid = "0efe9e3c08151b8d"; String date = "201503030741"; String areaid = "101010100"; String key = "a0f6ac_SmartWeatherAPI_cd7e788"; String data = "http: String str = WeatherSecurity.standardURLEncoder(data + appid, key); assertEquals(str, "... | public static String standardURLEncoder(String data, String key) { try { Mac mac = Mac.getInstance("HmacSHA1"); SecretKeySpec spec = new SecretKeySpec(key.getBytes(), "HmacSHA1"); mac.init(spec); byte[] byteHMAC = mac.doFinal(data.getBytes()); if (byteHMAC != null) { String oauth = encode(byteHMAC); return URLEncoder.e... | WeatherSecurity { public static String standardURLEncoder(String data, String key) { try { Mac mac = Mac.getInstance("HmacSHA1"); SecretKeySpec spec = new SecretKeySpec(key.getBytes(), "HmacSHA1"); mac.init(spec); byte[] byteHMAC = mac.doFinal(data.getBytes()); if (byteHMAC != null) { String oauth = encode(byteHMAC); r... | WeatherSecurity { public static String standardURLEncoder(String data, String key) { try { Mac mac = Mac.getInstance("HmacSHA1"); SecretKeySpec spec = new SecretKeySpec(key.getBytes(), "HmacSHA1"); mac.init(spec); byte[] byteHMAC = mac.doFinal(data.getBytes()); if (byteHMAC != null) { String oauth = encode(byteHMAC); r... | WeatherSecurity { public static String standardURLEncoder(String data, String key) { try { Mac mac = Mac.getInstance("HmacSHA1"); SecretKeySpec spec = new SecretKeySpec(key.getBytes(), "HmacSHA1"); mac.init(spec); byte[] byteHMAC = mac.doFinal(data.getBytes()); if (byteHMAC != null) { String oauth = encode(byteHMAC); r... | WeatherSecurity { public static String standardURLEncoder(String data, String key) { try { Mac mac = Mac.getInstance("HmacSHA1"); SecretKeySpec spec = new SecretKeySpec(key.getBytes(), "HmacSHA1"); mac.init(spec); byte[] byteHMAC = mac.doFinal(data.getBytes()); if (byteHMAC != null) { String oauth = encode(byteHMAC); r... |
@Test public void testEncryptByPublicKey() { String data = "abc"; byte[] result = RSAC.encryptByPublicKey(data.getBytes(), ns, es); assertEquals(ISOUtil.hexString(result), "AD04F695A18D6C400F301C3704EA472F6AB875967B66A6F196558E163173F783C1BD8CADD277E518603C2BD819DCB3B8364C9B2E2A89B769A32A678EAD345A1F"); } | public static byte[] encryptByPublicKey(byte[] data, String ns, String es) { return encryptByPublicKey(data, ns, es, ISecurity.RSA_ECB_ALGORITHM); } | RSAC { public static byte[] encryptByPublicKey(byte[] data, String ns, String es) { return encryptByPublicKey(data, ns, es, ISecurity.RSA_ECB_ALGORITHM); } } | RSAC { public static byte[] encryptByPublicKey(byte[] data, String ns, String es) { return encryptByPublicKey(data, ns, es, ISecurity.RSA_ECB_ALGORITHM); } } | RSAC { public static byte[] encryptByPublicKey(byte[] data, String ns, String es) { return encryptByPublicKey(data, ns, es, ISecurity.RSA_ECB_ALGORITHM); } static byte[] encryptByPublicKey(byte[] data, String ns, String es); static byte[] encryptByPublicKey(byte[] data, String ns, String es, String cipherS); static by... | RSAC { public static byte[] encryptByPublicKey(byte[] data, String ns, String es) { return encryptByPublicKey(data, ns, es, ISecurity.RSA_ECB_ALGORITHM); } static byte[] encryptByPublicKey(byte[] data, String ns, String es); static byte[] encryptByPublicKey(byte[] data, String ns, String es, String cipherS); static by... |
@Test public void testDecryptByPrivateKey() { String data = "AD04F695A18D6C400F301C3704EA472F6AB875967B66A6F196558E163173F783C1BD8CADD277E518603C2BD819DCB3B8364C9B2E2A89B769A32A678EAD345A1F"; byte[] result = RSAC.decryptByPrivateKey(ISOUtil.hex2byte(data), ns, ds); assertEquals(new String(result).trim(), "abc"); } | public static byte[] decryptByPrivateKey(byte[] data, String ns, String ds) { return decryptByPrivateKey(data, ns, ds, ISecurity.RSA_ECB_ALGORITHM); } | RSAC { public static byte[] decryptByPrivateKey(byte[] data, String ns, String ds) { return decryptByPrivateKey(data, ns, ds, ISecurity.RSA_ECB_ALGORITHM); } } | RSAC { public static byte[] decryptByPrivateKey(byte[] data, String ns, String ds) { return decryptByPrivateKey(data, ns, ds, ISecurity.RSA_ECB_ALGORITHM); } } | RSAC { public static byte[] decryptByPrivateKey(byte[] data, String ns, String ds) { return decryptByPrivateKey(data, ns, ds, ISecurity.RSA_ECB_ALGORITHM); } static byte[] encryptByPublicKey(byte[] data, String ns, String es); static byte[] encryptByPublicKey(byte[] data, String ns, String es, String cipherS); static ... | RSAC { public static byte[] decryptByPrivateKey(byte[] data, String ns, String ds) { return decryptByPrivateKey(data, ns, ds, ISecurity.RSA_ECB_ALGORITHM); } static byte[] encryptByPublicKey(byte[] data, String ns, String es); static byte[] encryptByPublicKey(byte[] data, String ns, String es, String cipherS); static ... |
@Test public void testJdkGetProxy() { ProxyFactory proxyFactory = new ProxyFactory(); Bmw bmw = new Bmw(); TargetSource targetSource = new SingletonTargetSource(bmw); proxyFactory.setTargetSource(targetSource); Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(bmw.getClass()); for (Class<?> targetInterf... | public static <T> T getRealTarget(Object proxy) { Assert.notNull(proxy, "proxy not null"); while (AopUtils.isAopProxy(proxy)) { ProxyFactory proxyFactory = getProxyFactory(proxy); if (proxyFactory == null) { return null; } ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectFieldAccess(proxyFactory... | SpringProxyUtils { public static <T> T getRealTarget(Object proxy) { Assert.notNull(proxy, "proxy not null"); while (AopUtils.isAopProxy(proxy)) { ProxyFactory proxyFactory = getProxyFactory(proxy); if (proxyFactory == null) { return null; } ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectField... | SpringProxyUtils { public static <T> T getRealTarget(Object proxy) { Assert.notNull(proxy, "proxy not null"); while (AopUtils.isAopProxy(proxy)) { ProxyFactory proxyFactory = getProxyFactory(proxy); if (proxyFactory == null) { return null; } ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectField... | SpringProxyUtils { public static <T> T getRealTarget(Object proxy) { Assert.notNull(proxy, "proxy not null"); while (AopUtils.isAopProxy(proxy)) { ProxyFactory proxyFactory = getProxyFactory(proxy); if (proxyFactory == null) { return null; } ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectField... | SpringProxyUtils { public static <T> T getRealTarget(Object proxy) { Assert.notNull(proxy, "proxy not null"); while (AopUtils.isAopProxy(proxy)) { ProxyFactory proxyFactory = getProxyFactory(proxy); if (proxyFactory == null) { return null; } ConfigurablePropertyAccessor accessor = PropertyAccessorFactory.forDirectField... |
@Test public void testWriteThreeEqualMaxSheetExcel() { List<ExcelDto> excelDtos = ExcelDataList.getList(); excelDtos.remove(65535); List<ExcelDto> excelDtos1 = ExcelDataList.getList(); excelDtos1.remove(65535); List<ExcelDto> excelDtos2 = ExcelDataList.getList(); excelDtos2.remove(65535); FileExcelWrite.build(fileName)... | public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } } | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } private FileExcelWrite(); } | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } private FileExcelWrite(); @Override Out... | FileExcelWrite implements OutputStreamDelegate { public static ExcelWrite build(InputStream inputStream, String fileName) { Objects.requireNonNull(inputStream); Objects.requireNonNull(fileName); return new CopyInputStreamExcelWrite(inputStream, fileName, new FileExcelWrite()); } private FileExcelWrite(); @Override Out... |
@Test(groups = "fast") public void parseBasic() throws Exception { Number result = getConverter().convert("80%", Float.class, errors()); Assert.assertEquals(result, new Float(0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseSpaceBeforePercentSignDouble() throws Exception { Number result = getConverter().convert("0.8 %", Double.class, errors()); Assert.assertEquals(result, new Double(0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseWithoutPercentSignDouble() throws Exception { Number result = getConverter().convert("0.8", Double.class, errors()); Assert.assertEquals(result, new Double(0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseNegativeDouble() throws Exception { Number result = getConverter().convert("-0.8%", Double.class, errors()); Assert.assertEquals(result, new Double(-0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseNegativeSpaceBeforePercentSignDouble() throws Exception { Number result = getConverter().convert("-0.8 %", Double.class, errors()); Assert.assertEquals(result, new Double(-0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseNegativeWithoutPercentSignDouble() throws Exception { Number result = getConverter().convert("-0.8", Double.class, errors()); Assert.assertEquals(result, new Double(-0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseParenthesesDouble() throws Exception { Number result = getConverter().convert("(0.8%)", Double.class, errors()); Assert.assertEquals(result, new Double(-0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseParenthesesSpaceBeforePercentSignDouble() throws Exception { Number result = getConverter().convert("(0.8 %)", Double.class, errors()); Assert.assertEquals(result, new Double(-0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void parseParenthesesWithoutPercentSignDouble() throws Exception { Number result = getConverter().convert("(0.8)", Double.class, errors()); Assert.assertEquals(result, new Double(-0.008)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void validNumber() { CreditCardTypeConverter c = new CreditCardTypeConverter(); Assert.assertEquals(c.convert("4111111111111111", String.class, new ArrayList<ValidationError>()), "4111111111111111"); } | public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("converter.creditCard", "invalidCreditCard")); return null; } | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... |
@Test(groups = "fast") public void invalidNumber() { CreditCardTypeConverter c = new CreditCardTypeConverter(); Assert.assertNull(c.convert("4111111111111110", String.class, new ArrayList<ValidationError>())); } | public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("converter.creditCard", "invalidCreditCard")); return null; } | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... |
@Test(groups = "fast") public void parseSpaceBeforePercentSign() throws Exception { Number result = getConverter().convert("80 %", Float.class, errors()); Assert.assertEquals(result, new Float(0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void stripNonNumericCharacters() { CreditCardTypeConverter c = new CreditCardTypeConverter(); Assert.assertEquals(c.convert("4111-1111-1111-1111", String.class, new ArrayList<ValidationError>()), "4111111111111111"); } | public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("converter.creditCard", "invalidCreditCard")); return null; } | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... | CreditCardTypeConverter implements TypeConverter<String> { public String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors) { String cardNumber = input.replaceAll("\\D", ""); if (getCardType(cardNumber) != null) { return cardNumber; } errors.add(new ScopedLocalizableError("con... |
@Test(groups = "fast") public void basicParse() throws Exception { TypeConverter<BigDecimal> converter = new BigDecimalTypeConverter(); converter.setLocale(Locale.US); BigDecimal result = converter.convert("12345.67", BigDecimal.class, errors()); Assert.assertEquals(result, new BigDecimal("12345.67")); } | public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... |
@Test(groups = "fast") public void parseBigNumber() throws Exception { String number = "7297029872767869231987623498756389734567893246934298765342987563489723497" + ".97982730927907092387409872340987234698750987129872348970982374076283764"; TypeConverter<BigDecimal> converter = new BigDecimalTypeConverter(); converter.... | public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... |
@Test(groups = "fast") public void parseWithGroupingCharacters() throws Exception { String number = "7297029872767869231987623498756389734567876534.2987563489723497"; String grouped = "7,297,029,872,767,869,231,987,623,498,756,389,734,567,876,534.2987563489723497"; TypeConverter<BigDecimal> converter = new BigDecimalTy... | public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... |
@Test(groups = "fast") public void parseAlternateLocale() throws Exception { String number = "123456789.99"; String localized = "123.456.789,99"; TypeConverter<BigDecimal> converter = new BigDecimalTypeConverter(); converter.setLocale(Locale.GERMANY); BigDecimal result = converter.convert(localized, BigDecimal.class, e... | public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... |
@Test(groups = "fast") public void invalidInput() throws Exception { String number = "a1b2vc3d4"; TypeConverter<BigDecimal> converter = new BigDecimalTypeConverter(); converter.setLocale(Locale.US); Collection<ValidationError> errors = errors(); @SuppressWarnings("unused") BigDecimal result = converter.convert(number, ... | public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } } | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... | BigDecimalTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigDecimal> { public BigDecimal convert(String input, Class<? extends BigDecimal> targetType, Collection<ValidationError> errors) { return (BigDecimal) parse(input, errors); } BigDecimal convert(String input,
Class<? extend... |
@Test(groups = "fast") public void basicParse() throws Exception { TypeConverter<BigInteger> converter = new BigIntegerTypeConverter(); converter.setLocale(Locale.US); BigInteger result = converter.convert("1234567", BigInteger.class, errors()); Assert.assertEquals(result, new BigInteger("1234567")); } | public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigInteger(); } else { return null; } } | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... |
@Test(groups = "fast") public void parseBigNumber() throws Exception { String number = String.valueOf(Long.MAX_VALUE) + "8729839871981298798234"; TypeConverter<BigInteger> converter = new BigIntegerTypeConverter(); converter.setLocale(Locale.US); BigInteger result = converter.convert(number, BigInteger.class, errors())... | public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigInteger(); } else { return null; } } | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... |
@Test(groups = "fast") public void parseWithGroupingCharacters() throws Exception { String number = "7297029872767869231987623498756389734567876534"; String grouped = "7,297,029,872,767,869,231,987,623,498,756,389,734,567,876,534"; TypeConverter<BigInteger> converter = new BigIntegerTypeConverter(); converter.setLocale... | public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigInteger(); } else { return null; } } | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... |
@Test(groups = "fast") public void parseAlternateLocale() throws Exception { String number = "123456789"; String localized = "123.456.789"; TypeConverter<BigInteger> converter = new BigIntegerTypeConverter(); converter.setLocale(Locale.GERMANY); BigInteger result = converter.convert(localized, BigInteger.class, errors(... | public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigInteger(); } else { return null; } } | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... |
@Test(groups = "fast") public void parseWithoutPercentSign() throws Exception { Number result = getConverter().convert("80", Float.class, errors()); Assert.assertEquals(result, new Float(0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void decimalTruncation() throws Exception { TypeConverter<BigInteger> converter = new BigIntegerTypeConverter(); converter.setLocale(Locale.US); BigInteger result = converter.convert("123456789.98765", BigInteger.class, errors()); Assert.assertEquals(result, new BigInteger("123456789")); A... | public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigInteger(); } else { return null; } } | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... |
@Test(groups = "fast") public void invalidInput() throws Exception { String number = "a1b2vc3d4"; TypeConverter<BigInteger> converter = new BigIntegerTypeConverter(); converter.setLocale(Locale.US); Collection<ValidationError> errors = errors(); @SuppressWarnings("unused") BigInteger result = converter.convert(number, ... | public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigInteger(); } else { return null; } } | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... | BigIntegerTypeConverter extends NumberTypeConverterSupport implements TypeConverter<BigInteger> { public BigInteger convert(String input, Class<? extends BigInteger> targetType, Collection<ValidationError> errors) { BigDecimal decimal = (BigDecimal) parse(input, errors); if (errors.size() == 0) { return decimal.toBigIn... |
@Test(groups = "fast") public void testBasicUsLocaleDates() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date date = converter.convert("1/31/07", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Ass... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testVariantUsLocaleDates() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date date = converter.convert("01/31/2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size())... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testAlternateSeparatorsDates() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date date = converter.convert("01 31 2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.siz... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testUkLocaleDates() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.UK); Date date = converter.convert("31 01 2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Asser... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testWhackySeparators() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date date = converter.convert("01, 31, 2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); ... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testNonStandardFormats() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date date = converter.convert("Jan 31 2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size());... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testPartialInputFormats() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date date = converter.convert("Jan 31", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Ass... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void testDateToStringFormat() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); DateTypeConverter converter = getConverter(Locale.US); Date now = new Date(); Date date = converter.convert(now.toString(), Date.class, errors); Assert.assertNotNull(date); Assert.assertE... | public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseException pe) { } } if (date != null) { return date; ... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... | DateTypeConverter implements TypeConverter<Date> { public Date convert(String input, Class<? extends Date> targetType, Collection<ValidationError> errors) { String parseable = preProcessInput(input); Date date = null; for (DateFormat format : this.formats) { try { date = format.parse(parseable); break; } catch (ParseEx... |
@Test(groups = "fast") public void parseNegative() throws Exception { Number result = getConverter().convert("-80%", Float.class, errors()); Assert.assertEquals(result, new Float(-0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void basicPositiveTests() { Number number = getConverter().parse("10912", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), 10912); number = getConverter().parse("-1,000,000", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), -1000000); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testNumbersWithWhiteSpace() { Number number = getConverter().parse(" 5262 ", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), 5262, "White space should have no effect."); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testFloatingPointsNumbers() { Number number = getConverter().parse("123.456", new ArrayList<ValidationError>()); Assert.assertEquals(number.doubleValue(), 123.456); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testParentheticalNumbers() { Number number = getConverter().parse("(891)", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), -891, "Brackets mean negative values."); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testCurrency() { Number number = getConverter().parse("$57", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), 57); number = getConverter().parse("$1,999.95", new ArrayList<ValidationError>()); Assert.assertEquals(number.doubleValue(), 1999.95); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testCurrencyWithSpace() { Number number = getConverter().parse("$ 57", new ArrayList<ValidationError>()); Assert.assertNotNull(number); Assert.assertEquals(number.intValue(), 57); number = getConverter().parse("1,999.95 $", new ArrayList<ValidationError>()); Assert.assertNotNull(numbe... | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testNegativeCurrency() { Number number = getConverter().parse("-$57", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), -57); number = getConverter().parse("$-57", new ArrayList<ValidationError>()); Assert.assertEquals(number.intValue(), -57); number = getConve... | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testComplicatedString() { Number number = getConverter().parse(" ($2,154,123.66) ", new ArrayList<ValidationError>()); Assert.assertEquals(number.doubleValue(), -2154123.66); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testWithText() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); Number number = getConverter().parse("not-a-number", errors); Assert.assertNull(number); Assert.assertEquals(errors.size(), 1, "We should have gotten a parse error."); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testWithBogusTrailingText() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); Number number = getConverter().parse("12345six", errors); Assert.assertNull(number); Assert.assertEquals(errors.size(), 1, "We should have gotten a parse error."); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void parseNegativeSpaceBeforePercentSign() throws Exception { Number result = getConverter().convert("-80 %", Float.class, errors()); Assert.assertEquals(result, new Float(-0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void testWithMultipleDecimalPoints() { Collection<ValidationError> errors = new ArrayList<ValidationError>(); Number number = getConverter().parse("123.456.789", errors); Assert.assertNull(number); Assert.assertEquals(errors.size(), 1, "We should have gotten a parse error."); } | protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIndex()) { return number; } } e... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... | NumberTypeConverterSupport { protected Number parse(String input, Collection<ValidationError> errors) { input = preprocess(input); ParsePosition pp = new ParsePosition(0); for (NumberFormat format : this.formats) { pp.setIndex(0); Number number = format.parse(input, pp); if (number != null && input.length() == pp.getIn... |
@Test(groups = "fast") public void testBasicUrl() throws Exception { String path = "/test/page.jsp"; UrlBuilder builder = new UrlBuilder(Locale.getDefault(), path, false); String result = builder.toString(); Assert.assertEquals(result, path); } | @Override public String toString() { if (url == null) { url = build(); } if (this.anchor != null && this.anchor.length() > 0) { return url + "#" + StringUtil.uriFragmentEncode(this.anchor); } else { return url; } } | UrlBuilder { @Override public String toString() { if (url == null) { url = build(); } if (this.anchor != null && this.anchor.length() > 0) { return url + "#" + StringUtil.uriFragmentEncode(this.anchor); } else { return url; } } } | UrlBuilder { @Override public String toString() { if (url == null) { url = build(); } if (this.anchor != null && this.anchor.length() > 0) { return url + "#" + StringUtil.uriFragmentEncode(this.anchor); } else { return url; } } UrlBuilder(Locale locale, String url, boolean isForPage); UrlBuilder(Locale locale, Class<?... | UrlBuilder { @Override public String toString() { if (url == null) { url = build(); } if (this.anchor != null && this.anchor.length() > 0) { return url + "#" + StringUtil.uriFragmentEncode(this.anchor); } else { return url; } } UrlBuilder(Locale locale, String url, boolean isForPage); UrlBuilder(Locale locale, Class<?... | UrlBuilder { @Override public String toString() { if (url == null) { url = build(); } if (this.anchor != null && this.anchor.length() > 0) { return url + "#" + StringUtil.uriFragmentEncode(this.anchor); } else { return url; } } UrlBuilder(Locale locale, String url, boolean isForPage); UrlBuilder(Locale locale, Class<?... |
@Test(groups = "fast") public void testJoinWithNoStrings() throws Exception { String combined = HtmlUtil.combineValues(null); Assert.assertEquals(combined, ""); combined = HtmlUtil.combineValues(new HashSet<String>()); Assert.assertEquals(combined, ""); } | public static String combineValues(Collection<String> values) { if (values == null || values.size() == 0) { return ""; } else { StringBuilder builder = new StringBuilder(values.size() * 30); for (String value : values) { builder.append(value).append(FIELD_DELIMITER_STRING); } return encode(builder.toString()); } } | HtmlUtil { public static String combineValues(Collection<String> values) { if (values == null || values.size() == 0) { return ""; } else { StringBuilder builder = new StringBuilder(values.size() * 30); for (String value : values) { builder.append(value).append(FIELD_DELIMITER_STRING); } return encode(builder.toString()... | HtmlUtil { public static String combineValues(Collection<String> values) { if (values == null || values.size() == 0) { return ""; } else { StringBuilder builder = new StringBuilder(values.size() * 30); for (String value : values) { builder.append(value).append(FIELD_DELIMITER_STRING); } return encode(builder.toString()... | HtmlUtil { public static String combineValues(Collection<String> values) { if (values == null || values.size() == 0) { return ""; } else { StringBuilder builder = new StringBuilder(values.size() * 30); for (String value : values) { builder.append(value).append(FIELD_DELIMITER_STRING); } return encode(builder.toString()... | HtmlUtil { public static String combineValues(Collection<String> values) { if (values == null || values.size() == 0) { return ""; } else { StringBuilder builder = new StringBuilder(values.size() * 30); for (String value : values) { builder.append(value).append(FIELD_DELIMITER_STRING); } return encode(builder.toString()... |
@Test(groups = "fast") public void testSplitWithNoValues() throws Exception { Collection<String> values = HtmlUtil.splitValues(null); Assert.assertNotNull(values); Assert.assertEquals(values.size(), 0); values = HtmlUtil.splitValues(""); Assert.assertNotNull(values); Assert.assertEquals(values.size(), 0); } | public static Collection<String> splitValues(String value) { if (value == null || value.length() == 0) { return Collections.emptyList(); } else { String[] splits = FIELD_DELIMITER_PATTERN.split(value); return Arrays.asList(splits); } } | HtmlUtil { public static Collection<String> splitValues(String value) { if (value == null || value.length() == 0) { return Collections.emptyList(); } else { String[] splits = FIELD_DELIMITER_PATTERN.split(value); return Arrays.asList(splits); } } } | HtmlUtil { public static Collection<String> splitValues(String value) { if (value == null || value.length() == 0) { return Collections.emptyList(); } else { String[] splits = FIELD_DELIMITER_PATTERN.split(value); return Arrays.asList(splits); } } } | HtmlUtil { public static Collection<String> splitValues(String value) { if (value == null || value.length() == 0) { return Collections.emptyList(); } else { String[] splits = FIELD_DELIMITER_PATTERN.split(value); return Arrays.asList(splits); } } static String encode(String fragment); static String combineValues(Colle... | HtmlUtil { public static Collection<String> splitValues(String value) { if (value == null || value.length() == 0) { return Collections.emptyList(); } else { String[] splits = FIELD_DELIMITER_PATTERN.split(value); return Arrays.asList(splits); } } static String encode(String fragment); static String combineValues(Colle... |
@Test(groups = "fast") public void testEmptyOnNullCollection() { Assert.assertTrue(CollectionUtil.empty(null)); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void testEmptyOnCollectionOfNulls() { Assert.assertTrue(CollectionUtil.empty(new String[]{null, null, null})); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void testEmptyZeroLengthCollection() { Assert.assertTrue(CollectionUtil.empty(new String[]{})); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void testEmptyOnCollectionOfEmptyStrings() { Assert.assertTrue(CollectionUtil.empty(new String[]{"", null, ""})); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void testEmptyOnNonEmptyCollection1() { Assert.assertFalse(CollectionUtil.empty(new String[]{"", null, "foo"})); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void testEmptyOnNonEmptyCollection2() { Assert.assertFalse(CollectionUtil.empty(new String[]{"bar"})); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void parseNegativeWithoutPercentSign() throws Exception { Number result = getConverter().convert("-80", Float.class, errors()); Assert.assertEquals(result, new Float(-0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void testEmptyOnNonEmptyCollection3() { Assert.assertFalse(CollectionUtil.empty(new String[]{"bar", "splat", "foo"})); } | public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } } | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... | CollectionUtil { public static boolean empty(String[] arr) { if (arr == null || arr.length == 0) { return true; } for (String s : arr) { if (s != null && !"".equals(s)) { return false; } } return true; } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(Stri... |
@Test(groups = "fast") public void testApplies() { Assert.assertTrue(CollectionUtil.applies(null, "foo")); Assert.assertTrue(CollectionUtil.applies(new String[]{}, "foo")); Assert.assertTrue(CollectionUtil.applies(new String[]{"bar", "foo"}, "foo")); Assert.assertFalse(CollectionUtil.applies(new String[]{"bar", "f00"},... | public static boolean applies(String events[], String event) { if (events == null || events.length == 0) { return true; } boolean isPositive = events[0].charAt(0) != '!'; if (isPositive) { return contains(events, event); } else { return !contains(events, "!" + event); } } | CollectionUtil { public static boolean applies(String events[], String event) { if (events == null || events.length == 0) { return true; } boolean isPositive = events[0].charAt(0) != '!'; if (isPositive) { return contains(events, event); } else { return !contains(events, "!" + event); } } } | CollectionUtil { public static boolean applies(String events[], String event) { if (events == null || events.length == 0) { return true; } boolean isPositive = events[0].charAt(0) != '!'; if (isPositive) { return contains(events, event); } else { return !contains(events, "!" + event); } } } | CollectionUtil { public static boolean applies(String events[], String event) { if (events == null || events.length == 0) { return true; } boolean isPositive = events[0].charAt(0) != '!'; if (isPositive) { return contains(events, event); } else { return !contains(events, "!" + event); } } static boolean contains(Objec... | CollectionUtil { public static boolean applies(String events[], String event) { if (events == null || events.length == 0) { return true; } boolean isPositive = events[0].charAt(0) != '!'; if (isPositive) { return contains(events, event); } else { return !contains(events, "!" + event); } } static boolean contains(Objec... |
@Test(groups = "fast") public void testAsList() { List<Object> list = CollectionUtil.asList(new String[]{"foo", "bar"}); Assert.assertEquals(list.get(0), "foo"); Assert.assertEquals(list.get(1), "bar"); list = CollectionUtil.asList(new String[]{}); Assert.assertEquals(list.size(), 0); list = CollectionUtil.asList(new i... | public static List<Object> asList(Object in) { if (in == null || !in.getClass().isArray()) { throw new IllegalArgumentException("Parameter to asObjectArray must be a non-null array."); } else { int length = Array.getLength(in); LinkedList<Object> list = new LinkedList<Object>(); for (int i = 0; i < length; ++i) { list.... | CollectionUtil { public static List<Object> asList(Object in) { if (in == null || !in.getClass().isArray()) { throw new IllegalArgumentException("Parameter to asObjectArray must be a non-null array."); } else { int length = Array.getLength(in); LinkedList<Object> list = new LinkedList<Object>(); for (int i = 0; i < len... | CollectionUtil { public static List<Object> asList(Object in) { if (in == null || !in.getClass().isArray()) { throw new IllegalArgumentException("Parameter to asObjectArray must be a non-null array."); } else { int length = Array.getLength(in); LinkedList<Object> list = new LinkedList<Object>(); for (int i = 0; i < len... | CollectionUtil { public static List<Object> asList(Object in) { if (in == null || !in.getClass().isArray()) { throw new IllegalArgumentException("Parameter to asObjectArray must be a non-null array."); } else { int length = Array.getLength(in); LinkedList<Object> list = new LinkedList<Object>(); for (int i = 0; i < len... | CollectionUtil { public static List<Object> asList(Object in) { if (in == null || !in.getClass().isArray()) { throw new IllegalArgumentException("Parameter to asObjectArray must be a non-null array."); } else { int length = Array.getLength(in); LinkedList<Object> list = new LinkedList<Object>(); for (int i = 0; i < len... |
@Test(groups = "fast") public void decryptNullTest() throws Exception { String input = null; String decrypted = CryptoUtil.decrypt(input); Assert.assertNull(decrypted, "Decrypting null should give back null."); } | public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length < 1) { log.w... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... |
@Test(groups = "fast") public void decryptBogusInputTest() throws Exception { String input = "_sipApTvfAXjncUGTRUf4OwZJBdz4Mbp2ZxqVyzkKio="; String decrypted = CryptoUtil.decrypt(input); Assert.assertNull(decrypted, "Decrypting a bogus input should give back null."); } | public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length < 1) { log.w... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... | CryptoUtil { public static String decrypt(String input) { if (input == null) { return null; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } byte[] bytes = Base64.decode(input, BASE64_OPTIONS); if (bytes == null || bytes.length... |
@Test(groups = "fast") public void failOnECB() throws Exception { String input1 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; String encrypted1 = CryptoUtil.encrypt(input1); String encrypted2 = CryptoUtil.encrypt(input1); for (int i = 0; i < encryp... | public static String encrypt(String input) { if (input == null) { input = ""; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } try { byte[] inbytes = input.getBytes(); final int inputLength = inbytes.length; byte[] output = new... | CryptoUtil { public static String encrypt(String input) { if (input == null) { input = ""; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } try { byte[] inbytes = input.getBytes(); final int inputLength = inbytes.length; byte[]... | CryptoUtil { public static String encrypt(String input) { if (input == null) { input = ""; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } try { byte[] inbytes = input.getBytes(); final int inputLength = inbytes.length; byte[]... | CryptoUtil { public static String encrypt(String input) { if (input == null) { input = ""; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } try { byte[] inbytes = input.getBytes(); final int inputLength = inbytes.length; byte[]... | CryptoUtil { public static String encrypt(String input) { if (input == null) { input = ""; } Configuration configuration = StripesFilter.getConfiguration(); if (configuration != null && configuration.isDebugMode()) { return input; } try { byte[] inbytes = input.getBytes(); final int inputLength = inbytes.length; byte[]... |
@Test(groups = "fast") public void testAccessibleMethodBaseCase() throws Exception { Method m = Object.class.getMethod("getClass"); Method m2 = ReflectUtil.findAccessibleMethod(m); Assert.assertSame(m, m2); } | public static Method findAccessibleMethod(final Method m) { if (isPublic(m.getModifiers()) && isPublic(m.getDeclaringClass().getModifiers())) { return m; } if (m.isAccessible()) { return m; } final Class<?> clazz = m.getDeclaringClass(); final String name = m.getName(); final Class<?>[] ptypes = m.getParameterTypes(); ... | ReflectUtil { public static Method findAccessibleMethod(final Method m) { if (isPublic(m.getModifiers()) && isPublic(m.getDeclaringClass().getModifiers())) { return m; } if (m.isAccessible()) { return m; } final Class<?> clazz = m.getDeclaringClass(); final String name = m.getName(); final Class<?>[] ptypes = m.getPara... | ReflectUtil { public static Method findAccessibleMethod(final Method m) { if (isPublic(m.getModifiers()) && isPublic(m.getDeclaringClass().getModifiers())) { return m; } if (m.isAccessible()) { return m; } final Class<?> clazz = m.getDeclaringClass(); final String name = m.getName(); final Class<?>[] ptypes = m.getPara... | ReflectUtil { public static Method findAccessibleMethod(final Method m) { if (isPublic(m.getModifiers()) && isPublic(m.getDeclaringClass().getModifiers())) { return m; } if (m.isAccessible()) { return m; } final Class<?> clazz = m.getDeclaringClass(); final String name = m.getName(); final Class<?>[] ptypes = m.getPara... | ReflectUtil { public static Method findAccessibleMethod(final Method m) { if (isPublic(m.getModifiers()) && isPublic(m.getDeclaringClass().getModifiers())) { return m; } if (m.isAccessible()) { return m; } final Class<?> clazz = m.getDeclaringClass(); final String name = m.getName(); final Class<?>[] ptypes = m.getPara... |
@Test(groups = "fast") public void testCovariantProperty() { abstract class Base { abstract Object getId(); } class ROSub extends Base { protected String id; @Override public String getId() { return id; } } class RWSub extends ROSub { @SuppressWarnings("unused") public void setId(String id) { this.id = id; } } Property... | public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property) { if (!propertyDescriptors.containsKey(clazz)) { getPropertyDescriptors(clazz); } return propertyDescriptors.get(clazz).get(property); } | ReflectUtil { public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property) { if (!propertyDescriptors.containsKey(clazz)) { getPropertyDescriptors(clazz); } return propertyDescriptors.get(clazz).get(property); } } | ReflectUtil { public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property) { if (!propertyDescriptors.containsKey(clazz)) { getPropertyDescriptors(clazz); } return propertyDescriptors.get(clazz).get(property); } private ReflectUtil(); } | ReflectUtil { public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property) { if (!propertyDescriptors.containsKey(clazz)) { getPropertyDescriptors(clazz); } return propertyDescriptors.get(clazz).get(property); } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarning... | ReflectUtil { public static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property) { if (!propertyDescriptors.containsKey(clazz)) { getPropertyDescriptors(clazz); } return propertyDescriptors.get(clazz).get(property); } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarning... |
@Test(groups = "fast") public void testResolveTypeArgsOfSuperInterface() { class Impl implements C { } Type[] typeArgs = ReflectUtil.getActualTypeArguments(Impl.class, A.class); Assert.assertEquals(typeArgs.length, 3); Assert.assertEquals(typeArgs[0], Long.class); Assert.assertEquals(typeArgs[1], String.class); Assert.... | public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } } | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } private ReflectUtil(); } | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(Str... | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(Str... |
@Test(groups = "fast") public void testResolveTypeArgsOfSuperclass() { abstract class BaseClass1<S, T, U> { } abstract class BaseClass2<V, W> extends BaseClass1<W, String, V> {} class Impl1<X> extends BaseClass2<Integer, X> { } class Impl2 extends Impl1<Long> { } class Impl3 extends Impl2 { } Type[] typeArgs = ReflectU... | public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } } | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } private ReflectUtil(); } | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(Str... | ReflectUtil { public static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType) { return getActualTypeArguments(clazz, targetType, null); } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(Str... |
@Test(groups = "fast") public void parseParentheses() throws Exception { Number result = getConverter().convert("(80%)", Float.class, errors()); Assert.assertEquals(result, new Float(-0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void findByName() { Class<? extends ActionBean> actionBean = resolver.getActionBeanByName("SimpleActionBean"); Assert.assertNotNull(actionBean); } | public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } } | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } } | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } @Override void init(Configuration configuration); UrlBindingFactory getUrlBindingFactory(); String getUrlBindingFromPath(String path);... | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } @Override void init(Configuration configuration); UrlBindingFactory getUrlBindingFactory(); String getUrlBindingFromPath(String path);... |
@Test(groups = "fast") public void multipleActionBeansWithSameSimpleName() { Class<? extends ActionBean> actionBean = resolver.getActionBeanByName("OverloadedActionBean"); Assert.assertNull(actionBean); } | public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } } | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } } | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } @Override void init(Configuration configuration); UrlBindingFactory getUrlBindingFactory(); String getUrlBindingFromPath(String path);... | AnnotatedClassActionResolver implements ActionResolver { public Class<? extends ActionBean> getActionBeanByName(String actionBeanName) { return actionBeansByName.get(actionBeanName); } @Override void init(Configuration configuration); UrlBindingFactory getUrlBindingFactory(); String getUrlBindingFromPath(String path);... |
@Test(groups = "fast") public void generateBinding() { String binding = this.resolver.getUrlBinding("foo.bar.web.admin.ControlCenterActionBean"); Assert.assertEquals(binding, "/admin/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingForNonPackagedClass() { String binding = this.resolver.getUrlBinding("ControlCenterActionBean"); Assert.assertEquals(binding, "/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingForClassWithSingleBasePackage() { String binding = this.resolver.getUrlBinding("www.ControlCenterActionBean"); Assert.assertEquals(binding, "/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingWithMultipleBasePackages() { String binding = this.resolver.getUrlBinding("foo.web.stripes.bar.www.ControlCenterActionBean"); Assert.assertEquals(binding, "/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingWithMultipleBasePackages2() { String binding = this.resolver.getUrlBinding("foo.web.stripes.www.admin.ControlCenterActionBean"); Assert.assertEquals(binding, "/admin/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingWithoutSuffix() { String binding = this.resolver.getUrlBinding("foo.web.stripes.www.admin.ControlCenter"); Assert.assertEquals(binding, "/admin/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingWithDifferentSuffix() { String binding = this.resolver.getUrlBinding("foo.web.stripes.www.admin.ControlCenterBean"); Assert.assertEquals(binding, "/admin/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void generateBindingWithDifferentSuffix2() { String binding = this.resolver.getUrlBinding("foo.web.stripes.www.admin.ControlCenterAction"); Assert.assertEquals(binding, "/admin/ControlCenter.action"); } | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void parseParenthesesSpaceBeforePercentSign() throws Exception { Number result = getConverter().convert("(80 %)", Float.class, errors()); Assert.assertEquals(result, new Float(-0.8f)); } | public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetTy... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... | PercentageTypeConverter extends NumberTypeConverterSupport implements TypeConverter<Number> { public Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ) { Number number = parse( input, errors ); if ( errors.size() == 0 ) { if ( targetType.equals( Float.class ) || targe... |
@Test(groups = "fast") public void testWithAnnotatedClass() { String name = net.sourceforge.stripes.test.TestActionBean.class.getName(); String binding = this.resolver.getUrlBinding(name); Assert.assertEquals(binding, "/test/Test.action"); binding = this.resolver.getUrlBinding(net.sourceforge.stripes.test.TestActionBea... | @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } } | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... | NameBasedActionResolver extends AnnotatedClassActionResolver { @Override public String getUrlBinding(Class<? extends ActionBean> clazz) { String binding = super.getUrlBinding(clazz); if (binding == null && !Modifier.isAbstract(clazz.getModifiers())) { binding = getUrlBinding(clazz.getName()); } return binding; } @Over... |
@Test(groups = "fast") public void testGetFindViewAttempts() { String urlBinding = "/account/ViewAccount.action"; List<String> viewAttempts = this.resolver.getFindViewAttempts(urlBinding); Assert.assertEquals(viewAttempts.size(), 3); Assert.assertEquals(viewAttempts.get(0), "/account/ViewAccount.jsp"); Assert.assertEqu... | protected List<String> getFindViewAttempts(String urlBinding) { List<String> attempts = new ArrayList<String>(3); int lastPeriod = urlBinding.lastIndexOf('.'); String path = urlBinding.substring(0, urlBinding.lastIndexOf("/") + 1); String name = (lastPeriod >= path.length()) ? urlBinding.substring(path.length(), lastPe... | NameBasedActionResolver extends AnnotatedClassActionResolver { protected List<String> getFindViewAttempts(String urlBinding) { List<String> attempts = new ArrayList<String>(3); int lastPeriod = urlBinding.lastIndexOf('.'); String path = urlBinding.substring(0, urlBinding.lastIndexOf("/") + 1); String name = (lastPeriod... | NameBasedActionResolver extends AnnotatedClassActionResolver { protected List<String> getFindViewAttempts(String urlBinding) { List<String> attempts = new ArrayList<String>(3); int lastPeriod = urlBinding.lastIndexOf('.'); String path = urlBinding.substring(0, urlBinding.lastIndexOf("/") + 1); String name = (lastPeriod... | NameBasedActionResolver extends AnnotatedClassActionResolver { protected List<String> getFindViewAttempts(String urlBinding) { List<String> attempts = new ArrayList<String>(3); int lastPeriod = urlBinding.lastIndexOf('.'); String path = urlBinding.substring(0, urlBinding.lastIndexOf("/") + 1); String name = (lastPeriod... | NameBasedActionResolver extends AnnotatedClassActionResolver { protected List<String> getFindViewAttempts(String urlBinding) { List<String> attempts = new ArrayList<String>(3); int lastPeriod = urlBinding.lastIndexOf('.'); String path = urlBinding.substring(0, urlBinding.lastIndexOf("/") + 1); String name = (lastPeriod... |
@Test(groups = "fast") public void testBaseCase() throws Exception { String input = "Hello"; String output = LocalizationUtility.makePseudoFriendlyName(input); Assert.assertEquals(output, input); } | public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < characters.length; ++i) { if... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... |
@Test(groups = "fast") public void testSimpleCase() throws Exception { String input = "hello"; String output = LocalizationUtility.makePseudoFriendlyName(input); Assert.assertEquals(output, "Hello"); } | public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < characters.length; ++i) { if... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... |
@Test(groups = "fast") public void testWithPeriod() throws Exception { String input = "bug.name"; String output = LocalizationUtility.makePseudoFriendlyName(input); Assert.assertEquals(output, "Bug Name"); } | public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < characters.length; ++i) { if... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... |
@Test(groups = "fast") public void testWithStudlyCaps() throws Exception { String input = "bugName"; String output = LocalizationUtility.makePseudoFriendlyName(input); Assert.assertEquals(output, "Bug Name"); } | public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < characters.length; ++i) { if... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... |
@Test(groups = "fast") public void testComplexName() throws Exception { String input = "bug.submittedBy.firstName"; String output = LocalizationUtility.makePseudoFriendlyName(input); Assert.assertEquals(output, "Bug Submitted By First Name"); } | public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < characters.length; ++i) { if... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... | LocalizationUtility { public static String makePseudoFriendlyName(String fieldNameKey) { StringBuilder builder = new StringBuilder(fieldNameKey.length() + 10); char[] characters = fieldNameKey.toCharArray(); builder.append(Character.toUpperCase(characters[0])); boolean upcaseNextChar = false; for (int i = 1; i < charac... |
@Test(groups = "fast") public void testSimpleClassName() throws Exception { String output = LocalizationUtility.getSimpleName(TestEnum.class); Assert.assertEquals(output, "LocalizationUtilityTest.TestEnum"); output = LocalizationUtility.getSimpleName(A.B.C.class); Assert.assertEquals(output, "LocalizationUtilityTest.A.... | public static String getSimpleName(Class<?> c) { if (c.getEnclosingClass() == null) { return c.getSimpleName(); } else { return prefixSimpleName(new StringBuilder(), c).toString(); } } | LocalizationUtility { public static String getSimpleName(Class<?> c) { if (c.getEnclosingClass() == null) { return c.getSimpleName(); } else { return prefixSimpleName(new StringBuilder(), c).toString(); } } } | LocalizationUtility { public static String getSimpleName(Class<?> c) { if (c.getEnclosingClass() == null) { return c.getSimpleName(); } else { return prefixSimpleName(new StringBuilder(), c).toString(); } } } | LocalizationUtility { public static String getSimpleName(Class<?> c) { if (c.getEnclosingClass() == null) { return c.getSimpleName(); } else { return prefixSimpleName(new StringBuilder(), c).toString(); } } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends... | LocalizationUtility { public static String getSimpleName(Class<?> c) { if (c.getEnclosingClass() == null) { return c.getSimpleName(); } else { return prefixSimpleName(new StringBuilder(), c).toString(); } } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.