EquivalenceClassTransformer implements DataTransformer { @Override public void transform(DataPipe cr) { Map<String, String> map = cr.getDataMap(); for (Map.Entry<String, String> entry : map.entrySet()) { String value = entry.getValue(); if (value.startsWith("%")) { String macro; String expr; int param = value.indexOf("("); if (param != -1) { macro = value.substring(1, param); expr = value.substring(param + 1, value.length() - 1); } else { macro = value.substring(1); expr = ""; } StringBuilder b = new StringBuilder(); switch (macro) { case "regex": generateFromRegex(b, expr); break; case "alpha": alpha(b, Integer.valueOf(expr)); break; case "alphaWithSpaces": alphaWithSpaces(b, Integer.valueOf(expr)); break; case "number": String[] lengths = expr.split(","); int precision = Integer.valueOf(lengths[0]); int scale = 0; if (lengths.length == 2) { scale = Integer.valueOf(lengths[1]) < 0 ? 0 : Integer.valueOf(lengths[1]); } int wholeDigits = precision - scale < 0 ? 0 : precision - scale; if (wholeDigits == 0 && scale > 0) { b.append("0."); digitSequence(b, scale); } else if (wholeDigits > 0) { b.append(random.nextInt(9) + 1); digitSequence(b, wholeDigits - 1); if (scale > 0) { b.append("."); digitSequence(b, scale); } } break; case "digits": int length = Integer.valueOf(expr); digitSequence(b, length); break; case "ssn": ssn(b); break; case "zip": zip(b); break; case "phoneDomesticUSA": phoneDomesticUSA(b); break; case "phoneDomesticUSAWithExt": phoneDomesticUSAWithExt(b); break; case "currency": b.append(CURRENCY_CODES[random.nextInt(CURRENCY_CODES.length)]); break; case "state": case "stateLong": b.append(STATE_LONG[random.nextInt(STATE_LONG.length)]); break; case "stateShort": b.append(STATES_SHORT[random.nextInt(STATES_SHORT.length)]); break; case "country": case "countryLong": b.append(COUNTRIES[random.nextInt(COUNTRIES.length)]); break; case "symbolNASDAQ": b.append(SYMBOLS_NASDAQ[random.nextInt(SYMBOLS_NASDAQ.length)]); break; case "symbolNotNASDAQ": b.append(SYMBOLS_NOT_NASDAQ[random.nextInt(SYMBOLS_NOT_NASDAQ.length)]); break; case "securityNameNASDAQ": b.append(SECURITY_NAMES_NASDAQ[random.nextInt(SECURITY_NAMES_NASDAQ.length)]); break; case "securityNameNotNASDAQ": b.append(SECURITY_NAMES_NOT_NASDAQ[random.nextInt(SECURITY_NAMES_NOT_NASDAQ.length)]); break; default: b.append(value); break; } entry.setValue(b.toString()); } else if (value.startsWith("$")) { String variable, varValue; int param = value.indexOf("{"); if (param != -1) { variable = value.substring(param + 1, value.length() - 1); } else { variable = value.substring(1); } if (map.containsKey(variable)) { varValue = map.get(variable); } else { varValue = null; } entry.setValue(varValue); } } } EquivalenceClassTransformer(); @Override void transform(DataPipe cr); static final String[] CURRENCY_CODES; static final String[] STATE_LONG; static final String[] STATES_SHORT; static final Holiday[] HOLIDAYS; static final String[] COUNTRIES; static final int COUNT_NASDAQ_SECURITIES; static final String[] SYMBOLS_NASDAQ; static final String[] SECURITY_NAMES_NASDAQ; static final int COUNT_NOT_NASDAQ_SECURITIES; static final String[] SYMBOLS_NOT_NASDAQ; static final String[] SECURITY_NAMES_NOT_NASDAQ; }
@Test public void numberTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); pipeToTransform.getDataMap().put("TEST", "%number(5)"); eqTransformer.transform(pipeToTransform); Pattern alphaWithSpacesPattern = Pattern.compile("^[1-9]{1}[\\d]{4}$"); Matcher didItMatch = alphaWithSpacesPattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); pipeToTransform.getDataMap().put("TEST", "%number(10,10)"); eqTransformer.transform(pipeToTransform); alphaWithSpacesPattern = Pattern.compile("0.[\\d]{10}$"); didItMatch = alphaWithSpacesPattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); pipeToTransform.getDataMap().put("TEST", "%number(10,5)"); eqTransformer.transform(pipeToTransform); alphaWithSpacesPattern = Pattern.compile("^[\\d]{5}.[\\d]{5}$"); System.out.println(pipeToTransform.getDataMap().get("TEST")); didItMatch = alphaWithSpacesPattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); pipeToTransform.getDataMap().put("TEST", "%number(0,0)"); eqTransformer.transform(pipeToTransform); Assert.assertEquals("", pipeToTransform.getDataMap().get("TEST")); pipeToTransform.getDataMap().put("TEST", "%number(0)"); eqTransformer.transform(pipeToTransform); Assert.assertEquals("", pipeToTransform.getDataMap().get("TEST")); }
@Test public void digitsTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); pipeToTransform.getDataMap().put("TEST", "%digits(5)"); eqTransformer.transform(pipeToTransform); Pattern alphaWithSpacesPattern = Pattern.compile("^[\\d]{5}$"); Matcher didItMatch = alphaWithSpacesPattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); pipeToTransform.getDataMap().put("TEST", "%digits(10)"); eqTransformer.transform(pipeToTransform); alphaWithSpacesPattern = Pattern.compile("^[\\d]{10}$"); didItMatch = alphaWithSpacesPattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); pipeToTransform.getDataMap().put("TEST", "%digits(0)"); eqTransformer.transform(pipeToTransform); Assert.assertEquals("", pipeToTransform.getDataMap().get("TEST")); }
@Test public void currencyTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String[] currencyCodes = { "AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BOV", "BRL", "BSD", "BTN", "BWP", "BYR", "BZD", "CAD", "CDF", "CHE", "CHF", "CHW", "CLF", "CLP", "CNY", "COP", "COU", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HRK", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LTL", "LVL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRO", "MUR", "MVR", "MWK", "MXN", "MXV", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLL", "SOS", "SRD", "SSP", "STD", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "USN", "USS", "UYI", "UYU", "UZS", "VEF", "VND", "VUV", "WST", "XAF", "XAG", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XDR", "XFU", "XOF", "XPD", "XPF", "XPT", "XSU", "XTS", "XUA", "XXX", "YER", "ZAR", "ZMK", "ZWL"}; Assert.assertTrue("Too small number of currency codes!", eqTransformer.CURRENCY_CODES.length >= 180); HashSet<String> currencyCodeLookUp = new HashSet<>(Arrays.asList(currencyCodes)); for (int i = 0; i < 500; i++) { pipeToTransform.getDataMap().put("TEST", "%currency"); eqTransformer.transform(pipeToTransform); Assert.assertTrue(currencyCodeLookUp.contains(pipeToTransform.getDataMap().get("TEST"))); } }
@Test public void nonMacrosUnaffectedTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); pipeToTransform.getDataMap().put("TEST", "Lorem ipsum doler sit amet."); pipeToTransform.getDataMap().put("TEST2", "%Lorem"); pipeToTransform.getDataMap().put("TEST3", "%ipsum(1,2)"); eqTransformer.transform(pipeToTransform); Assert.assertEquals("Lorem ipsum doler sit amet.", pipeToTransform.getDataMap().get("TEST")); Assert.assertEquals("%Lorem", pipeToTransform.getDataMap().get("TEST2")); Assert.assertEquals("%ipsum(1,2)", pipeToTransform.getDataMap().get("TEST3")); }
@Test public void statesLongTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String[] statesLong = { "Alabama", "Alaska", "American Samoa", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware", "Dist. of Columbia", "Florida", "Georgia", "Guam", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Marshall Islands", "Massachusetts", "Michigan", "Micronesia", "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Northern Marianas", "Ohio", "Oklahoma", "Oregon", "Palau", "Pennsylvania", "Puerto Rico", "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Virgin Islands", "Washington", "West Virginia", "Wisconsin", "Wyoming"}; Assert.assertTrue("Missed state long name(s)!", EquivalenceClassTransformer.STATE_LONG.length == 59); HashSet<String> statesLongLookUp = new HashSet<>(Arrays.asList(statesLong)); for (int i = 0; i < 500; i++) { pipeToTransform.getDataMap().put("TEST_states", "%state"); eqTransformer.transform(pipeToTransform); Assert.assertTrue("Wrong state name(s)! Have '" + pipeToTransform.getDataMap().get("TEST_states") + "'," + " but wait for one of '" + statesLongLookUp + "'...", statesLongLookUp.contains(pipeToTransform.getDataMap().get("TEST_states"))); } for (int i = 0; i < 500; i++) { pipeToTransform.getDataMap().put("TEST_statesLong", "%stateLong"); eqTransformer.transform(pipeToTransform); Assert.assertTrue("Wrong state long name(s)! Have '" + pipeToTransform.getDataMap().get("TEST_statesLong") + "'," + " but wait for one of '" + statesLongLookUp + "'...", statesLongLookUp.contains(pipeToTransform.getDataMap().get("TEST_statesLong"))); } }
@Test public void statesShortTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String[] statesShort = { "AL", "AK", "AS", "AZ", "AR", "CA", "CO", "CT", "DE", "DC", "FL", "GA", "GU", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MH", "MA", "MI", "FM", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "MP", "OH", "OK", "OR", "PW", "PA", "PR", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "VI", "WA", "WV", "WI", "WY"}; Assert.assertTrue("Missed state short name(s)!", EquivalenceClassTransformer.STATES_SHORT.length == 59); HashSet<String> statesShortLookUp = new HashSet<>(Arrays.asList(statesShort)); for (int i = 0; i < 500; i++) { pipeToTransform.getDataMap().put("TEST_statesShort", "%stateShort"); eqTransformer.transform(pipeToTransform); Assert.assertTrue("Wrong state short name(s)! Have '" + pipeToTransform.getDataMap().get("TEST_statesShort") + "'," + " but wait for one of '" + statesShortLookUp + "'...", statesShortLookUp.contains(pipeToTransform.getDataMap().get("TEST_statesShort"))); } }
@Test public void countryLongTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String[] countryLong = { "Afghanistan", "Albania", "Algeria", "Andorra", "Angola", "Antigua & Barbuda", "Argentina", "Armenia", "Australia", "Austria", "Azerbaijan", "Bahamas", "Bahrain", "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin", "Bhutan", "Bolivia", "Bosnia & Herzegovina", "Botswana", "Brazil", "Brunei", "Bulgaria", "Burkina Faso", "Burundi", "Cambodia", "Cameroon", "Canada", "Cape Verde", "Central African Republic", "Chad", "Chile", "China", "Colombia", "Comoros", "Congo", "Congo Democratic Republic", "Costa Rica", "Cote d'Ivoire", "Croatia", "Cuba", "Cyprus", "Czech Republic", "Denmark", "Djibouti", "Dominica", "Dominican Republic", "Ecuador", "East Timor", "Egypt", "El Salvador", "Equatorial Guinea", "Eritrea", "Estonia", "Ethiopia", "Fiji", "Finland", "France", "Gabon", "Gambia", "Georgia", "Germany", "Ghana", "Greece", "Grenada", "Guatemala", "Guinea", "Guinea-Bissau", "Guyana", "Haiti", "Honduras", "Hungary", "Iceland", "India", "Indonesia", "Iran", "Iraq", "Ireland", "Israel", "Italy", "Jamaica", "Japan", "Jordan", "Kazakhstan", "Kenya", "Kiribati", "Korea North", "Korea South", "Kosovo", "Kuwait", "Kyrgyzstan", "Laos", "Latvia", "Lebanon", "Lesotho", "Liberia", "Libya", "Liechtenstein", "Lithuania", "Luxembourg", "Macedonia", "Madagascar", "Malawi", "Malaysia", "Maldives", "Mali", "Malta", "Marshall Islands", "Mauritania", "Mauritius", "Mexico", "Micronesia", "Moldova", "Monaco", "Mongolia", "Montenegro", "Morocco", "Mozambique", "Myanmar (Burma)", "Namibia", "Nauru", "Nepal", "The Netherlands", "New Zealand", "Nicaragua", "Niger", "Nigeria", "Norway", "Oman", "Pakistan", "Palau", "Palestinian State", "Panama", "Papua New Guinea", "Paraguay", "Peru", "The Philippines", "Poland", "Portugal", "Qatar", "Romania", "Russia", "Rwanda", "St. Kitts & Nevis", "St. Lucia", "St. Vincent & The Grenadines", "Samoa", "San Marino", "Sao Tome & Principe", "Saudi Arabia", "Senegal", "Serbia", "Seychelles", "Sierra Leone", "Singapore", "Slovakia", "Slovenia", "Solomon Islands", "Somalia", "South Africa", "South Sudan", "Spain", "Sri Lanka", "Sudan", "Suriname", "Swaziland", "Sweden", "Switzerland", "Syria", "Taiwan", "Tajikistan", "Tanzania", "Thailand", "Togo", "Tonga", "Trinidad & Tobago", "Tunisia", "Turkey", "Turkmenistan", "Tuvalu", "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom", "United States of America", "Uruguay", "Uzbekistan", "Vanuatu", "Vatican City", "Venezuela", "Vietnam", "Yemen", "Zambia", "Zimbabwe" }; Assert.assertTrue("Missed country long name(s)!", EquivalenceClassTransformer.COUNTRIES.length == 197); HashSet<String> countryLongLookUp = new HashSet<>(Arrays.asList(countryLong)); for (int i = 0; i < 500; i++) { pipeToTransform.getDataMap().put("TEST_country", "%country"); eqTransformer.transform(pipeToTransform); Assert.assertTrue("Wrong country name(s)! Have '" + pipeToTransform.getDataMap().get("TEST_country") + "'," + " but wait for one of '" + countryLongLookUp + "'...", countryLongLookUp.contains(pipeToTransform.getDataMap().get("TEST_country"))); } for (int i = 0; i < 500; i++) { pipeToTransform.getDataMap().put("TEST_countryLong", "%countryLong"); eqTransformer.transform(pipeToTransform); Assert.assertTrue("Wrong country long name(s)! Have '" + pipeToTransform.getDataMap().get("TEST_countryLong") + "'," + " but wait for one of '" + countryLongLookUp + "'...", countryLongLookUp.contains(pipeToTransform.getDataMap().get("TEST_countryLong"))); } }
@Test public void regexCUSIPTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String testRegularExpression = "^\\d{5}(?:[-\\s]\\d{4})?$"; pipeToTransform.getDataMap().put("TEST", "%regex(" + testRegularExpression + ")"); eqTransformer.transform(pipeToTransform); Pattern pattern = Pattern.compile(testRegularExpression); Matcher didItMatch = pattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); }
@Test public void regexNumbersTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String testRegularExpression = "\\d{4}/\\d{2}/\\d{2}-\\d{2}:\\d{2}"; pipeToTransform.getDataMap().put("TEST", "%regex(" + testRegularExpression + ")"); eqTransformer.transform(pipeToTransform); Pattern pattern = Pattern.compile(testRegularExpression); Matcher didItMatch = pattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); }
@Test public void regexDateTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String testRegularExpression = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\\d\\d$"; pipeToTransform.getDataMap().put("TEST", "%regex(" + testRegularExpression + ")"); eqTransformer.transform(pipeToTransform); Pattern pattern = Pattern.compile(testRegularExpression); Matcher didItMatch = pattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); }
@Test public void regexEmailTest() { DataPipe pipeToTransform = new DataPipe(); EquivalenceClassTransformer eqTransformer = new EquivalenceClassTransformer(); String testRegularExpression = "^([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})$"; pipeToTransform.getDataMap().put("TEST", "%regex(" + testRegularExpression + ")"); eqTransformer.transform(pipeToTransform); Pattern pattern = Pattern.compile(testRegularExpression); Matcher didItMatch = pattern.matcher(pipeToTransform.getDataMap().get("TEST")); Assert.assertTrue(didItMatch.matches()); }