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(), get(), excelDtos1) .write(); }
|
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 OutputStream createOutputStream(String fileName); static ExcelWrite build(InputStream inputStream, String fileName); static ExcelWrite build(String fileName); }
|
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 OutputStream createOutputStream(String fileName); static ExcelWrite build(InputStream inputStream, String fileName); static ExcelWrite build(String fileName); }
|
@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 AlgorithmParameterSpec getAlgorithmParameterSpec(byte[] salt); static byte[] initSalt(); }
|
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 AlgorithmParameterSpec getAlgorithmParameterSpec(byte[] salt); static byte[] initSalt(); }
|
@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(decryptData, data); }
|
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 void validation(byte[] data, byte[] key); }
|
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 void validation(byte[] data, byte[] key); }
|
@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(byte[] data, byte[] key); static byte[] initMacKey(); }
|
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(byte[] data, byte[] key); static byte[] initMacKey(); }
|
@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); assertEquals(result, "omXf1QfFYGlZ+SshA2twjw=="); }
|
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); } catch (InvalidKeyException 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); } catch (InvalidKeyException 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); } catch (InvalidKeyException 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); } catch (InvalidKeyException e) { throw new RuntimeException("无效密钥错误", e); } } static byte[] encrypt(byte[] data, byte[] key); static byte[] initMacKey(); }
|
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); } catch (InvalidKeyException e) { throw new RuntimeException("无效密钥错误", e); } } static byte[] encrypt(byte[] data, byte[] key); static byte[] initMacKey(); }
|
@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 + "]算法", 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 + "]算法", 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 + "]算法", e); } } static String digest(byte[] bytes); }
|
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 + "]算法", e); } } static String digest(byte[] bytes); }
|
@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 + "]算法", 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 + "]算法", 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 + "]算法", e); } } static String digest(byte[] bytes); }
|
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 + "]算法", e); } } static String digest(byte[] bytes); }
|
@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, "ocxOZEXG%2BM9aqzMKw0eZK0mXcaA%3D"); String result = data + appid.substring(0, 6) + "&key=" + str; assertEquals(result, "http: } catch (Exception e) { e.printStackTrace(); } }
|
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.encode(oauth, "utf8"); } } catch (Exception e1) { e1.printStackTrace(); } return ""; }
|
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); return URLEncoder.encode(oauth, "utf8"); } } catch (Exception e1) { e1.printStackTrace(); } return ""; } }
|
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); return URLEncoder.encode(oauth, "utf8"); } } catch (Exception e1) { e1.printStackTrace(); } return ""; } }
|
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); return URLEncoder.encode(oauth, "utf8"); } } catch (Exception e1) { e1.printStackTrace(); } return ""; } static String standardURLEncoder(String data, String key); static String encode(byte[] from); }
|
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); return URLEncoder.encode(oauth, "utf8"); } } catch (Exception e1) { e1.printStackTrace(); } return ""; } static String standardURLEncoder(String data, String key); static String encode(byte[] from); }
|
@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 byte[] decryptByPrivateKey(byte[] data, String ns, String ds); static byte[] decryptByPrivateKey(byte[] data, String ns, String ds, String cipherS); }
|
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 byte[] decryptByPrivateKey(byte[] data, String ns, String ds); static byte[] decryptByPrivateKey(byte[] data, String ns, String ds, String cipherS); }
|
@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 byte[] decryptByPrivateKey(byte[] data, String ns, String ds); static byte[] decryptByPrivateKey(byte[] data, String ns, String ds, String cipherS); }
|
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 byte[] decryptByPrivateKey(byte[] data, String ns, String ds); static byte[] decryptByPrivateKey(byte[] data, String ns, String ds, String cipherS); }
|
@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<?> targetInterface : targetInterfaces) { proxyFactory.addInterface(targetInterface); } Advisor[] advisors = new Advisor[1]; advisors[0] = advisorAdapterRegistry.wrap(new TestMethodInterceptor()); proxyFactory.addAdvisors(advisors); Car proxy = (Car) proxyFactory.getProxy(); proxy.hashCode(); Bmw obj = SpringProxyUtils.getRealTarget(proxy); assertEquals(bmw, obj); }
|
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); TargetSource targetSource = (TargetSource) accessor.getPropertyValue("targetSource"); if (targetSource == null) { return null; } try { proxy = targetSource.getTarget(); } catch (Exception e) { e.printStackTrace(); } } return (T) proxy; }
|
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.forDirectFieldAccess(proxyFactory); TargetSource targetSource = (TargetSource) accessor.getPropertyValue("targetSource"); if (targetSource == null) { return null; } try { proxy = targetSource.getTarget(); } catch (Exception e) { e.printStackTrace(); } } return (T) proxy; } }
|
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.forDirectFieldAccess(proxyFactory); TargetSource targetSource = (TargetSource) accessor.getPropertyValue("targetSource"); if (targetSource == null) { return null; } try { proxy = targetSource.getTarget(); } catch (Exception e) { e.printStackTrace(); } } return (T) proxy; } }
|
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.forDirectFieldAccess(proxyFactory); TargetSource targetSource = (TargetSource) accessor.getPropertyValue("targetSource"); if (targetSource == null) { return null; } try { proxy = targetSource.getTarget(); } catch (Exception e) { e.printStackTrace(); } } return (T) proxy; } static T getRealTarget(Object proxy); static boolean isMultipleProxy(Object proxy); static ProxyFactory findJdkDynamicProxyFactory(Object proxy); static ProxyFactory findCglibProxyFactory(Object proxy); static boolean isTransactional(Object proxy); static void removeTransactional(Object proxy); static boolean isAsync(Object proxy); static void removeAsync(Object proxy); }
|
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.forDirectFieldAccess(proxyFactory); TargetSource targetSource = (TargetSource) accessor.getPropertyValue("targetSource"); if (targetSource == null) { return null; } try { proxy = targetSource.getTarget(); } catch (Exception e) { e.printStackTrace(); } } return (T) proxy; } static T getRealTarget(Object proxy); static boolean isMultipleProxy(Object proxy); static ProxyFactory findJdkDynamicProxyFactory(Object proxy); static ProxyFactory findCglibProxyFactory(Object proxy); static boolean isTransactional(Object proxy); static void removeTransactional(Object proxy); static boolean isAsync(Object proxy); static void removeAsync(Object proxy); }
|
@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) .setLargeDataMode(false) .deal(getTitle(), get(), excelDtos) .deal(getTitle(), get(), excelDtos1) .deal(getTitle(), get(), excelDtos2) .write(); }
|
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 OutputStream createOutputStream(String fileName); static ExcelWrite build(InputStream inputStream, String fileName); static ExcelWrite build(String fileName); }
|
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 OutputStream createOutputStream(String fileName); static ExcelWrite build(InputStream inputStream, String fileName); static ExcelWrite build(String fileName); }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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("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("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("converter.creditCard", "invalidCreditCard")); return null; } void setLocale(Locale locale); String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors); static Type getCardType(String cardNumber); }
|
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("converter.creditCard", "invalidCreditCard")); return null; } void setLocale(Locale locale); String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors); static Type getCardType(String cardNumber); }
|
@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("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("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("converter.creditCard", "invalidCreditCard")); return null; } void setLocale(Locale locale); String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors); static Type getCardType(String cardNumber); }
|
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("converter.creditCard", "invalidCreditCard")); return null; } void setLocale(Locale locale); String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors); static Type getCardType(String cardNumber); }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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("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("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("converter.creditCard", "invalidCreditCard")); return null; } void setLocale(Locale locale); String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors); static Type getCardType(String cardNumber); }
|
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("converter.creditCard", "invalidCreditCard")); return null; } void setLocale(Locale locale); String convert(String input, Class<? extends String> targetType, Collection<ValidationError> errors); static Type getCardType(String cardNumber); }
|
@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<? extends BigDecimal> targetType,
Collection<ValidationError> 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<? extends BigDecimal> targetType,
Collection<ValidationError> errors); }
|
@Test(groups = "fast") public void parseBigNumber() throws Exception { String number = "7297029872767869231987623498756389734567893246934298765342987563489723497" + ".97982730927907092387409872340987234698750987129872348970982374076283764"; TypeConverter<BigDecimal> converter = new BigDecimalTypeConverter(); converter.setLocale(Locale.US); BigDecimal result = converter.convert(number, BigDecimal.class, errors()); Assert.assertEquals(result, new BigDecimal(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<? extends BigDecimal> targetType,
Collection<ValidationError> 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<? extends BigDecimal> targetType,
Collection<ValidationError> errors); }
|
@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 BigDecimalTypeConverter(); converter.setLocale(Locale.US); BigDecimal result = converter.convert(grouped, BigDecimal.class, errors()); Assert.assertEquals(result, new BigDecimal(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<? extends BigDecimal> targetType,
Collection<ValidationError> 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<? extends BigDecimal> targetType,
Collection<ValidationError> errors); }
|
@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, errors()); Assert.assertEquals(result, new BigDecimal(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<? extends BigDecimal> targetType,
Collection<ValidationError> 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<? extends BigDecimal> targetType,
Collection<ValidationError> errors); }
|
@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, BigDecimal.class, errors); Assert.assertEquals(errors.size(), 1); }
|
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<? extends BigDecimal> targetType,
Collection<ValidationError> 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<? extends BigDecimal> targetType,
Collection<ValidationError> errors); }
|
@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.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.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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
@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()); Assert.assertEquals(result, new BigInteger(number)); Assert.assertEquals(result.toString(), 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.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.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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
@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(Locale.US); BigInteger result = converter.convert(grouped, BigInteger.class, errors()); Assert.assertEquals(result, new BigInteger(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.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.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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
@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()); Assert.assertEquals(result, new BigInteger(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.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.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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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")); Assert.assertEquals(result.toString(), "123456789"); }
|
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.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.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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
@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, BigInteger.class, errors); Assert.assertEquals(errors.size(), 1); }
|
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.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.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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
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.toBigInteger(); } else { return null; } } BigInteger convert(String input,
Class<? extends BigInteger> targetType,
Collection<ValidationError> errors); }
|
@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()); Assert.assertEquals(format.format(date), "01/31/2007"); date = converter.convert("Feb 28, 2006", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/2006"); date = converter.convert("March 1, 2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/2007"); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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()); Assert.assertEquals(format.format(date), "01/31/2007"); date = converter.convert("28 Feb 06", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/2006"); date = converter.convert("1 March 07", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/2007"); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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.size()); Assert.assertEquals(format.format(date), "01/31/2007"); date = converter.convert("28-Feb-06", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/2006"); date = converter.convert("01-March-07", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/2007"); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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()); Assert.assertEquals(format.format(date), "01/31/2007"); date = converter.convert("28/02/2006", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/2006"); date = converter.convert("01 March 2007", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/2007"); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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()); Assert.assertEquals(format.format(date), "01/31/2007"); date = converter.convert("02--28.2006", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/2006"); date = converter.convert("01 Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/2007"); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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()); Assert.assertEquals(format.format(date), "01/31/2007"); date = converter.convert("February 28 2006", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/2006"); date = converter.convert("2007-03-01", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/2007"); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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()); Assert.assertEquals(format.format(date), "01/31/" + Calendar.getInstance().get(Calendar.YEAR)); date = converter.convert("February 28", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "02/28/" + Calendar.getInstance().get(Calendar.YEAR)); date = converter.convert("03/01", Date.class, errors); Assert.assertNotNull(date); Assert.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), "03/01/" + Calendar.getInstance().get(Calendar.YEAR)); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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.assertEquals(0, errors.size()); Assert.assertEquals(format.format(date), format.format(now)); }
|
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; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); }
|
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 (ParseException pe) { } } if (date != null) { return date; } else { errors.add(new ScopedLocalizableError("converter.date", "invalidDate")); return null; } } void setLocale(Locale locale); Locale getLocale(); Date convert(String input,
Class<? extends Date> targetType,
Collection<ValidationError> errors); static final Pattern PRE_PROCESS_PATTERN; static final String[] formatStrings; static final String KEY_FORMAT_STRINGS; static final String KEY_PRE_PROCESS_PATTERN; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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(number); 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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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 = getConverter().parse("($1,999.95)", new ArrayList<ValidationError>()); Assert.assertEquals(number.doubleValue(), -1999.95); 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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
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.getIndex()) { return number; } } errors.add(new ScopedLocalizableError("converter.number", "invalidNumber")); return null; } void setLocale(Locale locale); Locale getLocale(); }
|
@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<? extends ActionBean> beanType, boolean isForPage); protected UrlBuilder(Locale locale, boolean isForPage); }
|
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<? extends ActionBean> beanType, boolean isForPage); protected UrlBuilder(Locale locale, boolean isForPage); String getEvent(); UrlBuilder setEvent(String event); String getParameterSeparator(); void setParameterSeparator(String parameterSeparator); UrlBuilder addParameter(String name, Object... values); UrlBuilder addParameters(Map<? extends Object, ? extends Object> parameters); String getAnchor(); UrlBuilder setAnchor(String anchor); @Override String toString(); }
|
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<? extends ActionBean> beanType, boolean isForPage); protected UrlBuilder(Locale locale, boolean isForPage); String getEvent(); UrlBuilder setEvent(String event); String getParameterSeparator(); void setParameterSeparator(String parameterSeparator); UrlBuilder addParameter(String name, Object... values); UrlBuilder addParameters(Map<? extends Object, ? extends Object> parameters); String getAnchor(); UrlBuilder setAnchor(String anchor); @Override String toString(); }
|
@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()); } } static String encode(String fragment); static String combineValues(Collection<String> values); static Collection<String> splitValues(String value); }
|
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()); } } static String encode(String fragment); static String combineValues(Collection<String> values); static Collection<String> splitValues(String value); }
|
@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(Collection<String> values); static Collection<String> splitValues(String value); }
|
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(Collection<String> values); static Collection<String> splitValues(String value); }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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"}, "foo")); Assert.assertFalse(CollectionUtil.applies(new String[]{"!bar", "!foo"}, "foo")); Assert.assertTrue(CollectionUtil.applies(new String[]{"!bar", "!f00"}, "foo")); }
|
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(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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 int[]{0, 1, 2, 3}); Assert.assertEquals(list.get(0), new Integer(0)); Assert.assertEquals(list.get(1), new Integer(1)); Assert.assertEquals(list.get(2), new Integer(2)); Assert.assertEquals(list.get(3), new Integer(3)); }
|
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.add(i, Array.get(in, i)); } return 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 < length; ++i) { list.add(i, Array.get(in, i)); } return 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 < length; ++i) { list.add(i, Array.get(in, i)); } return 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 < length; ++i) { list.add(i, Array.get(in, i)); } return list; } } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
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 < length; ++i) { list.add(i, Array.get(in, i)); } return list; } } static boolean contains(Object[] arr, Object item); static boolean empty(String[] arr); static boolean applies(String events[], String event); static Object[] asObjectArray(Object in); static List<Object> asList(Object in); static List<T> asList(Iterable<T> in); }
|
@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.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } static String encrypt(String input); static String decrypt(String input); static synchronized void setSecretKey(SecretKey key); }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } static String encrypt(String input); static String decrypt(String input); static synchronized void setSecretKey(SecretKey key); static final String CONFIG_ENCRYPTION_KEY; }
|
@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.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } static String encrypt(String input); static String decrypt(String input); static synchronized void setSecretKey(SecretKey key); }
|
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 < 1) { log.warn("Input is not Base64 encoded: ", input); return null; } if (bytes.length < CIPHER_BLOCK_LENGTH * 2 + CIPHER_HMAC_LENGTH) { log.warn("Input is too short: ", input); return null; } SecretKey key = getSecretKey(); byte[] mac = new byte[CIPHER_HMAC_LENGTH]; try { hmac(key, bytes, 0, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error performing hmac on: ", input); return null; } boolean validCiphertext; try { validCiphertext = hmacEquals(key, bytes, bytes.length - CIPHER_HMAC_LENGTH, mac, 0); } catch (Exception e1) { log.warn("Unexpected error validating hmac of: ", input); return null; } if (!validCiphertext) { log.warn("Input was not encrypted with the current encryption key (bad HMAC): ", input); return null; } Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE, bytes, 0, CIPHER_BLOCK_LENGTH); byte[] output; try { output = cipher.doFinal(bytes, CIPHER_BLOCK_LENGTH, bytes.length - CIPHER_HMAC_LENGTH - CIPHER_BLOCK_LENGTH); } catch (IllegalBlockSizeException e) { log.warn("Unexpected IllegalBlockSizeException on: ", input); return null; } catch (BadPaddingException e) { log.warn("Unexpected BadPaddingException on: ", input); return null; } return new String(output); } static String encrypt(String input); static String decrypt(String input); static synchronized void setSecretKey(SecretKey key); static final String CONFIG_ENCRYPTION_KEY; }
|
@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 < encrypted1.length() - 4; i++) { Assert.assertFalse( encrypted2.contains(encrypted1.substring(i, i + 4)), "Predictable ECB detected: " + encrypted1 + " " + encrypted2); } }
|
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 byte[calculateCipherbytes(inputLength) + CIPHER_HMAC_LENGTH]; SecretKey key = getSecretKey(); byte[] iv = generateInitializationVector(); System.arraycopy(iv, 0, output, 0, CIPHER_BLOCK_LENGTH); Cipher cipher = getCipher(key, Cipher.ENCRYPT_MODE, iv, 0, CIPHER_BLOCK_LENGTH); cipher.doFinal(inbytes, 0, inbytes.length, output, CIPHER_BLOCK_LENGTH); hmac(key, output, 0, output.length - CIPHER_HMAC_LENGTH, output, output.length - CIPHER_HMAC_LENGTH); return Base64.encodeBytes(output, BASE64_OPTIONS); } catch (Exception e) { throw new StripesRuntimeException("Could not encrypt value.", e); } }
|
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[] output = new byte[calculateCipherbytes(inputLength) + CIPHER_HMAC_LENGTH]; SecretKey key = getSecretKey(); byte[] iv = generateInitializationVector(); System.arraycopy(iv, 0, output, 0, CIPHER_BLOCK_LENGTH); Cipher cipher = getCipher(key, Cipher.ENCRYPT_MODE, iv, 0, CIPHER_BLOCK_LENGTH); cipher.doFinal(inbytes, 0, inbytes.length, output, CIPHER_BLOCK_LENGTH); hmac(key, output, 0, output.length - CIPHER_HMAC_LENGTH, output, output.length - CIPHER_HMAC_LENGTH); return Base64.encodeBytes(output, BASE64_OPTIONS); } catch (Exception e) { throw new StripesRuntimeException("Could not encrypt value.", e); } } }
|
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[] output = new byte[calculateCipherbytes(inputLength) + CIPHER_HMAC_LENGTH]; SecretKey key = getSecretKey(); byte[] iv = generateInitializationVector(); System.arraycopy(iv, 0, output, 0, CIPHER_BLOCK_LENGTH); Cipher cipher = getCipher(key, Cipher.ENCRYPT_MODE, iv, 0, CIPHER_BLOCK_LENGTH); cipher.doFinal(inbytes, 0, inbytes.length, output, CIPHER_BLOCK_LENGTH); hmac(key, output, 0, output.length - CIPHER_HMAC_LENGTH, output, output.length - CIPHER_HMAC_LENGTH); return Base64.encodeBytes(output, BASE64_OPTIONS); } catch (Exception e) { throw new StripesRuntimeException("Could not encrypt value.", e); } } }
|
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[] output = new byte[calculateCipherbytes(inputLength) + CIPHER_HMAC_LENGTH]; SecretKey key = getSecretKey(); byte[] iv = generateInitializationVector(); System.arraycopy(iv, 0, output, 0, CIPHER_BLOCK_LENGTH); Cipher cipher = getCipher(key, Cipher.ENCRYPT_MODE, iv, 0, CIPHER_BLOCK_LENGTH); cipher.doFinal(inbytes, 0, inbytes.length, output, CIPHER_BLOCK_LENGTH); hmac(key, output, 0, output.length - CIPHER_HMAC_LENGTH, output, output.length - CIPHER_HMAC_LENGTH); return Base64.encodeBytes(output, BASE64_OPTIONS); } catch (Exception e) { throw new StripesRuntimeException("Could not encrypt value.", e); } } static String encrypt(String input); static String decrypt(String input); static synchronized void setSecretKey(SecretKey key); }
|
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[] output = new byte[calculateCipherbytes(inputLength) + CIPHER_HMAC_LENGTH]; SecretKey key = getSecretKey(); byte[] iv = generateInitializationVector(); System.arraycopy(iv, 0, output, 0, CIPHER_BLOCK_LENGTH); Cipher cipher = getCipher(key, Cipher.ENCRYPT_MODE, iv, 0, CIPHER_BLOCK_LENGTH); cipher.doFinal(inbytes, 0, inbytes.length, output, CIPHER_BLOCK_LENGTH); hmac(key, output, 0, output.length - CIPHER_HMAC_LENGTH, output, output.length - CIPHER_HMAC_LENGTH); return Base64.encodeBytes(output, BASE64_OPTIONS); } catch (Exception e) { throw new StripesRuntimeException("Could not encrypt value.", e); } } static String encrypt(String input); static String decrypt(String input); static synchronized void setSecretKey(SecretKey key); static final String CONFIG_ENCRYPTION_KEY; }
|
@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(); for (Class<?> iface : clazz.getInterfaces()) { try { Method m2 = iface.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(iface.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } } Class<?> c = clazz.getSuperclass(); while (c != null) { try { Method m2 = c.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(c.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } c = c.getSuperclass(); } return m; }
|
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.getParameterTypes(); for (Class<?> iface : clazz.getInterfaces()) { try { Method m2 = iface.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(iface.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } } Class<?> c = clazz.getSuperclass(); while (c != null) { try { Method m2 = c.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(c.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } c = c.getSuperclass(); } return m; } }
|
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.getParameterTypes(); for (Class<?> iface : clazz.getInterfaces()) { try { Method m2 = iface.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(iface.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } } Class<?> c = clazz.getSuperclass(); while (c != null) { try { Method m2 = c.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(c.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } c = c.getSuperclass(); } return m; } private ReflectUtil(); }
|
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.getParameterTypes(); for (Class<?> iface : clazz.getInterfaces()) { try { Method m2 = iface.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(iface.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } } Class<?> c = clazz.getSuperclass(); while (c != null) { try { Method m2 = c.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(c.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } c = c.getSuperclass(); } return m; } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
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.getParameterTypes(); for (Class<?> iface : clazz.getInterfaces()) { try { Method m2 = iface.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(iface.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } } Class<?> c = clazz.getSuperclass(); while (c != null) { try { Method m2 = c.getMethod(name, ptypes); if (m2.isAccessible()) { return m2; } if (isPublic(c.getModifiers()) && isPublic(m2.getModifiers())) { return m2; } } catch (NoSuchMethodException nsme) { } c = c.getSuperclass(); } return m; } private ReflectUtil(); static boolean isDefault(Method method); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
@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; } } PropertyDescriptor pd = ReflectUtil.getPropertyDescriptor(ROSub.class, "id"); Assert.assertNotNull(pd.getReadMethod(), "Read method is null"); Assert.assertNull(pd.getWriteMethod(), "Write method is not null"); pd = ReflectUtil.getPropertyDescriptor(RWSub.class, "id"); Assert.assertNotNull(pd.getReadMethod(), "Read method is null"); Assert.assertNotNull(pd.getWriteMethod(), "Write method is null"); }
|
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); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
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); @SuppressWarnings("rawtypes") // this allows us to assign without casting static Class findClass(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
@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.assertEquals(typeArgs[2], Integer.class); }
|
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(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
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(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
@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 = ReflectUtil.getActualTypeArguments(Impl3.class, BaseClass1.class); Assert.assertEquals(typeArgs.length, 3); Assert.assertEquals(typeArgs[0], Long.class); Assert.assertEquals(typeArgs[1], String.class); Assert.assertEquals(typeArgs[2], Integer.class); }
|
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(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
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(String name); static String toString(Annotation ann); static Collection<Method> getMethods(Class<?> clazz); static Collection<Field> getFields(Class<?> clazz); static PropertyDescriptor getPropertyDescriptor(Class<?> clazz, String property); static Method findAccessibleMethod(final Method m); static Field getField(Class<?> clazz, String property); static Object getDefaultValue(Class<?> clazz); static Set<Class<?>> getImplementedInterfaces(Class<?> clazz); static Type[] getActualTypeArguments(Class<?> clazz, Class<?> targetType); static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz); static Method resolveBridgedReadMethod(PropertyDescriptor pd); static Method resolveBridgedWriteMethod(PropertyDescriptor pd); static Class<?> resolvePropertyType(PropertyDescriptor pd); }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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); String getUrlBinding(Class<? extends ActionBean> clazz); String getHandledEvent(Method handler); Class<? extends ActionBean> getActionBeanType(String path); ActionBean getActionBean(ActionBeanContext context); ActionBean getActionBean(ActionBeanContext context, String path); String getEventName(Class<? extends ActionBean> bean, ActionBeanContext context); Method getHandler(Class<? extends ActionBean> bean, String eventName); Method getDefaultHandler(Class<? extends ActionBean> bean); Collection<Class<? extends ActionBean>> getActionBeanClasses(); Class<? extends ActionBean> getActionBeanByName(String 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); String getUrlBinding(Class<? extends ActionBean> clazz); String getHandledEvent(Method handler); Class<? extends ActionBean> getActionBeanType(String path); ActionBean getActionBean(ActionBeanContext context); ActionBean getActionBean(ActionBeanContext context, String path); String getEventName(Class<? extends ActionBean> bean, ActionBeanContext context); Method getHandler(Class<? extends ActionBean> bean, String eventName); Method getDefaultHandler(Class<? extends ActionBean> bean); Collection<Class<? extends ActionBean>> getActionBeanClasses(); Class<? extends ActionBean> getActionBeanByName(String actionBeanName); static final String PACKAGES; }
|
@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); String getUrlBinding(Class<? extends ActionBean> clazz); String getHandledEvent(Method handler); Class<? extends ActionBean> getActionBeanType(String path); ActionBean getActionBean(ActionBeanContext context); ActionBean getActionBean(ActionBeanContext context, String path); String getEventName(Class<? extends ActionBean> bean, ActionBeanContext context); Method getHandler(Class<? extends ActionBean> bean, String eventName); Method getDefaultHandler(Class<? extends ActionBean> bean); Collection<Class<? extends ActionBean>> getActionBeanClasses(); Class<? extends ActionBean> getActionBeanByName(String 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); String getUrlBinding(Class<? extends ActionBean> clazz); String getHandledEvent(Method handler); Class<? extends ActionBean> getActionBeanType(String path); ActionBean getActionBean(ActionBeanContext context); ActionBean getActionBean(ActionBeanContext context, String path); String getEventName(Class<? extends ActionBean> bean, ActionBeanContext context); Method getHandler(Class<? extends ActionBean> bean, String eventName); Method getDefaultHandler(Class<? extends ActionBean> bean); Collection<Class<? extends ActionBean>> getActionBeanClasses(); Class<? extends ActionBean> getActionBeanByName(String actionBeanName); static final String PACKAGES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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 ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); }
|
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 ) || targetType.equals( Float.TYPE ) ) { number = new Float( number.floatValue() ); } else if ( targetType.equals( Double.class ) || targetType.equals( Double.TYPE ) ) { number = new Double( number.doubleValue() ); } else if ( targetType.equals( BigDecimal.class ) ) { number = new BigDecimal( number.doubleValue() ); } else { throw new IllegalArgumentException( "PercentageTypeConverter only converts to float, double and BigDecimal. " + "This is because the input number is always converted to a decimal value. " + "E.g. 99% -> 0.99. Type specified was: " + targetType ); } } return number; } Number convert( String input, Class<? extends Number> targetType, Collection<ValidationError> errors ); static final Pattern PRE_PROCESS_PATTERN; }
|
@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.TestActionBean.class); Assert.assertEquals(binding, net.sourceforge.stripes.test.TestActionBean.class. getAnnotation(UrlBinding.class).value()); }
|
@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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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.assertEquals(viewAttempts.get(1), "/account/viewAccount.jsp"); Assert.assertEquals(viewAttempts.get(2), "/account/view_account.jsp"); }
|
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(), lastPeriod) : urlBinding.substring(path.length()); if (name.length() > 0) { attempts.add(path + name + ".jsp"); name = Character.toLowerCase(name.charAt(0)) + name.substring(1); attempts.add(path + name + ".jsp"); StringBuilder builder = new StringBuilder(); for (int i = 0; i < name.length(); ++i) { char ch = name.charAt(i); if (Character.isUpperCase(ch)) { builder.append("_"); builder.append(Character.toLowerCase(ch)); } else { builder.append(ch); } } attempts.add(path + builder.toString() + ".jsp"); } return attempts; }
|
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 >= path.length()) ? urlBinding.substring(path.length(), lastPeriod) : urlBinding.substring(path.length()); if (name.length() > 0) { attempts.add(path + name + ".jsp"); name = Character.toLowerCase(name.charAt(0)) + name.substring(1); attempts.add(path + name + ".jsp"); StringBuilder builder = new StringBuilder(); for (int i = 0; i < name.length(); ++i) { char ch = name.charAt(i); if (Character.isUpperCase(ch)) { builder.append("_"); builder.append(Character.toLowerCase(ch)); } else { builder.append(ch); } } attempts.add(path + builder.toString() + ".jsp"); } return attempts; } }
|
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 >= path.length()) ? urlBinding.substring(path.length(), lastPeriod) : urlBinding.substring(path.length()); if (name.length() > 0) { attempts.add(path + name + ".jsp"); name = Character.toLowerCase(name.charAt(0)) + name.substring(1); attempts.add(path + name + ".jsp"); StringBuilder builder = new StringBuilder(); for (int i = 0; i < name.length(); ++i) { char ch = name.charAt(i); if (Character.isUpperCase(ch)) { builder.append("_"); builder.append(Character.toLowerCase(ch)); } else { builder.append(ch); } } attempts.add(path + builder.toString() + ".jsp"); } return attempts; } }
|
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 >= path.length()) ? urlBinding.substring(path.length(), lastPeriod) : urlBinding.substring(path.length()); if (name.length() > 0) { attempts.add(path + name + ".jsp"); name = Character.toLowerCase(name.charAt(0)) + name.substring(1); attempts.add(path + name + ".jsp"); StringBuilder builder = new StringBuilder(); for (int i = 0; i < name.length(); ++i) { char ch = name.charAt(i); if (Character.isUpperCase(ch)) { builder.append("_"); builder.append(Character.toLowerCase(ch)); } else { builder.append(ch); } } attempts.add(path + builder.toString() + ".jsp"); } return attempts; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); }
|
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 >= path.length()) ? urlBinding.substring(path.length(), lastPeriod) : urlBinding.substring(path.length()); if (name.length() > 0) { attempts.add(path + name + ".jsp"); name = Character.toLowerCase(name.charAt(0)) + name.substring(1); attempts.add(path + name + ".jsp"); StringBuilder builder = new StringBuilder(); for (int i = 0; i < name.length(); ++i) { char ch = name.charAt(i); if (Character.isUpperCase(ch)) { builder.append("_"); builder.append(Character.toLowerCase(ch)); } else { builder.append(ch); } } attempts.add(path + builder.toString() + ".jsp"); } return attempts; } @Override void init(Configuration configuration); @Override String getUrlBinding(Class<? extends ActionBean> clazz); @Override String getHandledEvent(Method handler); static boolean isAsyncEventHandler(Method handler); @Override ActionBean getActionBean(ActionBeanContext context,
String urlBinding); static final Set<String> BASE_PACKAGES; static final String DEFAULT_BINDING_SUFFIX; static final List<String> DEFAULT_ACTION_BEAN_SUFFIXES; }
|
@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 (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
@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 (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
@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 (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
@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 (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
@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 (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
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 < characters.length; ++i) { if (characters[i] == '.') { builder.append(' '); upcaseNextChar = true; } else if (Character.isUpperCase(characters[i])) { builder.append(' ').append(characters[i]); upcaseNextChar = false; } else if (upcaseNextChar) { builder.append(Character.toUpperCase(characters[i])); upcaseNextChar = false; } else { builder.append(characters[i]); upcaseNextChar = false; } } return builder.toString(); } static String getLocalizedFieldName(String fieldName,
String actionPath,
Class<? extends ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
@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.B.C"); }
|
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 ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
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 ActionBean> beanclass,
Locale locale); static String makePseudoFriendlyName(String fieldNameKey); static String getErrorMessage(Locale locale, String key); static String getSimpleName(Class<?> c); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.