diff --git a/pom.xml b/pom.xml index 7910e31..1866689 100644 --- a/pom.xml +++ b/pom.xml @@ -87,18 +87,6 @@ 1.7.32 test - - org.hamcrest - hamcrest - 2.2 - test - - - org.hamcrest - hamcrest-library - 1.3 - test - org.junit.jupiter junit-jupiter @@ -123,6 +111,12 @@ 1.10.1 test + + org.assertj + assertj-core + 3.27.3 + test + @@ -152,14 +146,14 @@ true - org.openrewrite.java.testing.junit5.JUnit4to5Migration + org.openrewrite.java.testing.hamcrest.MigrateHamcrestToAssertJ org.openrewrite.recipe rewrite-testing-frameworks - 3.5.1 + 3.24.0 diff --git a/src/main/resources/en/country.yml b/src/main/resources/en/country.yml index c5d8a55..4756143 100644 --- a/src/main/resources/en/country.yml +++ b/src/main/resources/en/country.yml @@ -4,6 +4,6 @@ en: code2: ['af', 'al', 'dz', 'ad', 'ao', 'ag', 'ar', 'am', 'au', 'at', 'az', 'bs', 'bh', 'bd', 'bb', 'by', 'be', 'bz', 'bj', 'bt', 'bo', 'ba', 'bw', 'br', 'bn', 'bg', 'bf', 'bi', 'cv', 'kh', 'cm', 'ca', 'cf', 'td', 'cl', 'cn', 'co', 'km', 'cg', 'cd', 'cr', 'ci', 'hr', 'cu', 'cy', 'cz', 'dk', 'dj', 'dm', 'do', 'ec', 'eg', 'sv', 'gq', 'er', 'ee', 'sz', 'et', 'fj', 'fi', 'fr', 'ga', 'gm', 'ge', 'de', 'gh', 'gr', 'gd', 'gt', 'gn', 'gw', 'gy', 'ht', 'hn', 'hu', 'is', 'in', 'id', 'ir', 'iq', 'ie', 'il', 'it', 'jm', 'jp', 'jo', 'kz', 'ke', 'ki', 'kp', 'kr', 'kw', 'kg', 'la', 'lv', 'lb', 'ls', 'lr', 'ly', 'li', 'lt', 'lu', 'mk', 'mg', 'mw', 'my', 'mv', 'ml', 'mt', 'mh', 'mr', 'mu', 'mx', 'fm', 'md', 'mc', 'mn', 'me', 'ma', 'mz', 'mm', 'na', 'nr', 'np', 'nl', 'nz', 'ni', 'ne', 'ng', 'no', 'om', 'pk', 'pw', 'pa', 'pg', 'py', 'pe', 'ph', 'pl', 'pt', 'qa', 'ro', 'ru', 'rw', 'kn', 'lc', 'vc', 'ws', 'sm', 'st', 'sa', 'sn', 'rs', 'sc', 'sl', 'sg', 'sk', 'si', 'sb', 'so', 'za', 'ss', 'es', 'lk', 'sd', 'sr', 'se', 'ch', 'sy', 'tj', 'tz', 'th', 'tl', 'tg', 'to', 'tt', 'tn', 'tr', 'tm', 'tv', 'ug', 'ua', 'ae', 'gb', 'us', 'uy', 'uz', 'vu', 've', 'vn', 'ye', 'zm', 'zw'] code3: ['afg', 'alb', 'dza', 'and', 'ago', 'atg', 'arg', 'arm', 'aus', 'aut', 'aze', 'bhs', 'bhr', 'bgd', 'brb', 'blr', 'bel', 'blz', 'ben', 'btn', 'bol', 'bih', 'bwa', 'bra', 'brn', 'bgr', 'bfa', 'bdi', 'cpv', 'khm', 'cmr', 'can', 'caf', 'tcd', 'chl', 'chn', 'col', 'com', 'cog', 'cod', 'cri', 'civ', 'hrv', 'cub', 'cyp', 'cze', 'dnk', 'dji', 'dma', 'dom', 'ecu', 'egy', 'slv', 'gnq', 'eri', 'est', 'swz', 'eth', 'fji', 'fin', 'fra', 'gab', 'gmb', 'geo', 'deu', 'gha', 'grc', 'grd', 'gtm', 'gin', 'gnb', 'guy', 'hti', 'hnd', 'hun', 'isl', 'ind', 'idn', 'irn', 'irq', 'irl', 'isr', 'ita', 'jam', 'jpn', 'jor', 'kaz', 'ken', 'kir', 'prk', 'kor', 'kwt', 'kgz', 'lao', 'lva', 'lbn', 'lso', 'lbr', 'lby', 'lie', 'ltu', 'lux', 'mkd', 'mdg', 'mwi', 'mys', 'mdv', 'mli', 'mlt', 'mhl', 'mrt', 'mus', 'mex', 'fsm', 'mda', 'mco', 'mng', 'mne', 'mar', 'moz', 'mmr', 'nam', 'nru', 'npl', 'nld', 'nzl', 'nic', 'ner', 'nga', 'nor', 'omn', 'pak', 'plw', 'pan', 'png', 'pry', 'per', 'phl', 'pol', 'prt', 'qat', 'rou', 'rus', 'rwa', 'kna', 'lca', 'vct', 'wsm', 'smr', 'stp', 'sau', 'sen', 'srb', 'syc', 'sle', 'sgp', 'svk', 'svn', 'slb', 'som', 'zaf', 'ssd', 'esp', 'lka', 'sdn', 'sur', 'swe', 'che', 'syr', 'tjk', 'tza', 'tha', 'tls', 'tgo', 'ton', 'tto', 'tun', 'tur', 'tkm', 'tuv', 'uga', 'ukr', 'are', 'gbr', 'usa', 'ury', 'uzb', 'vut', 'ven', 'vnm', 'yem', 'zmb', 'zwe'] name: ["Afghanistan", "Albania", "Algeria", "Andorra", "Angola", "Antigua and Barbuda", "Argentina", "Armenia", "Australia", "Austria", "Azerbaijan", "Bahamas", "Bahrain", "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin", "Bhutan", "Bolivia (Plurinational State of)", "Bosnia and Herzegovina", "Botswana", "Brazil", "Brunei Darussalam", "Bulgaria", "Burkina Faso", "Burundi", "Cabo Verde", "Cambodia", "Cameroon", "Canada", "Central African Republic", "Chad", "Chile", "China", "Colombia", "Comoros", "Congo", "Congo, Democratic Republic of the", "Costa Rica", "Côte d'Ivoire", "Croatia", "Cuba", "Cyprus", "Czechia", "Denmark", "Djibouti", "Dominica", "Dominican Republic", "Ecuador", "Egypt", "El Salvador", "Equatorial Guinea", "Eritrea", "Estonia", "Eswatini", "Ethiopia", "Fiji", "Finland", "France", "Gabon", "Gambia", "Georgia", "Germany", "Ghana", "Greece", "Grenada", "Guatemala", "Guinea", "Guinea-Bissau", "Guyana", "Haiti", "Honduras", "Hungary", "Iceland", "India", "Indonesia", "Iran (Islamic Republic of)", "Iraq", "Ireland", "Israel", "Italy", "Jamaica", "Japan", "Jordan", "Kazakhstan", "Kenya", "Kiribati", "Korea (Democratic People's Republic of)", "Korea, Republic of", "Kuwait", "Kyrgyzstan", "Lao People's Democratic Republic", "Latvia", "Lebanon", "Lesotho", "Liberia", "Libya", "Liechtenstein", "Lithuania", "Luxembourg", "Macedonia, the former Yugoslav Republic of", "Madagascar", "Malawi", "Malaysia", "Maldives", "Mali", "Malta", "Marshall Islands", "Mauritania", "Mauritius", "Mexico", "Micronesia (Federated States of)", "Moldova, Republic of", "Monaco", "Mongolia", "Montenegro", "Morocco", "Mozambique", "Myanmar", "Namibia", "Nauru", "Nepal", "Netherlands", "New Zealand", "Nicaragua", "Niger", "Nigeria", "Norway", "Oman", "Pakistan", "Palau", "Panama", "Papua New Guinea", "Paraguay", "Peru", "Philippines", "Poland", "Portugal", "Qatar", "Romania", "Russian Federation", "Rwanda", "Saint Kitts and Nevis", "Saint Lucia", "Saint Vincent and the Grenadines", "Samoa", "San Marino", "Sao Tome and Principe", "Saudi Arabia", "Senegal", "Serbia", "Seychelles", "Sierra Leone", "Singapore", "Slovakia", "Slovenia", "Solomon Islands", "Somalia", "South Africa", "South Sudan", "Spain", "Sri Lanka", "Sudan", "Suriname", "Sweden", "Switzerland", "Syrian Arab Republic", "Tajikistan", "Tanzania, United Republic of", "Thailand", "Timor-Leste", "Togo", "Tonga", "Trinidad and Tobago", "Tunisia", "Turkey", "Turkmenistan", "Tuvalu", "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom of Great Britain and Northern Ireland", "United States of America", "Uruguay", "Uzbekistan", "Vanuatu", "Venezuela (Bolivarian Republic of)", "Viet Nam", "Yemen", "Zambia", "Zimbabwe"] - capital: ["Hargeisa", "King Edward Point", "Port-aux-Fran√ßais", "Jerusalem", "Mariehamn", "Yaren", "Marigot", "Atafu", "El-Aai√∫n", "Kabul", "Tirana", "Algiers", "Pago Pago", "Andorra la Vella", "Luanda", "The Valley", "Saint John's", "Buenos Aires", "Yerevan", "Oranjestad", "Canberra", "Vienna", "Baku", "Nassau", "Manama", "Dhaka", "Bridgetown", "Minsk", "Brussels", "Belmopan", "Porto-Novo", "Hamilton", "Thimphu", "La Paz", "Sarajevo", "Gaborone", "Brasilia", "Road Town", "Bandar Seri Begawan", "Sofia", "Ouagadougou", "Rangoon", "Bujumbura", "Phnom Penh", "Yaounde", "Ottawa", "Praia", "George Town", "Bangui", "N'Djamena", "Santiago", "Beijing", "The Settlement", "West Island", "Bogota", "Moroni", "Kinshasa", "Brazzaville", "Avarua", "San Jose", "Yamoussoukro", "Zagreb", "Havana", "Willemstad", "Nicosia", "Prague", "Copenhagen", "Djibouti", "Roseau", "Santo Domingo", "Quito", "Cairo", "San Salvador", "Malabo", "Asmara", "Tallinn", "Addis Ababa", "Stanley", "Torshavn", "Suva", "Helsinki", "Paris", "Papeete", "Libreville", "Banjul", "Tbilisi", "Berlin", "Accra", "Gibraltar", "Athens", "Nuuk", "Saint George's", "Hagatna", "Guatemala City", "Saint Peter Port", "Conakry", "Bissau", "Georgetown", "Port-au-Prince", "Vatican City", "Tegucigalpa", "Budapest", "Reykjavik", "New Delhi", "Jakarta", "Tehran", "Baghdad", "Dublin", "Douglas", "Jerusalem", "Rome", "Kingston", "Tokyo", "Saint Helier", "Amman", "Astana", "Nairobi", "Tarawa", "Pyongyang", "Seoul", "Pristina", "Kuwait City", "Bishkek", "Vientiane", "Riga", "Beirut", "Maseru", "Monrovia", "Tripoli", "Vaduz", "Vilnius", "Luxembourg", "Skopje", "Antananarivo", "Lilongwe", "Kuala Lumpur", "Male", "Bamako", "Valletta", "Majuro", "Nouakchott", "Port Louis", "Mexico City", "Palikir", "Chisinau", "Monaco", "Ulaanbaatar", "Podgorica", "Plymouth", "Rabat", "Maputo", "Windhoek", "Kathmandu", "Amsterdam", "Noumea", "Wellington", "Managua", "Niamey", "Abuja", "Alofi", "Kingston", "Saipan", "Oslo", "Muscat", "Islamabad", "Melekeok", "Panama City", "Port Moresby", "Asuncion", "Lima", "Manila", "Adamstown", "Warsaw", "Lisbon", "San Juan", "Doha", "Bucharest", "Moscow", "Kigali", "Gustavia", "Jamestown", "Basseterre", "Castries", "Saint-Pierre", "Kingstown", "Apia", "San Marino", "Sao Tome", "Riyadh", "Dakar", "Belgrade", "Victoria", "Freetown", "Singapore", "Philipsburg", "Bratislava", "Ljubljana", "Honiara", "Mogadishu", "Pretoria", "Juba", "Madrid", "Colombo", "Khartoum", "Paramaribo", "Longyearbyen", "Mbabane", "Stockholm", "Bern", "Damascus", "Taipei", "Dushanbe", "Dar es Salaam", "Bangkok", "Dili", "Lome", "Nuku'alofa", "Port of Spain", "Tunis", "Ankara", "Ashgabat", "Grand Turk", "Funafuti", "Kampala", "Kyiv", "Abu Dhabi", "London", "Washington", "Montevideo", "Tashkent", "Port-Vila", "Caracas", "Hanoi", "Charlotte Amalie", "Mata-Utu", "Sanaa", "Lusaka", "Harare", "Washington", "North Nicosia", "Diego Garcia"] + capital: ["Hargeisa", "King Edward Point", "Port-aux-Français", "Jerusalem", "Mariehamn", "Yaren", "Marigot", "Atafu", "El-Ayoun", "Kabul", "Tirana", "Algiers", "Pago Pago", "Andorra la Vella", "Luanda", "The Valley", "Saint John's", "Buenos Aires", "Yerevan", "Oranjestad", "Canberra", "Vienna", "Baku", "Nassau", "Manama", "Dhaka", "Bridgetown", "Minsk", "Brussels", "Belmopan", "Porto-Novo", "Hamilton", "Thimphu", "La Paz", "Sarajevo", "Gaborone", "Brasilia", "Road Town", "Bandar Seri Begawan", "Sofia", "Ouagadougou", "Rangoon", "Bujumbura", "Phnom Penh", "Yaounde", "Ottawa", "Praia", "George Town", "Bangui", "N'Djamena", "Santiago", "Beijing", "The Settlement", "West Island", "Bogota", "Moroni", "Kinshasa", "Brazzaville", "Avarua", "San Jose", "Yamoussoukro", "Zagreb", "Havana", "Willemstad", "Nicosia", "Prague", "Copenhagen", "Djibouti", "Roseau", "Santo Domingo", "Quito", "Cairo", "San Salvador", "Malabo", "Asmara", "Tallinn", "Addis Ababa", "Stanley", "Torshavn", "Suva", "Helsinki", "Paris", "Papeete", "Libreville", "Banjul", "Tbilisi", "Berlin", "Accra", "Gibraltar", "Athens", "Nuuk", "Saint George's", "Hagatna", "Guatemala City", "Saint Peter Port", "Conakry", "Bissau", "Georgetown", "Port-au-Prince", "Vatican City", "Tegucigalpa", "Budapest", "Reykjavik", "New Delhi", "Jakarta", "Tehran", "Baghdad", "Dublin", "Douglas", "Jerusalem", "Rome", "Kingston", "Tokyo", "Saint Helier", "Amman", "Astana", "Nairobi", "Tarawa", "Pyongyang", "Seoul", "Pristina", "Kuwait City", "Bishkek", "Vientiane", "Riga", "Beirut", "Maseru", "Monrovia", "Tripoli", "Vaduz", "Vilnius", "Luxembourg", "Skopje", "Antananarivo", "Lilongwe", "Kuala Lumpur", "Male", "Bamako", "Valletta", "Majuro", "Nouakchott", "Port Louis", "Mexico City", "Palikir", "Chisinau", "Monaco", "Ulaanbaatar", "Podgorica", "Plymouth", "Rabat", "Maputo", "Windhoek", "Kathmandu", "Amsterdam", "Noumea", "Wellington", "Managua", "Niamey", "Abuja", "Alofi", "Kingston", "Saipan", "Oslo", "Muscat", "Islamabad", "Melekeok", "Panama City", "Port Moresby", "Asuncion", "Lima", "Manila", "Adamstown", "Warsaw", "Lisbon", "San Juan", "Doha", "Bucharest", "Moscow", "Kigali", "Gustavia", "Jamestown", "Basseterre", "Castries", "Saint-Pierre", "Kingstown", "Apia", "San Marino", "Sao Tome", "Riyadh", "Dakar", "Belgrade", "Victoria", "Freetown", "Singapore", "Philipsburg", "Bratislava", "Ljubljana", "Honiara", "Mogadishu", "Pretoria", "Juba", "Madrid", "Colombo", "Khartoum", "Paramaribo", "Longyearbyen", "Mbabane", "Stockholm", "Bern", "Damascus", "Taipei", "Dushanbe", "Dar es Salaam", "Bangkok", "Dili", "Lome", "Nuku'alofa", "Port of Spain", "Tunis", "Ankara", "Ashgabat", "Grand Turk", "Funafuti", "Kampala", "Kyiv", "Abu Dhabi", "London", "Washington", "Montevideo", "Tashkent", "Port-Vila", "Caracas", "Hanoi", "Charlotte Amalie", "Mata-Utu", "Sanaa", "Lusaka", "Harare", "Washington", "North Nicosia", "Diego Garcia"] currency: ["Afghani", "Euro", "Lek", "Algerian Dinar", "US Dollar", "Euro", "Kwanza", "East Caribbean Dollar", "No universal currency", "East Caribbean Dollar", "Argentine Peso", "Armenian Dram", "Aruban Florin", "Australian Dollar", "Euro", "Azerbaijan Manat", "Bahamian Dollar", "Bahraini Dinar", "Taka", "Barbados Dollar", "Belarusian Ruble", "Euro", "Belize Dollar", "CFA Franc BCEAO", "Bermudian Dollar", "Indian Rupee", "Ngultrum", "Boliviano", "Mvdol", "US Dollar", "Convertible Mark", "Pula", "Norwegian Krone", "Brazilian Real", "US Dollar", "Brunei Dollar", "Bulgarian Lev", "CFA Franc BCEAO", "Burundi Franc", "Cabo Verde Escudo", "Riel", "CFA Franc BEAC", "Canadian Dollar", "Cayman Islands Dollar", "CFA Franc BEAC", "CFA Franc BEAC", "Chilean Peso", "Unidad de Fomento", "Yuan Renminbi", "Australian Dollar", "Australian Dollar", "Colombian Peso", "Unidad de Valor Real", "Comorian Franc ", "Congolese Franc", "CFA Franc BEAC", "New Zealand Dollar", "Costa Rican Colon", "CFA Franc BCEAO", "Kuna", "Cuban Peso", "Peso Convertible", "Netherlands Antillean Guilder", "Euro", "Czech Koruna", "Danish Krone", "Djibouti Franc", "East Caribbean Dollar", "Dominican Peso", "US Dollar", "Egyptian Pound", "El Salvador Colon", "US Dollar", "CFA Franc BEAC", "Nakfa", "Euro", "Ethiopian Birr", "Euro", "Falkland Islands Pound", "Danish Krone", "Fiji Dollar", "Euro", "Euro", "Euro", "CFP Franc", "Euro", "CFA Franc BEAC", "Dalasi", "Lari", "Euro", "Ghana Cedi", "Gibraltar Pound", "Euro", "Danish Krone", "East Caribbean Dollar", "Euro", "US Dollar", "Quetzal", "Pound Sterling", "Guinean Franc", "CFA Franc BCEAO", "Guyana Dollar", "Gourde", "US Dollar", "Australian Dollar", "Euro", "Lempira", "Hong Kong Dollar", "Forint", "Iceland Krona", "Indian Rupee", "Rupiah", "SDR (Special Drawing Right)", "Iranian Rial", "Iraqi Dinar", "Euro", "Pound Sterling", "New Israeli Sheqel", "Euro", "Jamaican Dollar", "Yen", "Pound Sterling", "Jordanian Dinar", "Tenge", "Kenyan Shilling", "Australian Dollar", "North Korean Won", "Won", "Kuwaiti Dinar", "Som", "Lao Kip", "Euro", "Lebanese Pound", "Loti", "Rand", "Liberian Dollar", "Libyan Dinar", "Swiss Franc", "Euro", "Euro", "Pataca", "Denar", "Malagasy Ariary", "Malawi Kwacha", "Malaysian Ringgit", "Rufiyaa", "CFA Franc BCEAO", "Euro", "US Dollar", "Euro", "Ouguiya", "Mauritius Rupee", "Euro", "ADB Unit of Account", "Mexican Peso", "Mexican Unidad de Inversion (UDI)", "US Dollar", "Moldovan Leu", "Euro", "Tugrik", "Euro", "East Caribbean Dollar", "Moroccan Dirham", "Mozambique Metical", "Kyat", "Namibia Dollar", "Rand", "Australian Dollar", "Nepalese Rupee", "Euro", "CFP Franc", "New Zealand Dollar", "Cordoba Oro", "CFA Franc BCEAO", "Naira", "New Zealand Dollar", "Australian Dollar", "US Dollar", "Norwegian Krone", "Rial Omani", "Pakistan Rupee", "US Dollar", "No universal currency", "Balboa", "US Dollar", "Kina", "Guarani", "Sol", "Philippine Peso", "New Zealand Dollar", "Zloty", "Euro", "US Dollar", "Qatari Rial", "Euro", "Romanian Leu", "Russian Ruble", "Rwanda Franc", "Euro", "Saint Helena Pound", "East Caribbean Dollar", "East Caribbean Dollar", "Euro", "Euro", "East Caribbean Dollar", "Tala", "Euro", "Dobra", "Saudi Riyal", "CFA Franc BCEAO", "Serbian Dinar", "Seychelles Rupee", "Leone", "Singapore Dollar", "Netherlands Antillean Guilder", "Sucre", "Euro", "Euro", "Solomon Islands Dollar", "Somali Shilling", "Rand", "No universal currency", "South Sudanese Pound", "Euro", "Sri Lanka Rupee", "Sudanese Pound", "Surinam Dollar", "Norwegian Krone", "Lilangeni", "Swedish Krona", "Swiss Franc", "WIR Euro", "WIR Franc", "Syrian Pound", "New Taiwan Dollar", "Somoni", "Tanzanian Shilling", "Baht", "US Dollar", "CFA Franc BCEAO", "New Zealand Dollar", "Pa’anga", "Trinidad and Tobago Dollar", "Tunisian Dinar", "Turkish Lira", "Turkmenistan New Manat", "US Dollar", "Australian Dollar", "Uganda Shilling", "Hryvnia", "UAE Dirham", "Pound Sterling", "US Dollar", "US Dollar", "US Dollar (Next day)", "Peso Uruguayo", "Uruguay Peso en Unidades Indexadas (UI)", "Unidad Previsional", "Uzbekistan Sum", "Vatu", "Bolívar Soberano", "Dong", "US Dollar", "US Dollar", "CFP Franc", "Moroccan Dirham", "Yemeni Rial", "Zambian Kwacha", "Zimbabwe Dollar"] currency_code: ["AFN", "EUR", "ALL", "DZD", "USD", "EUR", "AOA", "XCD", "XCD", "ARS", "AMD", "AWG", "AUD", "EUR", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "EUR", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "USD", "BAM", "BWP", "NOK", "BRL", "USD", "BND", "BGN", "XOF", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "XAF", "XAF", "CLP", "CLF", "CNY", "AUD", "AUD", "COP", "COU", "KMF", "CDF", "XAF", "NZD", "CRC", "XOF", "HRK", "CUP", "CUC", "ANG", "EUR", "CZK", "DKK", "DJF", "XCD", "DOP", "USD", "EGP", "SVC", "USD", "XAF", "ERN", "EUR", "ETB", "EUR", "FKP", "DKK", "FJD", "EUR", "EUR", "EUR", "XPF", "EUR", "XAF", "GMD", "GEL", "EUR", "GHS", "GIP", "EUR", "DKK", "XCD", "EUR", "USD", "GTQ", "GBP", "GNF", "XOF", "GYD", "HTG", "USD", "AUD", "EUR", "HNL", "HKD", "HUF", "ISK", "INR", "IDR", "XDR", "IRR", "IQD", "EUR", "GBP", "ILS", "EUR", "JMD", "JPY", "GBP", "JOD", "KZT", "KES", "AUD", "KPW", "KRW", "KWD", "KGS", "LAK", "EUR", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "EUR", "EUR", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "XOF", "EUR", "USD", "EUR", "MRU", "MUR", "EUR", "XUA", "MXN", "MXV", "USD", "MDL", "EUR", "MNT", "EUR", "XCD", "MAD", "MZN", "MMK", "NAD", "ZAR", "AUD", "NPR", "EUR", "XPF", "NZD", "NIO", "XOF", "NGN", "NZD", "AUD", "USD", "NOK", "OMR", "PKR", "USD", "PAB", "USD", "PGK", "PYG", "PEN", "PHP", "NZD", "PLN", "EUR", "USD", "QAR", "EUR", "RON", "RUB", "RWF", "EUR", "SHP", "XCD", "XCD", "EUR", "EUR", "XCD", "WST", "EUR", "STN", "SAR", "XOF", "RSD", "SCR", "SLL", "SGD", "ANG", "XSU", "EUR", "EUR", "SBD", "SOS", "ZAR", "SSP", "EUR", "LKR", "SDG", "SRD", "NOK", "SZL", "SEK", "CHF", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "USD", "XOF", "NZD", "TOP", "TTD", "TND", "TRY", "TMT", "USD", "AUD", "UGX", "UAH", "AED", "GBP", "USD", "USD", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VND", "USD", "USD", "XPF", "MAD", "YER", "ZMW", "ZWL"] diff --git a/src/test/java/org/thejavaguy/javafaker/AddressTest.java b/src/test/java/org/thejavaguy/javafaker/AddressTest.java index 0e07c40..fdf61e7 100644 --- a/src/test/java/org/thejavaguy/javafaker/AddressTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AddressTest.java @@ -1,15 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.emptyString; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.lessThanOrEqualTo; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.IsANumber.isANumber; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.text.DecimalFormatSymbols; import java.util.Locale; @@ -24,13 +15,13 @@ public class AddressTest extends AbstractFakerTest { @Test public void testStreetAddressStartsWithNumber() { final String streetAddressNumber = faker.address().streetAddress(); - assertThat(streetAddressNumber, matchesRegularExpression("[0-9]+ .+")); + assertThat(streetAddressNumber).matches("[0-9]+ .+"); } @Test public void testStreetAddressIsANumber() { final String streetAddressNumber = faker.address().streetAddressNumber(); - assertThat(streetAddressNumber, matchesRegularExpression("[0-9]+")); + assertThat(streetAddressNumber).matches("[0-9]+"); } @Test @@ -39,10 +30,10 @@ public void testLatitude() { Double lat; for (int i = 0; i < 100; i++) { latStr = faker.address().latitude().replace(decimalSeparator, '.'); - assertThat(latStr, isANumber()); + assertThat(latStr).matches("-?\\d+(\\.\\d+)?"); lat = Double.valueOf(latStr); - assertThat("Latitude is less then -90", lat, greaterThanOrEqualTo(-90.0)); - assertThat("Latitude is greater than 90", lat, lessThanOrEqualTo(90.0)); + assertThat(lat).as("Latitude is less then -90").isGreaterThanOrEqualTo(-90.0); + assertThat(lat).as("Latitude is greater than 90").isLessThanOrEqualTo(90.0); } } @@ -52,46 +43,46 @@ public void testLongitude() { Double lon; for (int i = 0; i < 100; i++) { longStr = faker.address().longitude().replace(decimalSeparator, '.'); - assertThat(longStr, isANumber()); + assertThat(longStr).matches("-?\\d+(\\.\\d+)?"); lon = Double.valueOf(longStr); - assertThat("Longitude is less then -180", lon, greaterThanOrEqualTo(-180.0)); - assertThat("Longitude is greater than 180", lon, lessThanOrEqualTo(180.0)); + assertThat(lon).as("Longitude is less then -180").isGreaterThanOrEqualTo(-180.0); + assertThat(lon).as("Longitude is greater than 180").isLessThanOrEqualTo(180.0); } } @Test public void testTimeZone() { - assertThat(faker.address().timeZone(), matchesRegularExpression("[A-Za-z_]+/[A-Za-z_]+[/A-Za-z_]*")); + assertThat(faker.address().timeZone()).matches("[A-Za-z_]+/[A-Za-z_]+[/A-Za-z_]*"); } @Test public void testState() { - assertThat(faker.address().state(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.address().state()).matches("[A-Za-z ]+"); } @Test public void testCity() { - assertThat(faker.address().city(), matchesRegularExpression("[A-Za-z'() ]+")); + assertThat(faker.address().city()).matches("[A-Za-z'() ]+"); } @Test public void testCityName() { - assertThat(faker.address().cityName(), matchesRegularExpression("[A-Za-z'() ]+")); + assertThat(faker.address().cityName()).matches("[A-Za-z'() ]+"); } @Test public void testCountry() { - assertThat(faker.address().country(), matchesRegularExpression("[A-Za-z\\- &.,'()\\d]+")); + assertThat(faker.address().country()).matches("[A-Za-z\\- &.,'()\\d]+"); } @Test public void testCountryCode() { - assertThat(faker.address().countryCode(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.address().countryCode()).matches("[A-Za-z ]+"); } @Test public void testStreetAddressIncludeSecondary() { - assertThat(faker.address().streetAddress(true), is(not(emptyString()))); + assertThat(faker.address().streetAddress(true)).isNotEmpty(); } @Test @@ -99,34 +90,34 @@ public void testCityWithLocaleFranceAndSeed() { long seed = 1L; Faker firstFaker = new Faker(Locale.FRANCE, new Random(seed)); Faker secondFaker = new Faker(Locale.FRANCE, new Random(seed)); - assertThat(firstFaker.address().city(), is(secondFaker.address().city())); + assertThat(firstFaker.address().city()).isEqualTo(secondFaker.address().city()); } @Test public void testFullAddress() { - assertThat(faker.address().fullAddress(), is(not(emptyOrNullString()))); + assertThat(faker.address().fullAddress()).isNotEmpty(); } @Test public void testZipCodeByState() { faker = new Faker(new Locale("en-US")); - assertThat(faker.address().zipCodeByState(faker.address().stateAbbr()), matchesRegularExpression("[0-9]{5}")); + assertThat(faker.address().zipCodeByState(faker.address().stateAbbr())).matches("[0-9]{5}"); } @Test public void testHungarianZipCodeByState() { faker = new Faker(new Locale("hu")); - assertThat(faker.address().zipCodeByState(faker.address().stateAbbr()), matchesRegularExpression("[0-9]{4}")); + assertThat(faker.address().zipCodeByState(faker.address().stateAbbr())).matches("[0-9]{4}"); } @Test public void testCountyByZipCode() { faker = new Faker(new Locale("en-US")); - assertThat(faker.address().countyByZipCode("47732"), is(not(emptyOrNullString()))); + assertThat(faker.address().countyByZipCode("47732")).isNotEmpty(); } @Test public void testStreetPrefix() { - assertThat(faker.address().streetPrefix(), isStringWithContents()); + assertThat(faker.address().streetPrefix()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/AncientTest.java b/src/test/java/org/thejavaguy/javafaker/AncientTest.java index 63e091d..b5a9761 100644 --- a/src/test/java/org/thejavaguy/javafaker/AncientTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AncientTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,22 +8,22 @@ public class AncientTest extends AbstractFakerTest { @Test public void god() { - assertThat(faker.ancient().god(), matchesRegularExpression("\\w+")); + assertThat(faker.ancient().god()).matches("\\w+"); } @Test public void primordial() { - assertThat(faker.ancient().primordial(), matchesRegularExpression("\\w+")); + assertThat(faker.ancient().primordial()).matches("\\w+"); } @Test public void titan() { - assertThat(faker.ancient().titan(), matchesRegularExpression("\\w+")); + assertThat(faker.ancient().titan()).matches("\\w+"); } @Test public void hero() { - assertThat(faker.ancient().hero(), matchesRegularExpression("(?U)\\w+")); + assertThat(faker.ancient().hero()).matches("(?U)\\w+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/AnimalTest.java b/src/test/java/org/thejavaguy/javafaker/AnimalTest.java index 78ac0e3..621edef 100644 --- a/src/test/java/org/thejavaguy/javafaker/AnimalTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AnimalTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,7 +8,7 @@ public class AnimalTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.animal().name(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.animal().name()).matches("[A-Za-z ]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/AppTest.java b/src/test/java/org/thejavaguy/javafaker/AppTest.java index b6ecf26..b805209 100644 --- a/src/test/java/org/thejavaguy/javafaker/AppTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AppTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,16 +8,16 @@ public class AppTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.app().name(), matchesRegularExpression("([\\w-]+ ?)+")); + assertThat(faker.app().name()).matches("([\\w-]+ ?)+"); } @Test public void testVersion() { - assertThat(faker.app().version(), matchesRegularExpression("\\d\\.(\\d){1,2}(\\.\\d)?")); + assertThat(faker.app().version()).matches("\\d\\.(\\d){1,2}(\\.\\d)?"); } @Test public void testAuthor() { - assertThat(faker.app().author(), matchesRegularExpression("([\\w']+[-&,\\.]? ?){2,9}")); + assertThat(faker.app().author()).matches("([\\w']+[-&,\\.]? ?){2,9}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/AquaTeenHungerForceTest.java b/src/test/java/org/thejavaguy/javafaker/AquaTeenHungerForceTest.java index 745c6c5..5b26701 100644 --- a/src/test/java/org/thejavaguy/javafaker/AquaTeenHungerForceTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AquaTeenHungerForceTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,7 +8,7 @@ public class AquaTeenHungerForceTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.aquaTeenHungerForce().character(), matchesRegularExpression("[A-Za-z .]+")); + assertThat(faker.aquaTeenHungerForce().character()).matches("[A-Za-z .]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ArtistTest.java b/src/test/java/org/thejavaguy/javafaker/ArtistTest.java index df6b855..9a2d23f 100644 --- a/src/test/java/org/thejavaguy/javafaker/ArtistTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ArtistTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class ArtistTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.artist().name(), matchesRegularExpression("(\\w+ ?){1,2}")); + assertThat(faker.artist().name()).matches("(\\w+ ?){1,2}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/AvatarTest.java b/src/test/java/org/thejavaguy/javafaker/AvatarTest.java index 73222ca..9148f94 100644 --- a/src/test/java/org/thejavaguy/javafaker/AvatarTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AvatarTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.TestTemplate; import org.thejavaguy.javafaker.repeating.Repeat; @@ -12,6 +11,6 @@ public class AvatarTest extends AbstractFakerTest { @Repeat(times=10) public void testAvatar() { String avatar = faker.avatar().image(); - assertThat(avatar, matchesRegularExpression("^https:\\/\\/s3.amazonaws\\.com\\/uifaces\\/faces\\/twitter\\/[a-zA-Z0-9_]+\\/128\\.jpg$")); + assertThat(avatar).matches("^https:\\/\\/s3.amazonaws\\.com\\/uifaces\\/faces\\/twitter\\/[a-zA-Z0-9_]+\\/128\\.jpg$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/AviationTest.java b/src/test/java/org/thejavaguy/javafaker/AviationTest.java index 85c50b0..2e6286d 100644 --- a/src/test/java/org/thejavaguy/javafaker/AviationTest.java +++ b/src/test/java/org/thejavaguy/javafaker/AviationTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -10,16 +8,16 @@ public class AviationTest extends AbstractFakerTest { @Test public void airport() { - assertThat(faker.aviation().airport(), matchesRegularExpression("\\w{4}")); + assertThat(faker.aviation().airport()).matches("\\w{4}"); } @Test public void aircraft() { - assertThat(faker.aviation().aircraft(), isStringWithContents()); + assertThat(faker.aviation().aircraft()).isNotBlank(); } @Test public void metar() { - assertThat(faker.aviation().METAR(), isStringWithContents()); + assertThat(faker.aviation().METAR()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/BackToTheFutureTest.java b/src/test/java/org/thejavaguy/javafaker/BackToTheFutureTest.java index 338082f..1d1009e 100644 --- a/src/test/java/org/thejavaguy/javafaker/BackToTheFutureTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BackToTheFutureTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -10,16 +8,16 @@ public class BackToTheFutureTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.backToTheFuture().character(), isStringWithContents()); + assertThat(faker.backToTheFuture().character()).isNotBlank(); } @Test public void date() { - assertThat(faker.backToTheFuture().date(), matchesRegularExpression("([A-za-z]{3,8}) ([1-9]|[1-2]\\d|3[0-1]), (18[8-9]\\d|19[0-9]\\d|200\\d|201[0-5])")); + assertThat(faker.backToTheFuture().date()).matches("([A-za-z]{3,8}) ([1-9]|[1-2]\\d|3[0-1]), (18[8-9]\\d|19[0-9]\\d|200\\d|201[0-5])"); } @Test public void quote() { - assertThat(faker.backToTheFuture().quote(), isStringWithContents()); + assertThat(faker.backToTheFuture().quote()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/BarcodeTest.java b/src/test/java/org/thejavaguy/javafaker/BarcodeTest.java index 4daaa81..72e0b0e 100644 --- a/src/test/java/org/thejavaguy/javafaker/BarcodeTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BarcodeTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,20 +8,20 @@ public class BarcodeTest extends AbstractFakerTest { @Test public void type() { - assertThat(faker.barcode().type(), - matchesRegularExpression("(Code(128|39|93))|(E|J)AN(-\\d{1,2})*|Codabar|UCC|UPC(-(A|E))*|IS(B|S)N|ITF|" + + assertThat(faker.barcode().type()).matches( + "(Code(128|39|93))|(E|J)AN(-\\d{1,2})*|Codabar|UCC|UPC(-(A|E))*|IS(B|S)N|ITF|" + "Ames\\sCode|NW-7|Monarch|Code\\s2\\sof\\s7|Rationalized|ANSI\\/AIM BC3-1995|USD-4|" + - "GS1 Databar|MSI Plessey")); + "GS1 Databar|MSI Plessey"); } @Test public void data(){ - assertThat(faker.barcode().data(), matchesRegularExpression("\\d+")); + assertThat(faker.barcode().data()).matches("\\d+"); } @Test public void typeAndData(){ - assertThat(faker.barcode().typeAndData(), matchesRegularExpression("(\\w|\\W)+\\s\\d+$")); + assertThat(faker.barcode().typeAndData()).matches("(\\w|\\W)+\\s\\d+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/BasketballTest.java b/src/test/java/org/thejavaguy/javafaker/BasketballTest.java index 77e5f47..a54a552 100644 --- a/src/test/java/org/thejavaguy/javafaker/BasketballTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BasketballTest.java @@ -1,8 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -11,22 +10,22 @@ public class BasketballTest extends AbstractFakerTest { @Test public void testPositions(){ Faker faker=new Faker(); - assertThat(faker.basketball().positions(),matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); } + assertThat(faker.basketball().positions()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testTeams(){ Faker faker=new Faker(); - assertThat(faker.basketball().teams(),matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); } + assertThat(faker.basketball().teams()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testCoaches(){ Faker faker=new Faker(); - assertThat(faker.basketball().coaches(),matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); } + assertThat(faker.basketball().coaches()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testPlayers(){ Faker faker=new Faker(); - assertThat(faker.basketball().players(),matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); } + assertThat(faker.basketball().players()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testPositionsWith10000Times(){ diff --git a/src/test/java/org/thejavaguy/javafaker/BeerTest.java b/src/test/java/org/thejavaguy/javafaker/BeerTest.java index 74d2393..54131a8 100644 --- a/src/test/java/org/thejavaguy/javafaker/BeerTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BeerTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,26 +8,26 @@ public class BeerTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.beer().name(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.beer().name()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testStyle() { - assertThat(faker.beer().style(), matchesRegularExpression("[A-Za-z'() 0-9-]+")); + assertThat(faker.beer().style()).matches("[A-Za-z'() 0-9-]+"); } @Test public void testHop() { - assertThat(faker.beer().hop(), matchesRegularExpression("[A-Za-z'’()\\. 0-9-]+")); + assertThat(faker.beer().hop()).matches("[A-Za-z'’()\\. 0-9-]+"); } @Test public void testMalt() { - assertThat(faker.beer().malt(), matchesRegularExpression("[A-Za-z'() 0-9-]+")); + assertThat(faker.beer().malt()).matches("[A-Za-z'() 0-9-]+"); } @Test public void testYeast() { - assertThat(faker.beer().yeast(), matchesRegularExpression("[\\p{L}'() 0-9-ö]+")); + assertThat(faker.beer().yeast()).matches("[\\p{L}'() 0-9-ö]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/BojackHorsemanTest.java b/src/test/java/org/thejavaguy/javafaker/BojackHorsemanTest.java index a95f75d..5bdf90b 100644 --- a/src/test/java/org/thejavaguy/javafaker/BojackHorsemanTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BojackHorsemanTest.java @@ -1,9 +1,8 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -12,7 +11,7 @@ public class BojackHorsemanTest extends AbstractFakerTest { @Test public void testCharacters1(){ Faker faker=new Faker(); - assertThat(faker.bojackHorseman().characters(),matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); } + assertThat(faker.bojackHorseman().characters()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testQuotes1(){ diff --git a/src/test/java/org/thejavaguy/javafaker/BookTest.java b/src/test/java/org/thejavaguy/javafaker/BookTest.java index 79edda5..ee7be43 100644 --- a/src/test/java/org/thejavaguy/javafaker/BookTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BookTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,21 +8,21 @@ public class BookTest extends AbstractFakerTest { @Test public void testTitle() { - assertThat(faker.book().title(), matchesRegularExpression("([\\p{L}'\\-\\?]+[!,]? ?){2,9}")); + assertThat(faker.book().title()).matches("([\\p{L}'\\-\\?]+[!,]? ?){2,9}"); } @Test public void testAuthor() { - assertThat(faker.book().author(), matchesRegularExpression("([\\w']+\\.? ?){2,3}")); + assertThat(faker.book().author()).matches("([\\w']+\\.? ?){2,3}"); } @Test public void testPublisher() { - assertThat(faker.book().publisher(), matchesRegularExpression("([\\p{L}'&\\-]+[,.]? ?){1,5}")); + assertThat(faker.book().publisher()).matches("([\\p{L}'&\\-]+[,.]? ?){1,5}"); } @Test public void testGenre() { - assertThat(faker.book().genre(), matchesRegularExpression("([\\w/]+ ?){2,4}")); + assertThat(faker.book().genre()).matches("([\\w/]+ ?){2,4}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/BoolTest.java b/src/test/java/org/thejavaguy/javafaker/BoolTest.java index 94f8197..32e7769 100644 --- a/src/test/java/org/thejavaguy/javafaker/BoolTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BoolTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.oneOf; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,7 +9,7 @@ public class BoolTest extends AbstractFakerTest { @Test public void testBool() { for (int i = 0; i < 100; i++) { - assertThat(faker.bool().bool(), is(oneOf(true, false))); + assertThat(faker.bool().bool()).isIn(true, false); } } } diff --git a/src/test/java/org/thejavaguy/javafaker/BuffyTest.java b/src/test/java/org/thejavaguy/javafaker/BuffyTest.java index e1e30e4..4f07857 100644 --- a/src/test/java/org/thejavaguy/javafaker/BuffyTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BuffyTest.java @@ -1,33 +1,32 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; public class BuffyTest extends AbstractFakerTest { @Test public void testCharacters() { - assertThat(faker.buffy().characters(), isStringWithContents()); + assertThat(faker.buffy().characters()).isNotBlank(); } @Test public void testQuotes() { - assertThat(faker.buffy().quotes(), isStringWithContents()); + assertThat(faker.buffy().quotes()).isNotBlank(); } @Test public void testCelebrities() { - assertThat(faker.buffy().celebrities(), isStringWithContents()); + assertThat(faker.buffy().celebrities()).isNotBlank(); } @Test public void testBigBads() { - assertThat(faker.buffy().bigBads(), isStringWithContents()); + assertThat(faker.buffy().bigBads()).isNotBlank(); } @Test public void testEpisodes() { - assertThat(faker.buffy().episodes(), isStringWithContents()); + assertThat(faker.buffy().episodes()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/BusinessTest.java b/src/test/java/org/thejavaguy/javafaker/BusinessTest.java index 17ad3a5..124beb1 100644 --- a/src/test/java/org/thejavaguy/javafaker/BusinessTest.java +++ b/src/test/java/org/thejavaguy/javafaker/BusinessTest.java @@ -1,24 +1,23 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; public class BusinessTest extends AbstractFakerTest { @Test public void creditCardNumber() { - assertThat(faker.business().creditCardNumber(), isStringWithContents()); + assertThat(faker.business().creditCardNumber()).isNotBlank(); } @Test public void creditCardType() { - assertThat(faker.business().creditCardType(), isStringWithContents()); + assertThat(faker.business().creditCardType()).isNotBlank(); } @Test public void creditCardExpiry() { - assertThat(faker.business().creditCardExpiry(), isStringWithContents()); + assertThat(faker.business().creditCardExpiry()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CatTest.java b/src/test/java/org/thejavaguy/javafaker/CatTest.java index e8fb839..884b4a3 100644 --- a/src/test/java/org/thejavaguy/javafaker/CatTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CatTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,16 +8,16 @@ public class CatTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.cat().name(), matchesRegularExpression("[A-Za-z'() 0-9-]+")); + assertThat(faker.cat().name()).matches("[A-Za-z'() 0-9-]+"); } @Test public void breed() { - assertThat(faker.cat().breed(), matchesRegularExpression("[A-Za-z'() 0-9-,]+")); + assertThat(faker.cat().breed()).matches("[A-Za-z'() 0-9-,]+"); } @Test public void registry() { - assertThat(faker.cat().registry(), matchesRegularExpression("[A-Za-zé'() 0-9-]+")); + assertThat(faker.cat().registry()).matches("[A-Za-zé'() 0-9-]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ChuckNorrisTest.java b/src/test/java/org/thejavaguy/javafaker/ChuckNorrisTest.java index 793d8ea..1637b2e 100644 --- a/src/test/java/org/thejavaguy/javafaker/ChuckNorrisTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ChuckNorrisTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,6 +8,6 @@ public class ChuckNorrisTest extends AbstractFakerTest { @Test public void testFact() { - assertThat(faker.chuckNorris().fact(), is(not(emptyOrNullString()))); + assertThat(faker.chuckNorris().fact()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CodeTest.java b/src/test/java/org/thejavaguy/javafaker/CodeTest.java index 65c88f5..b71efbc 100644 --- a/src/test/java/org/thejavaguy/javafaker/CodeTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CodeTest.java @@ -1,11 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.hamcrest.Matchers.nullValue; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -26,7 +21,7 @@ public void isbn10DefaultIsNoSeparator() { String isbn10 = faker.code().isbn10(); assertIsValidISBN10(isbn10); - assertThat(isbn10, not(containsString("-"))); + assertThat(isbn10).doesNotContain("-"); } @TestTemplate @@ -35,7 +30,7 @@ public void isbn13DefaultIsNoSeparator() { String isbn13 = faker.code().isbn13(); assertIsValidISBN13(isbn13); - assertThat(isbn13, not(containsString("-"))); + assertThat(isbn13).doesNotContain("-"); } @TestTemplate @@ -44,12 +39,12 @@ public void testIsbn10() { final String isbn10NoSep = faker.code().isbn10(false); final String isbn10Sep = faker.code().isbn10(true); - assertThat(isbn10NoSep + " is not null", isbn10NoSep, is(not(nullValue()))); - assertThat(isbn10NoSep + " has length of 10", isbn10NoSep.length(), is(10)); + assertThat(isbn10NoSep).as(isbn10NoSep + " is not null").isNotNull(); + assertThat(isbn10NoSep.length()).as(isbn10NoSep + " has length of 10").isEqualTo(10); assertIsValidISBN10(isbn10NoSep); - assertThat(isbn10Sep + " is not null", isbn10Sep, is(not(nullValue()))); - assertThat(isbn10Sep + " has length of 13", isbn10Sep.length(), is(13)); + assertThat(isbn10Sep).as(isbn10Sep + " is not null").isNotNull(); + assertThat(isbn10Sep.length()).as(isbn10Sep + " has length of 13").isEqualTo(13); assertIsValidISBN10(isbn10Sep); } @@ -59,21 +54,21 @@ public void testIsbn13() { final String isbn13NoSep = faker.code().isbn13(false); final String isbn13Sep = faker.code().isbn13(true); - assertThat(isbn13NoSep + " is not null", isbn13NoSep, is(not(nullValue()))); - assertThat(isbn13NoSep + " has length of 13", isbn13NoSep.length(), is(13)); + assertThat(isbn13NoSep).as(isbn13NoSep + " is not null").isNotNull(); + assertThat(isbn13NoSep.length()).as(isbn13NoSep + " has length of 13").isEqualTo(13); assertIsValidISBN13(isbn13NoSep); - assertThat(isbn13Sep + " is not null", isbn13Sep, is(not(nullValue()))); - assertThat(isbn13Sep + " has length of 17", isbn13Sep.length(), is(17)); + assertThat(isbn13Sep).as(isbn13Sep + " is not null").isNotNull(); + assertThat(isbn13Sep.length()).as(isbn13Sep + " has length of 17").isEqualTo(17); assertIsValidISBN13(isbn13Sep); } private void assertIsValidISBN10(String isbn10) { - assertThat(isbn10 + " is valid", ISBN_VALIDATOR.isValidISBN10(isbn10), is(true)); + assertThat(ISBN_VALIDATOR.isValidISBN10(isbn10)).as(isbn10 + " is valid").isEqualTo(true); } private void assertIsValidISBN13(String isbn13) { - assertThat(isbn13 + " is valid", ISBN_VALIDATOR.isValidISBN13(isbn13), is(true)); + assertThat(ISBN_VALIDATOR.isValidISBN13(isbn13)).as(isbn13 + " is valid").isEqualTo(true); } @TestTemplate @@ -84,49 +79,49 @@ public void testOverrides() { final String isbn10Sep = faker.code().isbn10(true); final String isbn13Sep = faker.code().isbn13(true); - assertThat("Uses overridden expressions from test.yml", - isbn10Sep, - matchesRegularExpression("9971-\\d-\\d{4}-(\\d|X)")); + assertThat(isbn10Sep) + .as("Uses overridden expressions from test.yml") + .matches("9971-\\d-\\d{4}-(\\d|X)"); - assertThat("Uses overridden expressions from test.yml", - isbn13Sep, - matchesRegularExpression("(333|444)-9971-\\d-\\d{4}-\\d")); + assertThat(isbn13Sep) + .as("Uses overridden expressions from test.yml") + .matches("(333|444)-9971-\\d-\\d{4}-\\d"); } @Test public void asin() { - assertThat(faker.code().asin(), matchesRegularExpression("B000([A-Z]|\\d){6}")); + assertThat(faker.code().asin()).matches("B000([A-Z]|\\d){6}"); } @Test public void imei() { String imei = faker.code().imei(); - assertThat(imei, matchesRegularExpression("\\A[\\d\\.\\:\\-\\s]+\\z")); - assertThat(LuhnCheckDigit.LUHN_CHECK_DIGIT.isValid(imei), is(true)); + assertThat(imei).matches("\\A[\\d\\.\\:\\-\\s]+\\z"); + assertThat(LuhnCheckDigit.LUHN_CHECK_DIGIT.isValid(imei)).isEqualTo(true); } @Test public void ean8() { - assertThat(faker.code().ean8(), matchesRegularExpression("\\d{8}")); + assertThat(faker.code().ean8()).matches("\\d{8}"); } @Test public void gtin8() { - assertThat(faker.code().gtin8(), matchesRegularExpression("\\d{8}")); + assertThat(faker.code().gtin8()).matches("\\d{8}"); } @Test public void ean13() { String ean13 = faker.code().ean13(); - assertThat(ean13, matchesRegularExpression("\\d{13}")); - assertThat(EAN13CheckDigit.EAN13_CHECK_DIGIT.isValid(ean13), is(true)); + assertThat(ean13).matches("\\d{13}"); + assertThat(EAN13CheckDigit.EAN13_CHECK_DIGIT.isValid(ean13)).isEqualTo(true); } @Test public void gtin13() { String gtin13 = faker.code().gtin13(); - assertThat(gtin13, matchesRegularExpression("\\d{13}")); - assertThat(EAN13CheckDigit.EAN13_CHECK_DIGIT.isValid(gtin13), is(true)); + assertThat(gtin13).matches("\\d{13}"); + assertThat(EAN13CheckDigit.EAN13_CHECK_DIGIT.isValid(gtin13)).isEqualTo(true); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CoinTest.java b/src/test/java/org/thejavaguy/javafaker/CoinTest.java index 13e40ed..ecef914 100644 --- a/src/test/java/org/thejavaguy/javafaker/CoinTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CoinTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class CoinTest extends AbstractFakerTest { @Test public void coinFlip() { - assertThat(faker.coin().flip(), matchesRegularExpression("\\w+")); + assertThat(faker.coin().flip()).matches("\\w+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ColorTest.java b/src/test/java/org/thejavaguy/javafaker/ColorTest.java index 4addc7c..6d3422c 100644 --- a/src/test/java/org/thejavaguy/javafaker/ColorTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ColorTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,16 +8,16 @@ public class ColorTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.color().name(), matchesRegularExpression("(\\w+ ?){1,2}")); + assertThat(faker.color().name()).matches("(\\w+ ?){1,2}"); } @Test public void testHex() { - assertThat(faker.color().hex(), matchesRegularExpression("^#[0-9A-F]{6}$")); + assertThat(faker.color().hex()).matches("^#[0-9A-F]{6}$"); } @Test public void testHexNoHashSign() { - assertThat(faker.color().hex(false), matchesRegularExpression("^[0-9A-F]{6}$")); + assertThat(faker.color().hex(false)).matches("^[0-9A-F]{6}$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CommerceTest.java b/src/test/java/org/thejavaguy/javafaker/CommerceTest.java index 8de5900..983c947 100644 --- a/src/test/java/org/thejavaguy/javafaker/CommerceTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CommerceTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.text.DecimalFormatSymbols; @@ -17,41 +16,41 @@ public class CommerceTest extends AbstractFakerTest { @Test public void testColor() { - assertThat(faker.commerce().color(), matchesRegularExpression("(\\w+ ?){1,2}")); + assertThat(faker.commerce().color()).matches("(\\w+ ?){1,2}"); } @Test public void testDepartment() { - assertThat(faker.commerce().department(), matchesRegularExpression("(\\w+(, | & )?){1,3}")); + assertThat(faker.commerce().department()).matches("(\\w+(, | & )?){1,3}"); } @Test public void testProductName() { - assertThat(faker.commerce().productName(), matchesRegularExpression("(\\w+ ?){3,4}")); + assertThat(faker.commerce().productName()).matches("(\\w+ ?){3,4}"); } @Test public void testMaterial() { - assertThat(faker.commerce().material(), matchesRegularExpression("\\w+")); + assertThat(faker.commerce().material()).matches("\\w+"); } @Test public void testPrice() { - assertThat(faker.commerce().price(), matchesRegularExpression("\\d{1,3}\\" + decimalSeparator + "\\d{2}")); + assertThat(faker.commerce().price()).matches("\\d{1,3}\\" + decimalSeparator + "\\d{2}"); } @Test public void testPriceMinMax() { - assertThat(faker.commerce().price(100, 1000), matchesRegularExpression("\\d{3,4}\\" + decimalSeparator + "\\d{2}")); + assertThat(faker.commerce().price(100, 1000)).matches("\\d{3,4}\\" + decimalSeparator + "\\d{2}"); } @Test public void testPromotionCode() { - assertThat(faker.commerce().promotionCode(), matchesRegularExpression(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{6}")); + assertThat(faker.commerce().promotionCode()).matches(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{6}"); } @Test public void testPromotionCodeDigits() { - assertThat(faker.commerce().promotionCode(3), matchesRegularExpression(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{3}")); + assertThat(faker.commerce().promotionCode(3)).matches(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{3}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CompanyTest.java b/src/test/java/org/thejavaguy/javafaker/CompanyTest.java index c994a7d..4aeb9ba 100644 --- a/src/test/java/org/thejavaguy/javafaker/CompanyTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CompanyTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,47 +8,47 @@ public class CompanyTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.company().name(), matchesRegularExpression("[A-Za-z\\-&', ]+")); + assertThat(faker.company().name()).matches("[A-Za-z\\-&', ]+"); } @Test public void testSuffix() { - assertThat(faker.company().suffix(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.company().suffix()).matches("[A-Za-z ]+"); } @Test public void testIndustry() { - assertThat(faker.company().industry(), matchesRegularExpression("(\\w+([ ,&/-]{1,3})?){1,4}+")); + assertThat(faker.company().industry()).matches("(\\w+([ ,&/-]{1,3})?){1,4}+"); } @Test public void testBuzzword() { - assertThat(faker.company().buzzword(), matchesRegularExpression("(\\w+[ /-]?){1,3}")); + assertThat(faker.company().buzzword()).matches("(\\w+[ /-]?){1,3}"); } @Test public void testCatchPhrase() { - assertThat(faker.company().catchPhrase(), matchesRegularExpression("(\\w+[ /-]?){1,9}")); + assertThat(faker.company().catchPhrase()).matches("(\\w+[ /-]?){1,9}"); } @Test public void testBs() { - assertThat(faker.company().bs(), matchesRegularExpression("(\\w+[ /-]?){1,9}")); + assertThat(faker.company().bs()).matches("(\\w+[ /-]?){1,9}"); } @Test public void testLogo() { - assertThat(faker.company().logo(), matchesRegularExpression("https://pigment.github.io/fake-logos/logos/medium/color/\\d+\\.png")); + assertThat(faker.company().logo()).matches("https://pigment.github.io/fake-logos/logos/medium/color/\\d+\\.png"); } @Test public void testProfession() { - assertThat(faker.company().profession(), matchesRegularExpression("[a-z ]+")); + assertThat(faker.company().profession()).matches("[a-z ]+"); } @Test public void testUrl() { String regexp = "(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])"; - assertThat(faker.company().url(), matchesRegularExpression(regexp)); + assertThat(faker.company().url()).matches(regexp); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CountryTest.java b/src/test/java/org/thejavaguy/javafaker/CountryTest.java index 147127b..26243eb 100644 --- a/src/test/java/org/thejavaguy/javafaker/CountryTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CountryTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; @@ -14,37 +12,37 @@ public class CountryTest extends AbstractFakerTest { @Repeat(times=10) public void testFlag() { String flag = faker.country().flag(); - assertThat(flag, matchesRegularExpression("^http:\\/\\/flags.fmcdn\\.net\\/data\\/flags\\/w580\\/[a-zA-Z0-9_]+\\.png$")); + assertThat(flag).matches("^http:\\/\\/flags.fmcdn\\.net\\/data\\/flags\\/w580\\/[a-zA-Z0-9_]+\\.png$"); } @Test public void testCode2() { - assertThat(faker.country().countryCode2(), matchesRegularExpression("([a-z]{2})")); + assertThat(faker.country().countryCode2()).matches("([a-z]{2})"); } @Test public void testCode3() { - assertThat(faker.country().countryCode3(), matchesRegularExpression("([a-z]{3})")); + assertThat(faker.country().countryCode3()).matches("([a-z]{3})"); } @Test public void testCapital() { - assertThat(faker.country().capital(), matchesRegularExpression("([\\w'-]+ ?)+")); + assertThat(faker.country().capital()).matches("([\\w'-ç]+ ?)+"); } @Test public void testCurrency() { - assertThat(faker.country().currency(), matchesRegularExpression("([A-Za-zÀ-ÿ'’()-]+ ?)+")); + assertThat(faker.country().currency()).matches("([A-Za-zÀ-ÿ'’()-]+ ?)+"); } @Test public void testCurrencyCode() { - assertThat(faker.country().currencyCode(), matchesRegularExpression("([\\w-’í]+ ?)+")); + assertThat(faker.country().currencyCode()).matches("([\\w-'’í]+ ?)+"); } @Test public void testName() { - assertThat(faker.country().name(), isStringWithContents()); + assertThat(faker.country().name()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CryptoTest.java b/src/test/java/org/thejavaguy/javafaker/CryptoTest.java index ab63fb0..07131fd 100644 --- a/src/test/java/org/thejavaguy/javafaker/CryptoTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CryptoTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -10,21 +9,21 @@ public class CryptoTest extends AbstractFakerTest { @Test public void testMd5() { - assertThat(faker.crypto().md5(), matchesRegularExpression("[a-z\\d]+")); + assertThat(faker.crypto().md5()).matches("[a-z\\d]+"); } @Test public void testSha1() { - assertThat(faker.crypto().sha1(), matchesRegularExpression("[a-z\\d]+")); + assertThat(faker.crypto().sha1()).matches("[a-z\\d]+"); } @Test public void testSha256() { - assertThat(faker.crypto().sha256(), matchesRegularExpression("[a-z\\d]+")); + assertThat(faker.crypto().sha256()).matches("[a-z\\d]+"); } @Test public void testSha512() { - assertThat(faker.crypto().sha512(), matchesRegularExpression("[a-z\\d]+")); + assertThat(faker.crypto().sha512()).matches("[a-z\\d]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/CurrencyTest.java b/src/test/java/org/thejavaguy/javafaker/CurrencyTest.java index 70b1d61..538067e 100644 --- a/src/test/java/org/thejavaguy/javafaker/CurrencyTest.java +++ b/src/test/java/org/thejavaguy/javafaker/CurrencyTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,13 +8,13 @@ public class CurrencyTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.currency().name(), matchesRegularExpression("[\\w\\'\\.\\-\\(\\) ]+")); + assertThat(faker.currency().name()).matches("[\\w\\'\\.\\-\\(\\) ]+"); } @Test public void testCode() { final Currency currency = faker.currency(); - assertThat(currency.code(), matchesRegularExpression("[A-Z]{3}")); + assertThat(currency.code()).matches("[A-Z]{3}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/DateAndTimeTest.java b/src/test/java/org/thejavaguy/javafaker/DateAndTimeTest.java index 1e195d1..d6cb4d5 100644 --- a/src/test/java/org/thejavaguy/javafaker/DateAndTimeTest.java +++ b/src/test/java/org/thejavaguy/javafaker/DateAndTimeTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.lessThanOrEqualTo; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.fail; @@ -26,8 +22,8 @@ public void testFutureDate() { for (int i = 0; i < 1000; i++) { Date future = faker.date().future(1, TimeUnit.SECONDS, now); - assertThat("past date", future.getTime(), greaterThan(now.getTime())); - assertThat("future date over range", future.getTime(), lessThan(now.getTime() + 1000)); + assertThat(future.getTime()).as("past date").isGreaterThan(now.getTime()); + assertThat(future.getTime()).as("future date over range").isLessThan(now.getTime() + 1000); } } @@ -36,9 +32,9 @@ public void testFutureDateWithMinimum(){ for (int i = 0; i < 1000; i++) { Date now = new Date(); Date future = faker.date().future(5, 4, TimeUnit.SECONDS); - assertThat("past date", future.getTime(), greaterThan(now.getTime())); - assertThat("future date over range", future.getTime(), lessThan(now.getTime() + 5001)); - assertThat("future date under minimum range", future.getTime(), greaterThan(now.getTime() + 3999)); + assertThat(future.getTime()).as("past date").isGreaterThan(now.getTime()); + assertThat(future.getTime()).as("future date over range").isLessThan(now.getTime() + 5001); + assertThat(future.getTime()).as("future date under minimum range").isGreaterThan(now.getTime() + 3999); } } @@ -47,9 +43,9 @@ public void testPastDateWithMinimum(){ for (int i = 0; i < 1000; i++) { Date now = new Date(); Date past = faker.date().past(5, 4, TimeUnit.SECONDS); - assertThat("future date", past.getTime(), lessThan(now.getTime())); - assertThat("past date over range", past.getTime(), greaterThan(now.getTime() - 5001)); - assertThat("past date under minimum range", past.getTime(), lessThan(now.getTime() - 3999)); + assertThat(past.getTime()).as("future date").isLessThan(now.getTime()); + assertThat(past.getTime()).as("past date over range").isGreaterThan(now.getTime() - 5001); + assertThat(past.getTime()).as("past date under minimum range").isLessThan(now.getTime() - 3999); } } @@ -59,8 +55,8 @@ public void testPastDateWithReferenceDate() { for (int i = 0; i < 1000; i++) { Date past = faker.date().past(1, TimeUnit.SECONDS, now); - assertThat("past date", past.getTime(), lessThan(now.getTime())); - assertThat("past date over range", past.getTime(), greaterThan(now.getTime() - 1000)); + assertThat(past.getTime()).as("past date").isLessThan(now.getTime()); + assertThat(past.getTime()).as("past date over range").isGreaterThan(now.getTime() - 1000); } } @@ -68,7 +64,7 @@ public void testPastDateWithReferenceDate() { public void testPastDate() { Date now = new Date(); Date past = faker.date().past(100, TimeUnit.SECONDS); - assertThat("past date is in the past", past.getTime(), lessThan(now.getTime())); + assertThat(past.getTime()).as("past date is in the past").isLessThan(now.getTime()); } @Test @@ -78,8 +74,8 @@ public void testBetween() { for (int i = 0; i < 1000; i++) { Date date = faker.date().between(now, then); - assertThat("after upper bound", date.getTime(), lessThan(then.getTime())); - assertThat("before lower bound", date.getTime(), greaterThanOrEqualTo(now.getTime())); + assertThat(date.getTime()).as("after upper bound").isLessThan(then.getTime()); + assertThat(date.getTime()).as("before lower bound").isGreaterThanOrEqualTo(now.getTime()); } } @Test @@ -102,8 +98,8 @@ public void testBirthday() { for (int i = 0; i < 5000; i++) { Date birthday = faker.date().birthday(); - assertThat("birthday is after upper bound", birthday.getTime(), lessThan(to)); - assertThat("birthday is before lower bound", birthday.getTime(), greaterThanOrEqualTo(from)); + assertThat(birthday.getTime()).as("birthday is after upper bound").isLessThan(to); + assertThat(birthday.getTime()).as("birthday is before lower bound").isGreaterThanOrEqualTo(from); } } @@ -121,8 +117,8 @@ public void testBirthdayWithAges() { long to = new GregorianCalendar(currentYear - minAge, currentMonth, currentDay).getTime().getTime(); Date birthday = faker.date().birthday(minAge, maxAge); - assertThat("birthday is after upper bound", birthday.getTime(), lessThanOrEqualTo(to)); - assertThat("birthday is before lower bound", birthday.getTime(), greaterThanOrEqualTo(from)); + assertThat(birthday.getTime()).as("birthday is after upper bound").isLessThanOrEqualTo(to); + assertThat(birthday.getTime()).as("birthday is before lower bound").isGreaterThanOrEqualTo(from); } } diff --git a/src/test/java/org/thejavaguy/javafaker/DemographicTest.java b/src/test/java/org/thejavaguy/javafaker/DemographicTest.java index e588538..2e6c229 100644 --- a/src/test/java/org/thejavaguy/javafaker/DemographicTest.java +++ b/src/test/java/org/thejavaguy/javafaker/DemographicTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,26 +8,26 @@ public class DemographicTest extends AbstractFakerTest { @Test public void race() { - assertThat(faker.demographic().race(), matchesRegularExpression("(\\w+ ?)+")); + assertThat(faker.demographic().race()).matches("(\\w+ ?)+"); } @Test public void educationalAttainment() { - assertThat(faker.demographic().educationalAttainment(), matchesRegularExpression("(?U)([\\w'-]+ ?)+")); + assertThat(faker.demographic().educationalAttainment()).matches("(?U)([\\w'-]+ ?)+"); } @Test public void demonym() { - assertThat(faker.demographic().demonym(), matchesRegularExpression("(?U)([\\w'-]+ ?)+")); + assertThat(faker.demographic().demonym()).matches("(?U)([\\w'-]+ ?)+"); } @Test public void maritalStatus() { - assertThat(faker.demographic().maritalStatus(), matchesRegularExpression("(\\w+ ?)+")); + assertThat(faker.demographic().maritalStatus()).matches("(\\w+ ?)+"); } @Test public void sex() { - assertThat(faker.demographic().sex(), matchesRegularExpression("\\w+")); + assertThat(faker.demographic().sex()).matches("\\w+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/DiseaseTest.java b/src/test/java/org/thejavaguy/javafaker/DiseaseTest.java index c4a4bc2..9a90705 100644 --- a/src/test/java/org/thejavaguy/javafaker/DiseaseTest.java +++ b/src/test/java/org/thejavaguy/javafaker/DiseaseTest.java @@ -1,9 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; @@ -13,43 +11,43 @@ public class DiseaseTest extends AbstractFakerTest { @Test public void testInternalDisease() { Faker faker = new Faker(); - assertThat(faker.disease().internalDisease(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().internalDisease()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testNeurology() { Faker faker = new Faker(); - assertThat(faker.disease().neurology(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().neurology()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testSurgery() { Faker faker = new Faker(); - assertThat(faker.disease().surgery(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().surgery()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testPaediatrics() { Faker faker = new Faker(); - assertThat(faker.disease().paediatrics(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().paediatrics()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testGynecologyAndObstetrics() { Faker faker = new Faker(); - assertThat(faker.disease().gynecologyAndObstetrics(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().gynecologyAndObstetrics()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testOphthalmologyAndOtorhinolaryngology() { Faker faker = new Faker(); - assertThat(faker.disease().ophthalmologyAndOtorhinolaryngology(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().ophthalmologyAndOtorhinolaryngology()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @Test public void testDermatolory() { Faker faker = new Faker(); - assertThat(faker.disease().dermatolory(), matchesRegularExpression("[\\p{L}'()\\., 0-9-’’]+")); + assertThat(faker.disease().dermatolory()).matches("[\\p{L}'()\\., 0-9-’’]+"); } @@ -70,42 +68,42 @@ public void testInternalDiseaseWith10000Times() { @Repeat(times = 10000) public void testNeurologyWith10000Times() { Faker faker = new Faker(); - assertThat(faker.disease().neurology(), isStringWithContents()); + assertThat(faker.disease().neurology()).isNotBlank(); } @TestTemplate @Repeat(times = 10000) public void testSurgeryWith10000Times() { Faker faker = new Faker(); - assertThat(faker.disease().surgery(), isStringWithContents()); + assertThat(faker.disease().surgery()).isNotBlank(); } @TestTemplate @Repeat(times = 10000) public void testPaediatricsWith10000Times() { Faker faker = new Faker(); - assertThat(faker.disease().paediatrics(), isStringWithContents()); + assertThat(faker.disease().paediatrics()).isNotBlank(); } @TestTemplate @Repeat(times = 10000) public void testGynecologyAndObstetricsWith10000Times() { Faker faker = new Faker(); - assertThat(faker.disease().gynecologyAndObstetrics(), isStringWithContents()); + assertThat(faker.disease().gynecologyAndObstetrics()).isNotBlank(); } @TestTemplate @Repeat(times = 10000) public void testOphthalmologyAndOtorhinolaryngologyWith10000Times() { Faker faker = new Faker(); - assertThat(faker.disease().ophthalmologyAndOtorhinolaryngology(), isStringWithContents()); + assertThat(faker.disease().ophthalmologyAndOtorhinolaryngology()).isNotBlank(); } @TestTemplate @Repeat(times = 10000) public void testDermatoloryWith10000Times() { Faker faker = new Faker(); - assertThat(faker.disease().dermatolory(), isStringWithContents()); + assertThat(faker.disease().dermatolory()).isNotBlank(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/DogTest.java b/src/test/java/org/thejavaguy/javafaker/DogTest.java index caf4fe3..ac3d4f3 100644 --- a/src/test/java/org/thejavaguy/javafaker/DogTest.java +++ b/src/test/java/org/thejavaguy/javafaker/DogTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,41 +8,41 @@ public class DogTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.dog().name(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().name()).matches("[A-Za-z ]+"); } @Test public void breed() { - assertThat(faker.dog().breed(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().breed()).matches("[A-Za-z ]+"); } @Test public void sound() { - assertThat(faker.dog().sound(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().sound()).matches("[A-Za-z ]+"); } @Test public void memePhrase() { - assertThat(faker.dog().memePhrase(), matchesRegularExpression("[A-Za-z0-9'\\/ ]+")); + assertThat(faker.dog().memePhrase()).matches("[A-Za-z0-9'\\/ ]+"); } @Test public void age() { - assertThat(faker.dog().age(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().age()).matches("[A-Za-z ]+"); } @Test public void gender() { - assertThat(faker.dog().gender(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().gender()).matches("[A-Za-z ]+"); } @Test public void coatLength() { - assertThat(faker.dog().coatLength(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().coatLength()).matches("[A-Za-z ]+"); } @Test public void size() { - assertThat(faker.dog().size(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dog().size()).matches("[A-Za-z ]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/DragonBallTest.java b/src/test/java/org/thejavaguy/javafaker/DragonBallTest.java index 59f7b27..3028c69 100644 --- a/src/test/java/org/thejavaguy/javafaker/DragonBallTest.java +++ b/src/test/java/org/thejavaguy/javafaker/DragonBallTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class DragonBallTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.dragonBall().character(), matchesRegularExpression("^(\\w+\\.?\\s?-?)+$")); + assertThat(faker.dragonBall().character()).matches("^(\\w+\\.?\\s?-?)+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/DuneTest.java b/src/test/java/org/thejavaguy/javafaker/DuneTest.java index 889753f..7586643 100644 --- a/src/test/java/org/thejavaguy/javafaker/DuneTest.java +++ b/src/test/java/org/thejavaguy/javafaker/DuneTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; @@ -11,43 +10,41 @@ public class DuneTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.dune().character(), matchesRegularExpression("[A-Za-z '\\-\"]+")); + assertThat(faker.dune().character()).matches("[A-Za-z '\\-\"]+"); } @Test public void title() { - assertThat(faker.dune().title(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dune().title()).matches("[A-Za-z ]+"); } @Test public void planet() { - assertThat(faker.dune().planet(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.dune().planet()).matches("[A-Za-z ]+"); } @Test public void quote() { - assertThat(faker.dune().quote(), matchesRegularExpression("\\P{Cc}+")); + assertThat(faker.dune().quote()).matches("\\P{Cc}+"); } @TestTemplate @Repeat(times = 10000) public void randomQuote() { assertThat( - faker.dune().quote(faker.options().option(Dune.Quote.class)), - matchesRegularExpression("\\P{Cc}+")); + faker.dune().quote(faker.options().option(Dune.Quote.class))).matches("\\P{Cc}+"); } @Test public void saying() { - assertThat(faker.dune().saying(), matchesRegularExpression("\\P{Cc}+")); + assertThat(faker.dune().saying()).matches("\\P{Cc}+"); } @TestTemplate @Repeat(times = 10000) public void randomSaying() { assertThat( - faker.dune().saying(faker.options().option(Dune.Saying.class)), - matchesRegularExpression("\\P{Cc}+")); + faker.dune().saying(faker.options().option(Dune.Saying.class))).matches("\\P{Cc}+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/EducatorTest.java b/src/test/java/org/thejavaguy/javafaker/EducatorTest.java index dbd2019..5c6244e 100644 --- a/src/test/java/org/thejavaguy/javafaker/EducatorTest.java +++ b/src/test/java/org/thejavaguy/javafaker/EducatorTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,21 +8,21 @@ public class EducatorTest extends AbstractFakerTest { @Test public void testUniversity() { - assertThat(faker.educator().university(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.educator().university()).matches("(\\w+ ?){2,3}"); } @Test public void testCourse() { - assertThat(faker.educator().course(), matchesRegularExpression("(\\(?\\w+\\)? ?){3,6}")); + assertThat(faker.educator().course()).matches("(\\(?\\w+\\)? ?){3,6}"); } @Test public void testSecondarySchool() { - assertThat(faker.educator().secondarySchool(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.educator().secondarySchool()).matches("(\\w+ ?){2,3}"); } @Test public void testCampus() { - assertThat(faker.educator().campus(), matchesRegularExpression("(\\w+ ?){1,2}")); + assertThat(faker.educator().campus()).matches("(\\w+ ?){1,2}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ElderScrollsTest.java b/src/test/java/org/thejavaguy/javafaker/ElderScrollsTest.java index 7027564..17d4f1a 100644 --- a/src/test/java/org/thejavaguy/javafaker/ElderScrollsTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ElderScrollsTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,41 +8,41 @@ public class ElderScrollsTest extends AbstractFakerTest { @Test public void testCity() { - assertThat(faker.elderScrolls().city(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().city()).isNotEmpty(); } @Test public void testCreature() { - assertThat(faker.elderScrolls().creature(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().creature()).isNotEmpty(); } @Test public void testDragon() { - assertThat(faker.elderScrolls().dragon(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().dragon()).isNotEmpty(); } @Test public void testFirstName() { - assertThat(faker.elderScrolls().firstName(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().firstName()).isNotEmpty(); } @Test public void testLastName() { - assertThat(faker.elderScrolls().lastName(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().lastName()).isNotEmpty(); } @Test public void testRace() { - assertThat(faker.elderScrolls().race(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().race()).isNotEmpty(); } @Test public void testRegion() { - assertThat(faker.elderScrolls().region(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().region()).isNotEmpty(); } @Test public void testQuote() { - assertThat(faker.elderScrolls().quote(), is(not(emptyOrNullString()))); + assertThat(faker.elderScrolls().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/EnglandFootBallTest.java b/src/test/java/org/thejavaguy/javafaker/EnglandFootBallTest.java index 0865461..5e0eda1 100644 --- a/src/test/java/org/thejavaguy/javafaker/EnglandFootBallTest.java +++ b/src/test/java/org/thejavaguy/javafaker/EnglandFootBallTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,12 +8,12 @@ public class EnglandFootBallTest extends AbstractFakerTest{ @Test public void testLeague() { String league = faker.englandfootball().league(); - assertThat(league, is(not(emptyOrNullString()))); + assertThat(league).isNotEmpty(); } @Test public void testTeam() { String team = faker.englandfootball().team(); - assertThat(team, is(not(emptyOrNullString()))); + assertThat(team).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/EsportsTest.java b/src/test/java/org/thejavaguy/javafaker/EsportsTest.java index 1b8d38a..b2b5cc6 100644 --- a/src/test/java/org/thejavaguy/javafaker/EsportsTest.java +++ b/src/test/java/org/thejavaguy/javafaker/EsportsTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,26 +8,26 @@ public class EsportsTest extends AbstractFakerTest { @Test public void player() { - assertThat(faker.esports().player(), matchesRegularExpression("(\\w|.)+")); + assertThat(faker.esports().player()).matches("(\\w|.)+"); } @Test public void team() { - assertThat(faker.esports().team(), matchesRegularExpression("((\\w|.)+ ?)+")); + assertThat(faker.esports().team()).matches("((\\w|.)+ ?)+"); } @Test public void event() { - assertThat(faker.esports().event(), matchesRegularExpression("(\\w+ ?)+")); + assertThat(faker.esports().event()).matches("(\\w+ ?)+"); } @Test public void league() { - assertThat(faker.esports().league(), matchesRegularExpression("\\w+")); + assertThat(faker.esports().league()).matches("\\w+"); } @Test public void game() { - assertThat(faker.esports().game(), matchesRegularExpression("([\\w:.]+ ?)+")); + assertThat(faker.esports().game()).matches("([\\w:.]+ ?)+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/FakerTest.java b/src/test/java/org/thejavaguy/javafaker/FakerTest.java index ebd5f96..fdeefa8 100644 --- a/src/test/java/org/thejavaguy/javafaker/FakerTest.java +++ b/src/test/java/org/thejavaguy/javafaker/FakerTest.java @@ -1,13 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyString; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import java.util.Locale; import java.util.Random; @@ -20,97 +14,97 @@ public class FakerTest extends AbstractFakerTest { @Test public void bothifyShouldGenerateLettersAndNumbers() { - assertThat(faker.bothify("????##@gmail.com"), matchesRegularExpression("\\w{4}\\d{2}@gmail.com")); + assertThat(faker.bothify("????##@gmail.com")).matches("\\w{4}\\d{2}@gmail.com"); } @Test public void letterifyShouldGenerateLetters() { - assertThat(faker.bothify("????"), matchesRegularExpression("\\w{4}")); + assertThat(faker.bothify("????")).matches("\\w{4}"); } @Test public void letterifyShouldGenerateUpperCaseLetters() { - assertThat(faker.bothify("????",true), matchesRegularExpression("[A-Z]{4}")); + assertThat(faker.bothify("????",true)).matches("[A-Z]{4}"); } @Test public void letterifyShouldLeaveNonSpecialCharactersAlone() { - assertThat(faker.bothify("ABC????DEF"), matchesRegularExpression("ABC\\w{4}DEF")); + assertThat(faker.bothify("ABC????DEF")).matches("ABC\\w{4}DEF"); } @Test public void numerifyShouldGenerateNumbers() { - assertThat(faker.numerify("####"), matchesRegularExpression("\\d{4}")); + assertThat(faker.numerify("####")).matches("\\d{4}"); } @Test public void numerifyShouldLeaveNonSpecialCharactersAlone() { - assertThat(faker.numerify("####123"), matchesRegularExpression("\\d{4}123")); + assertThat(faker.numerify("####123")).matches("\\d{4}123"); } @Test public void regexifyShouldGenerateNumbers() { - assertThat(faker.regexify("\\d"), matchesRegularExpression("\\d")); + assertThat(faker.regexify("\\d")).matches("\\d"); } @Test public void regexifyShouldGenerateLetters() { - assertThat(faker.regexify("\\w"), matchesRegularExpression("\\w")); + assertThat(faker.regexify("\\w")).matches("\\w"); } @Test public void regexifyShouldGenerateAlternations() { - assertThat(faker.regexify("(a|b)"), matchesRegularExpression("(a|b)")); + assertThat(faker.regexify("(a|b)")).matches("(a|b)"); } @Test public void regexifyShouldGenerateBasicCharacterClasses() { - assertThat(faker.regexify("(aeiou)"), matchesRegularExpression("(aeiou)")); + assertThat(faker.regexify("(aeiou)")).matches("(aeiou)"); } @Test public void regexifyShouldGenerateCharacterClassRanges() { - assertThat(faker.regexify("[a-z]"), matchesRegularExpression("[a-z]")); + assertThat(faker.regexify("[a-z]")).matches("[a-z]"); } @Test public void regexifyShouldGenerateMultipleCharacterClassRanges() { - assertThat(faker.regexify("[a-z1-9]"), matchesRegularExpression("[a-z1-9]")); + assertThat(faker.regexify("[a-z1-9]")).matches("[a-z1-9]"); } @Test public void regexifyShouldGenerateSingleCharacterQuantifiers() { - assertThat(faker.regexify("a*b+c?"), matchesRegularExpression("a*b+c?")); + assertThat(faker.regexify("a*b+c?")).matches("a*b+c?"); } @Test public void regexifyShouldGenerateBracketsQuantifiers() { - assertThat(faker.regexify("a{2}"), matchesRegularExpression("a{2}")); + assertThat(faker.regexify("a{2}")).matches("a{2}"); } @Test public void regexifyShouldGenerateMinMaxQuantifiers() { - assertThat(faker.regexify("a{2,3}"), matchesRegularExpression("a{2,3}")); + assertThat(faker.regexify("a{2,3}")).matches("a{2,3}"); } @Test public void regexifyShouldGenerateBracketsQuantifiersOnBasicCharacterClasses() { - assertThat(faker.regexify("[aeiou]{2,3}"), matchesRegularExpression("[aeiou]{2,3}")); + assertThat(faker.regexify("[aeiou]{2,3}")).matches("[aeiou]{2,3}"); } @Test public void regexifyShouldGenerateBracketsQuantifiersOnCharacterClassRanges() { - assertThat(faker.regexify("[a-z]{2,3}"), matchesRegularExpression("[a-z]{2,3}")); + assertThat(faker.regexify("[a-z]{2,3}")).matches("[a-z]{2,3}"); } @Test public void regexifyShouldGenerateBracketsQuantifiersOnAlternations() { - assertThat(faker.regexify("(a|b){2,3}"), matchesRegularExpression("(a|b){2,3}")); + assertThat(faker.regexify("(a|b){2,3}")).matches("(a|b){2,3}"); } @Test public void regexifyShouldGenerateEscapedCharacters() { - assertThat(faker.regexify("\\.\\*\\?\\+"), matchesRegularExpression("\\.\\*\\?\\+")); + assertThat(faker.regexify("\\.\\*\\?\\+")).matches("\\.\\*\\?\\+"); } @Test @@ -133,20 +127,20 @@ public void badExpressionCouldntCoerce() { @Test public void expression() { - assertThat(faker.expression("#{regexify '(a|b){2,3}'}"), matchesRegularExpression("(a|b){2,3}")); - assertThat(faker.expression("#{regexify '\\.\\*\\?\\+'}"), matchesRegularExpression("\\.\\*\\?\\+")); - assertThat(faker.expression("#{bothify '????','true'}"), matchesRegularExpression("[A-Z]{4}")); - assertThat(faker.expression("#{bothify '????','false'}"), matchesRegularExpression("[a-z]{4}")); - assertThat(faker.expression("#{letterify '????','true'}"), matchesRegularExpression("[A-Z]{4}")); - assertThat(faker.expression("#{Name.first_name} #{Name.first_name} #{Name.last_name}"), matchesRegularExpression("[a-zA-Z']+ [a-zA-Z']+ [a-zA-Z']+")); - assertThat(faker.expression("#{number.number_between '1','10'}"), matchesRegularExpression("[1-9]")); - assertThat(faker.expression("#{color.name}"), matchesRegularExpression("[a-z\\s]+")); + assertThat(faker.expression("#{regexify '(a|b){2,3}'}")).matches("(a|b){2,3}"); + assertThat(faker.expression("#{regexify '\\.\\*\\?\\+'}")).matches("\\.\\*\\?\\+"); + assertThat(faker.expression("#{bothify '????','true'}")).matches("[A-Z]{4}"); + assertThat(faker.expression("#{bothify '????','false'}")).matches("[a-z]{4}"); + assertThat(faker.expression("#{letterify '????','true'}")).matches("[A-Z]{4}"); + assertThat(faker.expression("#{Name.first_name} #{Name.first_name} #{Name.last_name}")).matches("[a-zA-Z']+ [a-zA-Z']+ [a-zA-Z']+"); + assertThat(faker.expression("#{number.number_between '1','10'}")).matches("[1-9]"); + assertThat(faker.expression("#{color.name}")).matches("[a-z\\s]+"); } @TestTemplate @Repeat(times = 100) public void numberBetweenRepeated() { - assertThat(faker.expression("#{number.number_between '1','10'}"), matchesRegularExpression("[1-9]")); + assertThat(faker.expression("#{number.number_between '1','10'}")).matches("[1-9]"); } @Test @@ -157,27 +151,27 @@ public void regexifyShouldGenerateSameValueForFakerWithSameSeed() { String firstResult = new Faker(new Random(seed)).regexify(regex); String secondResult = new Faker(new Random(seed)).regexify(regex); - assertThat(secondResult, is(firstResult)); + assertThat(secondResult).isEqualTo(firstResult); } @Test public void resolveShouldReturnValueThatExists() { - assertThat(faker.resolve("address.city_prefix"), is(not(emptyString()))); + assertThat(faker.resolve("address.city_prefix")).isNotEmpty(); } @Test public void resolveShouldThrowExceptionWhenPropertyDoesntExist() { assertThrows(RuntimeException.class, () -> { final String resolve = faker.resolve("address.nothing"); - assertThat(resolve, is(nullValue())); + assertThat(resolve).isNull(); }); } @Test public void fakerInstanceCanBeAcquiredViaUtilityMethods() { - assertThat(Faker.instance(), is(instanceOf(Faker.class))); - assertThat(Faker.instance(Locale.CANADA), is(instanceOf(Faker.class))); - assertThat(Faker.instance(new Random(1)), is(instanceOf(Faker.class))); - assertThat(Faker.instance(Locale.CHINA, new Random(2)), is(instanceOf(Faker.class))); + assertThat(Faker.instance()).isInstanceOf(Faker.class); + assertThat(Faker.instance(Locale.CANADA)).isInstanceOf(Faker.class); + assertThat(Faker.instance(new Random(1))).isInstanceOf(Faker.class); + assertThat(Faker.instance(Locale.CHINA, new Random(2))).isInstanceOf(Faker.class); } } diff --git a/src/test/java/org/thejavaguy/javafaker/FileTest.java b/src/test/java/org/thejavaguy/javafaker/FileTest.java index 6014df7..356142c 100644 --- a/src/test/java/org/thejavaguy/javafaker/FileTest.java +++ b/src/test/java/org/thejavaguy/javafaker/FileTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; @@ -12,43 +11,42 @@ public class FileTest extends AbstractFakerTest { @TestTemplate @Repeat(times=10) public void testExtension() { - assertThat(faker.file().extension(), - matchesRegularExpression("(flac|mp3|wav|bmp|gif|jpeg|jpg|png|tiff|css|csv|html|js|json|txt|mp4|avi|mov|webm|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odp|pages|numbers|key|pdf)")); + assertThat(faker.file().extension()).matches("(flac|mp3|wav|bmp|gif|jpeg|jpg|png|tiff|css|csv|html|js|json|txt|mp4|avi|mov|webm|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odp|pages|numbers|key|pdf)"); } @TestTemplate @Repeat(times=10) public void testMimeTypeFormat() { - assertThat(faker.file().mimeType(), matchesRegularExpression(".+\\/.+")); + assertThat(faker.file().mimeType()).matches(".+\\/.+"); } @TestTemplate @Repeat(times=10) public void testFileName() { - assertThat(faker.file().fileName(), matchesRegularExpression("([a-z\\-_]+)(\\\\|\\/)([a-z\\-_]+)\\.([a-z0-9]+)")); + assertThat(faker.file().fileName()).matches("([a-z\\-_]+)(\\\\|\\/)([a-z\\-_]+)\\.([a-z0-9]+)"); } @Test public void testFileNameSpecifyExtension() { - assertThat(faker.file().fileName(null, null, "txt", null), - matchesRegularExpression("([a-z\\-_]+)(\\\\|\\/)([a-z\\-_]+)\\.txt")); + assertThat(faker.file().fileName(null, null, "txt", null)) + .matches("([a-z\\-_]+)(\\\\|\\/)([a-z\\-_]+)\\.txt"); } @Test public void testFileNameSpecifyDir() { - assertThat(faker.file().fileName("my_dir", null, null, null), - matchesRegularExpression("my_dir(\\\\|\\/)([a-z\\-_]+)\\.([a-z0-9]+)")); + assertThat(faker.file().fileName("my_dir", null, null, null)) + .matches("my_dir(\\\\|\\/)([a-z\\-_]+)\\.([a-z0-9]+)"); } @Test public void testFileNameSpecifySeparator() { - assertThat(faker.file().fileName(null,null,null,"\\"), - matchesRegularExpression("([a-z\\-_]+)\\\\([a-z\\-_]+)\\.([a-z0-9]+)")); + assertThat(faker.file().fileName(null,null,null,"\\")) + .matches("([a-z\\-_]+)\\\\([a-z\\-_]+)\\.([a-z0-9]+)"); } @Test public void testFileNameSpecifyName() { - assertThat(faker.file().fileName(null,"da_name",null,null), - matchesRegularExpression("([a-z\\-_]+)(\\\\|\\/)da_name\\.([a-z0-9]+)")); + assertThat(faker.file().fileName(null,"da_name",null,null)) + .matches("([a-z\\-_]+)(\\\\|\\/)da_name\\.([a-z0-9]+)"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/FinanceTest.java b/src/test/java/org/thejavaguy/javafaker/FinanceTest.java index e09be4f..03b0cd7 100644 --- a/src/test/java/org/thejavaguy/javafaker/FinanceTest.java +++ b/src/test/java/org/thejavaguy/javafaker/FinanceTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.apache.commons.validator.routines.checkdigit.LuhnCheckDigit; import org.junit.jupiter.api.Test; @@ -19,22 +17,22 @@ public void creditCard() { private void assertCardLuhnDigit(String creditCard) { final String creditCardStripped = creditCard.replaceAll("-", ""); - assertThat(LuhnCheckDigit.LUHN_CHECK_DIGIT.isValid(creditCardStripped), is(true)); + assertThat(LuhnCheckDigit.LUHN_CHECK_DIGIT.isValid(creditCardStripped)).isEqualTo(true); } @Test public void bic() { - assertThat(faker.finance().bic(), matchesRegularExpression("([A-Z]){4}([A-Z]){2}([0-9A-Z]){2}([0-9A-Z]{3})?")); + assertThat(faker.finance().bic()).matches("([A-Z]){4}([A-Z]){2}([0-9A-Z]){2}([0-9A-Z]{3})?"); } @Test public void iban() { - assertThat(faker.finance().iban(), matchesRegularExpression("[A-Z]{2}\\p{Alnum}{13,30}")); + assertThat(faker.finance().iban()).matches("[A-Z]{2}\\p{Alnum}{13,30}"); } @Test public void ibanWithCountryCode() { - assertThat(faker.finance().iban("DE"), matchesRegularExpression("DE\\d{20}")); + assertThat(faker.finance().iban("DE")).matches("DE\\d{20}"); } @Test diff --git a/src/test/java/org/thejavaguy/javafaker/FoodTest.java b/src/test/java/org/thejavaguy/javafaker/FoodTest.java index 11cae1c..6adb439 100644 --- a/src/test/java/org/thejavaguy/javafaker/FoodTest.java +++ b/src/test/java/org/thejavaguy/javafaker/FoodTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,36 +8,36 @@ public class FoodTest extends AbstractFakerTest { @Test public void ingredient() { - assertThat(faker.food().ingredient(), matchesRegularExpression("[A-Za-z- ]+")); + assertThat(faker.food().ingredient()).matches("[A-Za-z- ]+"); } @Test public void spice() { - assertThat(faker.food().spice(), matchesRegularExpression("[A-Za-z1-9- ]+")); + assertThat(faker.food().spice()).matches("[A-Za-z1-9- ]+"); } @Test public void dish() { - assertThat(faker.food().dish(), matchesRegularExpression("\\P{Cc}+")); + assertThat(faker.food().dish()).matches("\\P{Cc}+"); } @Test public void fruit() { - assertThat(faker.food().fruit(), matchesRegularExpression("[A-Za-z1-9- ]+")); + assertThat(faker.food().fruit()).matches("[A-Za-z1-9- ]+"); } @Test public void vegetable() { - assertThat(faker.food().vegetable(), matchesRegularExpression("[A-Za-z1-9- ]+")); + assertThat(faker.food().vegetable()).matches("[A-Za-z1-9- ]+"); } @Test public void sushi() { - assertThat(faker.food().sushi(), matchesRegularExpression("[A-Za-z1-9- ]+")); + assertThat(faker.food().sushi()).matches("[A-Za-z1-9- ]+"); } @Test public void measurement() { - assertThat(faker.food().measurement(), matchesRegularExpression("[A-Za-z1-9/ ]+{2}")); + assertThat(faker.food().measurement()).matches("[A-Za-z1-9/ ]+{2}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/FriendsTest.java b/src/test/java/org/thejavaguy/javafaker/FriendsTest.java index 714cf83..4b01fed 100644 --- a/src/test/java/org/thejavaguy/javafaker/FriendsTest.java +++ b/src/test/java/org/thejavaguy/javafaker/FriendsTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,16 +8,16 @@ public class FriendsTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.friends().character(), matchesRegularExpression("[A-Za-z .,]+")); + assertThat(faker.friends().character()).matches("[A-Za-z .,]+"); } @Test public void location() { - assertThat(faker.friends().location(), matchesRegularExpression("[\\w.', ]+")); + assertThat(faker.friends().location()).matches("[\\w.', ]+"); } @Test public void quote() { - assertThat(faker.friends().quote(), is(not(emptyOrNullString()))); + assertThat(faker.friends().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/FunnyNameTest.java b/src/test/java/org/thejavaguy/javafaker/FunnyNameTest.java index c248393..33ed5e4 100644 --- a/src/test/java/org/thejavaguy/javafaker/FunnyNameTest.java +++ b/src/test/java/org/thejavaguy/javafaker/FunnyNameTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class FunnyNameTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.funnyName().name(), matchesRegularExpression("^(\\w+\\.?\\s?'?-?)+$")); + assertThat(faker.funnyName().name()).matches("^(\\w+\\.?\\s?'?-?)+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/GameOfThronesTest.java b/src/test/java/org/thejavaguy/javafaker/GameOfThronesTest.java index 873580a..f43c3ce 100644 --- a/src/test/java/org/thejavaguy/javafaker/GameOfThronesTest.java +++ b/src/test/java/org/thejavaguy/javafaker/GameOfThronesTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,26 +8,26 @@ public class GameOfThronesTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.gameOfThrones().character(), matchesRegularExpression("[A-Za-z'\\-\\(\\) ]+")); + assertThat(faker.gameOfThrones().character()).matches("[A-Za-z'\\-\\(\\) ]+"); } @Test public void house() { - assertThat(faker.gameOfThrones().house(), matchesRegularExpression("[A-Za-z' ]+")); + assertThat(faker.gameOfThrones().house()).matches("[A-Za-z' ]+"); } @Test public void city() { - assertThat(faker.gameOfThrones().city(), matchesRegularExpression("[A-Za-z' ]+")); + assertThat(faker.gameOfThrones().city()).matches("[A-Za-z' ]+"); } @Test public void dragon() { - assertThat(faker.gameOfThrones().dragon(), matchesRegularExpression("\\w+")); + assertThat(faker.gameOfThrones().dragon()).matches("\\w+"); } @Test public void quote() { - assertThat(faker.gameOfThrones().quote(), is(not(emptyOrNullString()))); + assertThat(faker.gameOfThrones().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/GenderTest.java b/src/test/java/org/thejavaguy/javafaker/GenderTest.java index df995a5..2e2b216 100644 --- a/src/test/java/org/thejavaguy/javafaker/GenderTest.java +++ b/src/test/java/org/thejavaguy/javafaker/GenderTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,17 +8,17 @@ public class GenderTest extends AbstractFakerTest { @Test public void types() { - assertThat(faker.gender().types(), matchesRegularExpression("(\\w+ ?){1,2}")); + assertThat(faker.gender().types()).matches("(\\w+ ?){1,2}"); } @Test public void binaryTypes() { - assertThat(faker.gender().binaryTypes(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.gender().binaryTypes()).matches("[A-Za-z ]+"); } @Test public void shortBinaryTypes() { - assertThat(faker.gender().shortBinaryTypes(), matchesRegularExpression("f|m")); + assertThat(faker.gender().shortBinaryTypes()).matches("f|m"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/HackerTest.java b/src/test/java/org/thejavaguy/javafaker/HackerTest.java index 5896ccd..2fbc5ee 100644 --- a/src/test/java/org/thejavaguy/javafaker/HackerTest.java +++ b/src/test/java/org/thejavaguy/javafaker/HackerTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,26 +8,26 @@ public class HackerTest extends AbstractFakerTest { @Test public void testAbbreviation() { - assertThat(faker.hacker().abbreviation(), matchesRegularExpression("[A-Z]{2,4}")); + assertThat(faker.hacker().abbreviation()).matches("[A-Z]{2,4}"); } @Test public void testAdjective() { - assertThat(faker.hacker().adjective(), matchesRegularExpression("(\\w+[- ]?){1,2}")); + assertThat(faker.hacker().adjective()).matches("(\\w+[- ]?){1,2}"); } @Test public void testNoun() { - assertThat(faker.hacker().noun(), matchesRegularExpression("\\w+( \\w+)?")); + assertThat(faker.hacker().noun()).matches("\\w+( \\w+)?"); } @Test public void testVerb() { - assertThat(faker.hacker().verb(), matchesRegularExpression("\\w+( \\w+)?")); + assertThat(faker.hacker().verb()).matches("\\w+( \\w+)?"); } @Test public void testIngverb() { - assertThat(faker.hacker().ingverb(), matchesRegularExpression("\\w+ing( \\w+)?")); + assertThat(faker.hacker().ingverb()).matches("\\w+ing( \\w+)?"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/HarryPotterTest.java b/src/test/java/org/thejavaguy/javafaker/HarryPotterTest.java index bef499c..41333fc 100644 --- a/src/test/java/org/thejavaguy/javafaker/HarryPotterTest.java +++ b/src/test/java/org/thejavaguy/javafaker/HarryPotterTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,31 +8,31 @@ public class HarryPotterTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.harryPotter().character(), matchesRegularExpression("[A-Za-z,\\-\\.\\(\\) ]+")); + assertThat(faker.harryPotter().character()).matches("[A-Za-z,\\-\\.\\(\\) ]+"); } @Test public void location() { - assertThat(faker.harryPotter().location(), matchesRegularExpression("[A-Za-z0-9'\\. &,/]+")); + assertThat(faker.harryPotter().location()).matches("[A-Za-z0-9'\\. &,/]+"); } @Test public void quote() { - assertThat(faker.harryPotter().quote(), is(not(emptyOrNullString()))); + assertThat(faker.harryPotter().quote()).isNotEmpty(); } @Test public void book() { - assertThat(faker.harryPotter().book(), matchesRegularExpression("Harry Potter and the ([A-Za-z'\\-]+ ?)+")); + assertThat(faker.harryPotter().book()).matches("Harry Potter and the ([A-Za-z'\\-]+ ?)+"); } @Test public void house() { - assertThat(faker.harryPotter().house(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.harryPotter().house()).matches("[A-Za-z ]+"); } @Test public void spell() { - assertThat(faker.harryPotter().spell(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.harryPotter().spell()).matches("[A-Za-z ]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/HipsterTest.java b/src/test/java/org/thejavaguy/javafaker/HipsterTest.java index 5117fe8..b964d74 100644 --- a/src/test/java/org/thejavaguy/javafaker/HipsterTest.java +++ b/src/test/java/org/thejavaguy/javafaker/HipsterTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class HipsterTest extends AbstractFakerTest { @Test public void word() { - assertThat(faker.hipster().word(), matchesRegularExpression("^([\\w-+&']+ ?)+$")); + assertThat(faker.hipster().word()).matches("^([\\w-+&']+ ?)+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/HitchhikersGuideToTheGalaxyTest.java b/src/test/java/org/thejavaguy/javafaker/HitchhikersGuideToTheGalaxyTest.java index 071e930..5ffacf4 100644 --- a/src/test/java/org/thejavaguy/javafaker/HitchhikersGuideToTheGalaxyTest.java +++ b/src/test/java/org/thejavaguy/javafaker/HitchhikersGuideToTheGalaxyTest.java @@ -1,8 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -10,12 +9,12 @@ public class HitchhikersGuideToTheGalaxyTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.hitchhikersGuideToTheGalaxy().character(), matchesRegularExpression("^(\\w+(\\.?\\s?'?))+$")); + assertThat(faker.hitchhikersGuideToTheGalaxy().character()).matches("^[\\w\\s.']+$"); } @Test public void location() { - assertThat(faker.hitchhikersGuideToTheGalaxy().location(), matchesRegularExpression("^(\\w+\\S?\\.?\\s?'?-?)+$")); + assertThat(faker.hitchhikersGuideToTheGalaxy().location()).matches("^(\\w+\\S?\\.?\\s?'?-?)+$"); } @Test @@ -25,7 +24,7 @@ public void marvinQuote() { @Test public void planet() { - assertThat(faker.hitchhikersGuideToTheGalaxy().planet(), matchesRegularExpression("^(\\w+-?\\s?)+$")); + assertThat(faker.hitchhikersGuideToTheGalaxy().planet()).matches("^(\\w+-?\\s?)+$"); } @Test @@ -35,6 +34,6 @@ public void quote() { @Test public void specie() { - assertThat(faker.hitchhikersGuideToTheGalaxy().specie(), matchesRegularExpression("^(\\w+'?\\s?)+$")); + assertThat(faker.hitchhikersGuideToTheGalaxy().specie()).matches("^(\\w+'?\\s?)+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/HobbitTest.java b/src/test/java/org/thejavaguy/javafaker/HobbitTest.java index a3260f6..834bb7e 100644 --- a/src/test/java/org/thejavaguy/javafaker/HobbitTest.java +++ b/src/test/java/org/thejavaguy/javafaker/HobbitTest.java @@ -1,8 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -10,12 +9,12 @@ public class HobbitTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.hobbit().character(), matchesRegularExpression("^(\\(?\\w+\\.?\\s?\\)?)+$")); + assertThat(faker.hobbit().character()).matches("^(\\(?\\w+\\.?\\s?\\)?)+$"); } @Test public void thorinsCompany() { - assertThat(faker.hobbit().thorinsCompany(), matchesRegularExpression("^(\\w+\\s?)+$")); + assertThat(faker.hobbit().thorinsCompany()).matches("^(\\w+\\s?)+$"); } @Test @@ -25,6 +24,6 @@ public void quote() { @Test public void location() { - assertThat(faker.hobbit().location(), matchesRegularExpression("^(\\w+'?-?\\s?)+$")); + assertThat(faker.hobbit().location()).matches("^(\\w+'?-?\\s?)+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/HowIMetYourMotherTest.java b/src/test/java/org/thejavaguy/javafaker/HowIMetYourMotherTest.java index 4dc8404..e459ebf 100644 --- a/src/test/java/org/thejavaguy/javafaker/HowIMetYourMotherTest.java +++ b/src/test/java/org/thejavaguy/javafaker/HowIMetYourMotherTest.java @@ -1,8 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -10,7 +9,7 @@ public class HowIMetYourMotherTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.howIMetYourMother().character(), matchesRegularExpression("^(\\w+\\.?\\s?)+$")); + assertThat(faker.howIMetYourMother().character()).matches("^(\\w+\\.?\\s?)+$"); } @Test @@ -20,7 +19,7 @@ public void catchPhrase() { @Test public void highFive() { - assertThat(faker.howIMetYourMother().highFive(), matchesRegularExpression("^(\\w+-?\\s?)+$")); + assertThat(faker.howIMetYourMother().highFive()).matches("^(\\w+-?\\s?)+$"); } @Test diff --git a/src/test/java/org/thejavaguy/javafaker/IdNumberTest.java b/src/test/java/org/thejavaguy/javafaker/IdNumberTest.java index 7d53b8c..4f67d8e 100644 --- a/src/test/java/org/thejavaguy/javafaker/IdNumberTest.java +++ b/src/test/java/org/thejavaguy/javafaker/IdNumberTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -11,24 +10,24 @@ public class IdNumberTest extends AbstractFakerTest { @Test public void testValid() { - assertThat(faker.idNumber().valid(), matchesRegularExpression("[0-8]\\d{2}-\\d{2}-\\d{4}")); + assertThat(faker.idNumber().valid()).matches("[0-8]\\d{2}-\\d{2}-\\d{4}"); } @Test public void testInvalid() { - assertThat(faker.idNumber().invalid(), matchesRegularExpression("[0-9]\\d{2}-\\d{2}-\\d{4}")); + assertThat(faker.idNumber().invalid()).matches("[0-9]\\d{2}-\\d{2}-\\d{4}"); } @Test public void testSsnValid() { - assertThat(faker.idNumber().valid(), matchesRegularExpression("[0-8]\\d{2}-\\d{2}-\\d{4}")); + assertThat(faker.idNumber().valid()).matches("[0-8]\\d{2}-\\d{2}-\\d{4}"); } @Test public void testValidSwedishSsn() { final Faker f = new Faker(new Locale("sv_SE")); for (int i = 0; i < 100; i++) { - assertThat(f.idNumber().valid(), matchesRegularExpression("\\d{6}[-+]\\d{4}")); + assertThat(f.idNumber().valid()).matches("\\d{6}[-+]\\d{4}"); } } @@ -36,7 +35,7 @@ public void testValidSwedishSsn() { public void testInvalidSwedishSsn() { final Faker f = new Faker(new Locale("sv_SE")); for (int i = 0; i < 100; i++) { - assertThat(f.idNumber().invalid(), matchesRegularExpression("\\d{6}[-+]\\d{4}")); + assertThat(f.idNumber().invalid()).matches("\\d{6}[-+]\\d{4}"); } } } diff --git a/src/test/java/org/thejavaguy/javafaker/InternetTest.java b/src/test/java/org/thejavaguy/javafaker/InternetTest.java index 535afb7..98f7a0a 100644 --- a/src/test/java/org/thejavaguy/javafaker/InternetTest.java +++ b/src/test/java/org/thejavaguy/javafaker/InternetTest.java @@ -1,26 +1,12 @@ package org.thejavaguy.javafaker; import static java.lang.Integer.parseInt; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.anyOf; -import static org.hamcrest.Matchers.both; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.lessThanOrEqualTo; -import static org.hamcrest.Matchers.not; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.startsWith; -import static org.thejavaguy.javafaker.matchers.CountOfCharactersMatcher.countOf; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.util.List; import java.util.Locale; import org.apache.commons.validator.routines.EmailValidator; -import org.hamcrest.Matchers; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; import org.thejavaguy.javafaker.repeating.Repeat; @@ -33,14 +19,14 @@ public class InternetTest extends AbstractFakerTest { @Test public void testEmailAddress() { String emailAddress = faker.internet().emailAddress(); - assertThat(EmailValidator.getInstance().isValid(emailAddress), is(true)); + assertThat(EmailValidator.getInstance().isValid(emailAddress)).isEqualTo(true); } @Test public void testEmailAddressWithLocalPartParameter() { String emailAddress = faker.internet().emailAddress("john"); - assertThat(emailAddress, startsWith("john@")); - assertThat(EmailValidator.getInstance().isValid(emailAddress), is(true)); + assertThat(emailAddress).startsWith("john@"); + assertThat(EmailValidator.getInstance().isValid(emailAddress)).isEqualTo(true); } @Test @@ -48,13 +34,14 @@ public void testSafeEmailAddress() { List emails = Lists.newArrayList(); for (int i=0;i<100;i++) { String emailAddress = faker.internet().safeEmailAddress(); - assertThat(EmailValidator.getInstance().isValid(emailAddress), is(true)); + assertThat(EmailValidator.getInstance().isValid(emailAddress)).isEqualTo(true); emails.add(emailAddress); } final String safeDomain = faker.resolve("internet.safe_email"); - assertThat("Should find at least one email from " + safeDomain, emails, - Matchers.hasItem(Matchers.endsWith("@" + safeDomain))); + assertThat(emails) + .as("Should find at least one email from " + safeDomain) + .anyMatch(email -> email.endsWith("@" + safeDomain)); } @Test @@ -62,146 +49,153 @@ public void testSafeEmailAddressWithLocalPartParameter() { List emails = Lists.newArrayList(); for (int i=0;i<100;i++) { String emailAddress = faker.internet().safeEmailAddress("john"); - assertThat(emailAddress, startsWith("john@")); - assertThat(EmailValidator.getInstance().isValid(emailAddress), is(true)); + assertThat(emailAddress).startsWith("john@"); + assertThat(EmailValidator.getInstance().isValid(emailAddress)).isEqualTo(true); emails.add(emailAddress); } final String safeDomain = faker.resolve("internet.safe_email"); - assertThat("Should find at least one email from " + safeDomain, emails, - Matchers.hasItem(Matchers.endsWith("@" + safeDomain))); + assertThat(emails) + .as("Should find at least one email from " + safeDomain) + .anyMatch(email -> email.endsWith("@" + safeDomain)); } @Test public void testEmailAddressDoesNotIncludeAccentsInTheLocalPart() { String emailAddress = faker.internet().emailAddress("áéíóú"); - assertThat(emailAddress, startsWith("aeiou@")); + assertThat(emailAddress).startsWith("aeiou@"); } @Test public void testSafeEmailAddressDoesNotIncludeAccentsInTheLocalPart() { String emailAddress = faker.internet().safeEmailAddress("áéíóú"); - assertThat(emailAddress, startsWith("aeiou@")); + assertThat(emailAddress).startsWith("aeiou@"); } @Test public void testUrl() { - assertThat(faker.internet().url(), matchesRegularExpression("www\\.(\\w|-)+\\.\\w+")); + assertThat(faker.internet().url()).matches("www\\.(\\w|-)+\\.\\w+"); } @Test public void testAvatar() { - assertThat(faker.internet().avatar(), matchesRegularExpression("http.*/[^/]+/128.jpg$")); + assertThat(faker.internet().avatar()).matches("http.*/[^/]+/128.jpg$"); } @Test public void testImage() { String imageUrl = faker.internet().image(); - assertThat(imageUrl, matchesRegularExpression("^http:\\/\\/lorempixel\\.com(/g)?/\\d{1,4}/\\d{1,4}/\\w+/$")); + assertThat(imageUrl).matches("^http:\\/\\/lorempixel\\.com(/g)?/\\d{1,4}/\\d{1,4}/\\w+/$"); } @Test public void testDomainName() { - assertThat(faker.internet().domainName(), matchesRegularExpression("[a-z]+\\.\\w{2,4}")); + assertThat(faker.internet().domainName()).matches("[a-z]+\\.\\w{2,4}"); } @Test public void testDomainWord() { - assertThat(faker.internet().domainWord(), matchesRegularExpression("[a-z]+")); + assertThat(faker.internet().domainWord()).matches("[a-z]+"); } @Test public void testDomainSuffix() { - assertThat(faker.internet().domainSuffix(), matchesRegularExpression("\\w{2,4}")); + assertThat(faker.internet().domainSuffix()).matches("\\w{2,4}"); } @Test public void testImageWithExplicitParams() { String imageUrl = faker.internet().image(800, 600, false, "bugs"); - assertThat(imageUrl, matchesRegularExpression("^http:\\/\\/lorempixel\\.com/800/600/\\w+/bugs$")); + assertThat(imageUrl).matches("^http:\\/\\/lorempixel\\.com/800/600/\\w+/bugs$"); } @Test public void testPassword() { - assertThat(faker.internet().password(), matchesRegularExpression("[a-z\\d]{8,16}")); + assertThat(faker.internet().password()).matches("[a-z\\d]{8,16}"); } @Test public void testPasswordIncludeDigit() { - assertThat(faker.internet().password(), matchesRegularExpression("[a-z\\d]{8,16}")); - assertThat(faker.internet().password(false), matchesRegularExpression("[a-z]{8,16}")); + assertThat(faker.internet().password()).matches("[a-z\\d]{8,16}"); + assertThat(faker.internet().password(false)).matches("[a-z]{8,16}"); } @Test public void testPasswordMinLengthMaxLength() { - assertThat(faker.internet().password(10, 25), matchesRegularExpression("[a-z\\d]{10,25}")); + assertThat(faker.internet().password(10, 25)).matches("[a-z\\d]{10,25}"); } @Test public void testPasswordMinLengthMaxLengthIncludeUpperCase() { - assertThat(faker.internet().password(1, 2, false), matchesRegularExpression("[a-z\\d]{1,2}")); - assertThat(faker.internet().password(10, 25, true), matchesRegularExpression("[a-zA-Z\\d]{10,25}")); + assertThat(faker.internet().password(1, 2, false)).matches("[a-z\\d]{1,2}"); + assertThat(faker.internet().password(10, 25, true)).matches("[a-zA-Z\\d]{10,25}"); } @Test public void testPasswordMinLengthMaxLengthIncludeUpperCaseIncludeSpecial() { - assertThat(faker.internet().password(10, 25, false, false), matchesRegularExpression("[a-z\\d]{10,25}")); - assertThat(faker.internet().password(10, 25, false, true), matchesRegularExpression("[a-z\\d!@#$%^&*]{10,25}")); - assertThat(faker.internet().password(10, 25, true, true), matchesRegularExpression("[a-zA-Z\\d!@#$%^&*]{10,25}")); + assertThat(faker.internet().password(10, 25, false, false)).matches("[a-z\\d]{10,25}"); + assertThat(faker.internet().password(10, 25, false, true)).matches("[a-z\\d!@#$%^&*]{10,25}"); + assertThat(faker.internet().password(10, 25, true, true)).matches("[a-zA-Z\\d!@#$%^&*]{10,25}"); } @Test public void testPasswordMinLengthMaxLengthIncludeUpperCaseIncludeSpecialIncludeDigit() { - assertThat(faker.internet().password(10, 25, false, false, false), matchesRegularExpression("[a-z]{10,25}")); - assertThat(faker.internet().password(10, 25, false, true, true), matchesRegularExpression("[a-z\\d!@#$%^&*]{10,25}")); - assertThat(faker.internet().password(10, 25, true, true, false), matchesRegularExpression("[a-zA-Z!@#$%^&*]{10,25}")); - assertThat(faker.internet().password(10, 25, true, true, true), matchesRegularExpression("[a-zA-Z\\d!@#$%^&*]{10,25}")); + assertThat(faker.internet().password(10, 25, false, false, false)).matches("[a-z]{10,25}"); + assertThat(faker.internet().password(10, 25, false, true, true)).matches("[a-z\\d!@#$%^&*]{10,25}"); + assertThat(faker.internet().password(10, 25, true, true, false)).matches("[a-zA-Z!@#$%^&*]{10,25}"); + assertThat(faker.internet().password(10, 25, true, true, true)).matches("[a-zA-Z\\d!@#$%^&*]{10,25}"); } @Test public void testMacAddress() { - assertThat(faker.internet().macAddress(), countOf(':', is(5))); - assertThat(faker.internet().macAddress(""), countOf(':', is(5))); + assertThat(faker.internet().macAddress().chars().filter(c -> c == ':').count()).isEqualTo(5); + assertThat(faker.internet().macAddress("").chars().filter(c -> c == ':').count()).isEqualTo(5); - assertThat(faker.internet().macAddress("fa:fa:fa"), startsWith("fa:fa:fa")); - assertThat(faker.internet().macAddress("fa:fa:fa"), countOf(':', is(5))); + assertThat(faker.internet().macAddress("fa:fa:fa")).startsWith("fa:fa:fa"); + assertThat(faker.internet().macAddress("fa:fa:fa").chars().filter(c -> c == ':').count()).isEqualTo(5); - assertThat(faker.internet().macAddress("01:02"), startsWith("01:02")); - assertThat(faker.internet().macAddress("01:02"), countOf(':', is(5))); + assertThat(faker.internet().macAddress("01:02")).startsWith("01:02"); + assertThat(faker.internet().macAddress("01:02").chars().filter(c -> c == ':').count()).isEqualTo(5); // loop through 1000 times just to 'run it through the wringer' for (int i=0; i<1000;i++) { - assertThat( - "Is valid mac format", - faker.internet().macAddress(), - matchesRegularExpression("[0-9a-fA-F]{2}(\\:([0-9a-fA-F]{1,4})){5}")); + assertThat(faker.internet().macAddress()).matches("[0-9a-fA-F]{2}(\\:([0-9a-fA-F]{1,4})){5}"); } } @Test public void testIpV4Address() { - assertThat(faker.internet().ipV4Address(), countOf('.', is(3))); + assertThat(faker.internet().ipV4Address().chars().filter(c -> c == '.').count()).isEqualTo(3); for (int i = 0; i < 100; i++) { final String[] octets = faker.internet().ipV4Address().split("\\."); - assertThat("first octet is 1-255", parseInt(octets[0]), - both(greaterThan(0)).and(lessThanOrEqualTo(255))); - assertThat("second octet is 0-255", parseInt(octets[1]), - both(greaterThanOrEqualTo(0)).and(lessThanOrEqualTo(255))); - assertThat("second octet is 0-255", parseInt(octets[2]), - both(greaterThanOrEqualTo(0)).and(lessThanOrEqualTo(255))); - assertThat("second octet is 0-255", parseInt(octets[3]), - both(greaterThanOrEqualTo(0)).and(lessThanOrEqualTo(255))); + assertThat(parseInt(octets[0])) + .as("first octet is 1-255") + .isGreaterThanOrEqualTo(0) + .isLessThanOrEqualTo(255); + assertThat(parseInt(octets[1])) + .as("second octet is 0-255") + .isGreaterThanOrEqualTo(0) + .isLessThanOrEqualTo(255); + assertThat(parseInt(octets[2])) + .as("third octet is 0-255") + .isGreaterThanOrEqualTo(0) + .isLessThanOrEqualTo(255); + assertThat(parseInt(octets[3])) + .as("fourth octet is 0-255") + .isGreaterThanOrEqualTo(0) + .isLessThanOrEqualTo(255); } } @Test public void testIpV4Cidr() { - assertThat(faker.internet().ipV4Cidr(), countOf('.', is(3))); - assertThat(faker.internet().ipV4Cidr(), countOf('/', is(1))); + assertThat(faker.internet().ipV4Cidr().chars().filter(c -> c == '.').count()).isEqualTo(3); + assertThat(faker.internet().ipV4Cidr().chars().filter(c -> c == '/').count()).isEqualTo(1); for (int i = 0; i < 1000; i++) { - assertThat(parseInt(faker.internet().ipV4Cidr().split("/")[1]), - both(greaterThanOrEqualTo(1)).and(lessThan(32))); + assertThat(parseInt(faker.internet().ipV4Cidr().split("/")[1])) + .isGreaterThanOrEqualTo(0) + .isLessThan(32); } } @@ -216,11 +210,14 @@ public void testPrivateIpV4Address() { for (int i = 0; i < 1000; i++) { String addr = faker.internet().privateIpV4Address(); - assertThat(addr, anyOf(matchesRegularExpression(tenDot), - matchesRegularExpression(oneTwoSeven), - matchesRegularExpression(oneSixNine), - matchesRegularExpression(oneNineTwo), - matchesRegularExpression(oneSevenTwo))); + assertThat(addr) + .satisfiesAnyOf( + arg -> assertThat(arg).matches(tenDot), + arg -> assertThat(arg).matches(oneTwoSeven), + arg -> assertThat(arg).matches(oneSixNine), + arg -> assertThat(arg).matches(oneNineTwo), + arg -> assertThat(arg).matches(oneSevenTwo) + ); } } @@ -233,53 +230,51 @@ public void testPublicIpV4Address() { String oneSevenTwo = "^172\\.(16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31)\\."; for (int i = 0; i < 1000; i++) { String addr = faker.internet().publicIpV4Address(); - assertThat(addr.matches(tenDot),is(false)); - assertThat(addr.matches(oneTwoSeven),is(false)); - assertThat(addr.matches(oneSixNine),is(false)); - assertThat(addr.matches(oneNineTwo),is(false)); - assertThat(addr.matches(oneSevenTwo),is(false)); + assertThat(addr.matches(tenDot)).isEqualTo(false); + assertThat(addr.matches(oneTwoSeven)).isEqualTo(false); + assertThat(addr.matches(oneSixNine)).isEqualTo(false); + assertThat(addr.matches(oneNineTwo)).isEqualTo(false); + assertThat(addr.matches(oneSevenTwo)).isEqualTo(false); } } @Test public void testIpV6() { - assertThat(faker.internet().ipV6Address(), countOf(':', is(7))); + assertThat(faker.internet().ipV6Address().chars().filter(c -> c == ':').count()).isEqualTo(7); for (int i = 0; i < 1000; i++) { - assertThat( - "Is valid ipv6 format", - faker.internet().ipV6Address(), - matchesRegularExpression("[0-9a-fA-F]{1,4}(\\:([0-9a-fA-F]{1,4})){1,7}")); + assertThat(faker.internet().ipV6Address()).matches("[0-9a-fA-F]{1,4}(\\:([0-9a-fA-F]{1,4})){1,7}"); } } @Test public void testIpV6Cidr() { - assertThat(faker.internet().ipV6Cidr(), countOf(':', is(7))); - assertThat(faker.internet().ipV6Cidr(), countOf('/', is(1))); + assertThat(faker.internet().ipV6Cidr().chars().filter(c -> c == ':').count()).isEqualTo(7); + assertThat(faker.internet().ipV6Cidr().chars().filter(c -> c == '/').count()).isEqualTo(1); for (int i = 0; i < 1000; i++) { - assertThat(parseInt(faker.internet().ipV6Cidr().split("/")[1]), - both(greaterThanOrEqualTo(1)).and(lessThan(128))); + assertThat(parseInt(faker.internet().ipV6Cidr().split("/")[1])) + .isGreaterThanOrEqualTo(0) + .isLessThan(128); } } @TestTemplate @Repeat(times=10) public void testSlugWithParams() { - assertThat(faker.internet().slug(ImmutableList.of("a", "b"), "-"), matchesRegularExpression("[a-zA-Z]+\\-[a-zA-Z]+")); + assertThat(faker.internet().slug(ImmutableList.of("a", "b"), "-")).matches("[a-zA-Z]+\\-[a-zA-Z]+"); } @TestTemplate @Repeat(times=10) public void testSlug() { - assertThat(faker.internet().slug(), matchesRegularExpression("[a-zA-Z]+\\_[a-zA-Z]+")); + assertThat(faker.internet().slug()).matches("[a-zA-Z]+\\_[a-zA-Z]+"); } @TestTemplate @Repeat(times=10) public void testUuid() { - assertThat(faker.internet().uuid(), matchesRegularExpression("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")); + assertThat(faker.internet().uuid()).matches("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"); } @TestTemplate @@ -288,26 +283,26 @@ public void testFarsiIDNs() { // in this case, we're just making sure Farsi doesn't blow up. // there have been issues with Farsi not being produced. final Faker f = new Faker(new Locale("fa")); - assertThat(f.internet().domainName(), is(not(emptyOrNullString()))); - assertThat(f.internet().emailAddress(), is(not(emptyOrNullString()))); - assertThat(f.internet().safeEmailAddress(), is(not(emptyOrNullString()))); - assertThat(f.internet().url(), is(not(emptyOrNullString()))); + assertThat(f.internet().domainName()).isNotEmpty(); + assertThat(f.internet().emailAddress()).isNotEmpty(); + assertThat(f.internet().safeEmailAddress()).isNotEmpty(); + assertThat(f.internet().url()).isNotEmpty(); } @Test public void testUserAgent() { Internet.UserAgent[] agents = Internet.UserAgent.values(); for(Internet.UserAgent agent : agents) { - assertThat(faker.internet().userAgent(agent), is(not(emptyOrNullString()))); + assertThat(faker.internet().userAgent(agent)).isNotEmpty(); } //Test faker.internet().userAgentAny() for random user_agent retrieval. - assertThat(faker.internet().userAgentAny(), is(not(emptyOrNullString()))); + assertThat(faker.internet().userAgentAny()).isNotEmpty(); } @Test public void testSlugWithNull(){ Faker f=new Faker(); - assertThat(f.internet().slug(null,"_"),notNullValue()); + assertThat(f.internet().slug(null, "_")).isNotNull(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/JobTest.java b/src/test/java/org/thejavaguy/javafaker/JobTest.java index b2de6ca..801d6d9 100644 --- a/src/test/java/org/thejavaguy/javafaker/JobTest.java +++ b/src/test/java/org/thejavaguy/javafaker/JobTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,26 +8,26 @@ public class JobTest extends AbstractFakerTest { @Test public void field() { - assertThat(faker.job().field(), matchesRegularExpression("^[A-Z][A-Za-z-]+$")); + assertThat(faker.job().field()).matches("^[A-Z][A-Za-z-]+$"); } @Test public void seniority() { - assertThat(faker.job().seniority(), matchesRegularExpression("^[A-Z][a-z]+$")); + assertThat(faker.job().seniority()).matches("^[A-Z][a-z]+$"); } @Test public void position() { - assertThat(faker.job().position(), matchesRegularExpression("^[A-Z][a-z]+$")); + assertThat(faker.job().position()).matches("^[A-Z][a-z]+$"); } @Test public void keySkills() { - assertThat(faker.job().keySkills(), matchesRegularExpression("([A-Za-z-]+ ?){1,3}")); + assertThat(faker.job().keySkills()).matches("([A-Za-z-]+ ?){1,3}"); } @Test public void title() { - assertThat(faker.job().title(), matchesRegularExpression("([A-Za-z-]+ ?){2,3}")); + assertThat(faker.job().title()).matches("([A-Za-z-]+ ?){2,3}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/KaamelottTest.java b/src/test/java/org/thejavaguy/javafaker/KaamelottTest.java index a429aff..44de584 100644 --- a/src/test/java/org/thejavaguy/javafaker/KaamelottTest.java +++ b/src/test/java/org/thejavaguy/javafaker/KaamelottTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,11 +8,11 @@ public class KaamelottTest extends AbstractFakerTest { @Test public void testCharacter() { - assertThat(faker.kaamelott().character(), matchesRegularExpression("[A-Za-z' -ÇÉàçêèéïîüùú]+")); + assertThat(faker.kaamelott().character()).matches("[A-Za-z' -ÇÉàçêèéïîüùú]+"); } @Test public void testQuote() { - assertThat(faker.kaamelott().quote(), matchesRegularExpression("[-A-Za-z0-9 —ÇÉàçêèéïîüùú;:…\\?\\!\\.’‘'”“,\\[\\]]+")); + assertThat(faker.kaamelott().quote()).matches("[-A-Za-z0-9 —ÇÉàçêèéïîüùú;:…\\?\\!\\.’‘'”“,\\[\\]]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/LeagueOfLegendsTest.java b/src/test/java/org/thejavaguy/javafaker/LeagueOfLegendsTest.java index ca6419d..dcd7e9f 100644 --- a/src/test/java/org/thejavaguy/javafaker/LeagueOfLegendsTest.java +++ b/src/test/java/org/thejavaguy/javafaker/LeagueOfLegendsTest.java @@ -1,8 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -10,12 +9,12 @@ public class LeagueOfLegendsTest extends AbstractFakerTest { @Test public void champion() { - assertThat(faker.leagueOfLegends().champion(), matchesRegularExpression("^(\\w+\\.?-?'?\\s?&?\\s?)+$")); + assertThat(faker.leagueOfLegends().champion()).matches("^(\\w+\\.?-?'?\\s?&?\\s?)+$"); } @Test public void location() { - assertThat(faker.leagueOfLegends().location(), matchesRegularExpression("^(\\w+\\s?)+$")); + assertThat(faker.leagueOfLegends().location()).matches("^(\\w+\\s?)+$"); } @Test @@ -25,16 +24,16 @@ public void quote() { @Test public void summonerSpell() { - assertThat(faker.leagueOfLegends().summonerSpell(), matchesRegularExpression("^(\\w+\\s?!?)+$")); + assertThat(faker.leagueOfLegends().summonerSpell()).matches("^(\\w+\\s?!?)+$"); } @Test public void masteries() { - assertThat(faker.leagueOfLegends().masteries(), matchesRegularExpression("^(\\w+\\s?'?)+$")); + assertThat(faker.leagueOfLegends().masteries()).matches("^(\\w+\\s?'?)+$"); } @Test public void rank() { - assertThat(faker.leagueOfLegends().rank(), matchesRegularExpression("^\\w+(\\s[IV]+)?$")); + assertThat(faker.leagueOfLegends().rank()).matches("^\\w+(\\s[IV]+)?$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/LebowskiTest.java b/src/test/java/org/thejavaguy/javafaker/LebowskiTest.java index 527f813..b782622 100644 --- a/src/test/java/org/thejavaguy/javafaker/LebowskiTest.java +++ b/src/test/java/org/thejavaguy/javafaker/LebowskiTest.java @@ -1,23 +1,22 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; public class LebowskiTest extends AbstractFakerTest { @Test public void actor() { - assertThat(faker.lebowski().actor(), matchesRegularExpression("^([\\w]+ ?){1,3}$")); + assertThat(faker.lebowski().actor()).matches("^([\\w]+ ?){1,3}$"); } @Test public void character() { - assertThat(faker.lebowski().character(), matchesRegularExpression("^([\\w]+ ?){1,3}$")); + assertThat(faker.lebowski().character()).matches("^([\\w]+ ?){1,3}$"); } @Test public void quote() { - assertThat(faker.lebowski().quote(), matchesRegularExpression("^([\\w.,!?'-]+ ?)+$")); + assertThat(faker.lebowski().quote()).matches("^([\\w.,!?'-]+ ?)+$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/LordOfTheRingsTest.java b/src/test/java/org/thejavaguy/javafaker/LordOfTheRingsTest.java index 61bd22e..b4bb6e2 100644 --- a/src/test/java/org/thejavaguy/javafaker/LordOfTheRingsTest.java +++ b/src/test/java/org/thejavaguy/javafaker/LordOfTheRingsTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,11 +11,11 @@ public class LordOfTheRingsTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.lordOfTheRings().character(), matchesRegularExpression("(?U)([\\w ]+ ?)+")); + assertThat(faker.lordOfTheRings().character()).matches("(?U)([\\w ]+ ?)+"); } @Test public void location() { - assertThat(faker.lordOfTheRings().location(), matchesRegularExpression("(?U)([\\w'\\- ]+ ?)+")); + assertThat(faker.lordOfTheRings().location()).matches("(?U)([\\w'\\- ]+ ?)+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/LoremTest.java b/src/test/java/org/thejavaguy/javafaker/LoremTest.java index 64e55c8..e0f9d62 100644 --- a/src/test/java/org/thejavaguy/javafaker/LoremTest.java +++ b/src/test/java/org/thejavaguy/javafaker/LoremTest.java @@ -1,14 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.emptyString; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -24,87 +17,87 @@ public void shouldCreateFixedLengthString() { @Test public void wordShouldNotBeNullOrEmpty() { - assertThat(faker.lorem().word(), is(not(emptyOrNullString()))); + assertThat(faker.lorem().word()).isNotEmpty(); } @Test public void testCharacter() { - assertThat(String.valueOf(faker.lorem().character()), matchesRegularExpression("[a-z\\d]{1}")); + assertThat(String.valueOf(faker.lorem().character())).matches("[a-z\\d]{1}"); } @Test public void testCharacterIncludeUpperCase() { - assertThat(String.valueOf(faker.lorem().character(false)), matchesRegularExpression("[a-z\\d]{1}")); - assertThat(String.valueOf(faker.lorem().character(true)), matchesRegularExpression("[a-zA-Z\\d]{1}")); + assertThat(String.valueOf(faker.lorem().character(false))).matches("[a-z\\d]{1}"); + assertThat(String.valueOf(faker.lorem().character(true))).matches("[a-zA-Z\\d]{1}"); } @Test public void testCharacters() { - assertThat(faker.lorem().characters(), matchesRegularExpression("[a-z\\d]{255}")); + assertThat(faker.lorem().characters()).matches("[a-z\\d]{255}"); } @Test public void testCharactersIncludeUpperCase() { - assertThat(faker.lorem().characters(false), matchesRegularExpression("[a-z\\d]{255}")); - assertThat(faker.lorem().characters(true), matchesRegularExpression("[a-zA-Z\\d]{255}")); + assertThat(faker.lorem().characters(false)).matches("[a-z\\d]{255}"); + assertThat(faker.lorem().characters(true)).matches("[a-zA-Z\\d]{255}"); } @Test public void testCharactersWithLength() { - assertThat(faker.lorem().characters(2), matchesRegularExpression("[a-z\\d]{2}")); - assertThat(faker.lorem().characters(500), matchesRegularExpression("[a-z\\d]{500}")); - assertThat(faker.lorem().characters(0), is(emptyString())); - assertThat(faker.lorem().characters(-1), is(emptyString())); + assertThat(faker.lorem().characters(2)).matches("[a-z\\d]{2}"); + assertThat(faker.lorem().characters(500)).matches("[a-z\\d]{500}"); + assertThat(faker.lorem().characters(0)).isEmpty(); + assertThat(faker.lorem().characters(-1)).isEmpty(); } @Test public void testCharactersWithLengthIncludeUppercase() { - assertThat(faker.lorem().characters(2, false), matchesRegularExpression("[a-z\\d]{2}")); - assertThat(faker.lorem().characters(500, false), matchesRegularExpression("[a-z\\d]{500}")); - assertThat(faker.lorem().characters(2, true), matchesRegularExpression("[a-zA-Z\\d]{2}")); - assertThat(faker.lorem().characters(500, true), matchesRegularExpression("[a-zA-Z\\d]{500}")); - assertThat(faker.lorem().characters(0, false), is(emptyString())); - assertThat(faker.lorem().characters(-1, true), is(emptyString())); + assertThat(faker.lorem().characters(2, false)).matches("[a-z\\d]{2}"); + assertThat(faker.lorem().characters(500, false)).matches("[a-z\\d]{500}"); + assertThat(faker.lorem().characters(2, true)).matches("[a-zA-Z\\d]{2}"); + assertThat(faker.lorem().characters(500, true)).matches("[a-zA-Z\\d]{500}"); + assertThat(faker.lorem().characters(0, false)).isEmpty(); + assertThat(faker.lorem().characters(-1, true)).isEmpty(); } @Test public void testCharactersMinimumMaximumLength() { - assertThat(faker.lorem().characters(1, 10), matchesRegularExpression("[a-z\\d]{1,10}")); + assertThat(faker.lorem().characters(1, 10)).matches("[a-z\\d]{1,10}"); } @Test public void testCharactersMinimumMaximumLengthIncludeUppercase() { - assertThat(faker.lorem().characters(1, 10, true), matchesRegularExpression("[a-zA-Z\\d]{1,10}")); + assertThat(faker.lorem().characters(1, 10, true)).matches("[a-zA-Z\\d]{1,10}"); } @Test public void testCharactersMinimumMaximumLengthIncludeUppercaseIncludeDigit() { - assertThat(faker.lorem().characters(1, 10, false, false), matchesRegularExpression("[a-zA-Z]{1,10}")); - assertThat(faker.lorem().characters(1, 10, true, true), matchesRegularExpression("[a-zA-Z\\d]{1,10}")); + assertThat(faker.lorem().characters(1, 10, false, false)).matches("[a-zA-Z]{1,10}"); + assertThat(faker.lorem().characters(1, 10, true, true)).matches("[a-zA-Z\\d]{1,10}"); } @Test public void testSentence() { - assertThat(faker.lorem().sentence(), matchesRegularExpression("(\\w+\\s?){4,10}\\.")); + assertThat(faker.lorem().sentence()).matches("(\\w+\\s?){4,10}\\."); } @Test public void testSentenceWithWordCount() { - assertThat(faker.lorem().sentence(10), matchesRegularExpression("(\\w+\\s?){11,17}\\.")); + assertThat(faker.lorem().sentence(10)).matches("(\\w+\\s?){11,17}\\."); } @Test public void testSentenceWithWordCountAndRandomWordsToAdd() { - assertThat(faker.lorem().sentence(10, 10), matchesRegularExpression("(\\w+\\s?){10,20}\\.")); + assertThat(faker.lorem().sentence(10, 10)).matches("(\\w+\\s?){10,20}\\."); } @Test public void testSentenceFixedNumberOfWords() { - assertThat(faker.lorem().sentence(10, 0), matchesRegularExpression("(\\w+\\s?){10}\\.")); + assertThat(faker.lorem().sentence(10, 0)).matches("(\\w+\\s?){10}\\."); } @Test public void testWords() { - assertThat(faker.lorem().words(), hasSize(greaterThanOrEqualTo(1))); + assertThat(faker.lorem().words()).hasSizeGreaterThanOrEqualTo(1); } } diff --git a/src/test/java/org/thejavaguy/javafaker/MatzTest.java b/src/test/java/org/thejavaguy/javafaker/MatzTest.java index 15f3a11..056bfb3 100644 --- a/src/test/java/org/thejavaguy/javafaker/MatzTest.java +++ b/src/test/java/org/thejavaguy/javafaker/MatzTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,6 +8,6 @@ public class MatzTest extends AbstractFakerTest { @Test public void quote() { - assertThat(faker.matz().quote(), is(not(emptyOrNullString()))); + assertThat(faker.matz().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/MedicalTest.java b/src/test/java/org/thejavaguy/javafaker/MedicalTest.java index d673d04..c5e546e 100644 --- a/src/test/java/org/thejavaguy/javafaker/MedicalTest.java +++ b/src/test/java/org/thejavaguy/javafaker/MedicalTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,22 +8,22 @@ public class MedicalTest extends AbstractFakerTest { @Test public void testMedicineName() { - assertThat(faker.medical().medicineName(), isStringWithContents()); + assertThat(faker.medical().medicineName()).isNotBlank(); } @Test public void testDiseaseName() { - assertThat(faker.medical().diseaseName(), isStringWithContents()); + assertThat(faker.medical().diseaseName()).isNotBlank(); } @Test public void testHospitalName() { - assertThat(faker.medical().hospitalName(), isStringWithContents()); + assertThat(faker.medical().hospitalName()).isNotBlank(); } @Test public void testSymptom() { - assertThat(faker.medical().symptoms(), isStringWithContents()); + assertThat(faker.medical().symptoms()).isNotBlank(); } diff --git a/src/test/java/org/thejavaguy/javafaker/MountainTest.java b/src/test/java/org/thejavaguy/javafaker/MountainTest.java index 70a82f0..728c220 100644 --- a/src/test/java/org/thejavaguy/javafaker/MountainTest.java +++ b/src/test/java/org/thejavaguy/javafaker/MountainTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,12 +8,12 @@ public class MountainTest extends AbstractFakerTest { @Test public void testMountainName() { String mountainName = faker.mountain().name(); - assertThat(mountainName, is(not(emptyOrNullString()))); + assertThat(mountainName).isNotEmpty(); } @Test public void testMountainLeague() { String mountainLeague = faker.mountain().range(); - assertThat(mountainLeague, is(not(emptyOrNullString()))); + assertThat(mountainLeague).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/MusicTest.java b/src/test/java/org/thejavaguy/javafaker/MusicTest.java index 769abac..9300278 100644 --- a/src/test/java/org/thejavaguy/javafaker/MusicTest.java +++ b/src/test/java/org/thejavaguy/javafaker/MusicTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,21 +8,21 @@ public class MusicTest extends AbstractFakerTest { @Test public void instrument() { - assertThat(faker.music().instrument(), matchesRegularExpression("\\w+ ?\\w+")); + assertThat(faker.music().instrument()).matches("\\w+ ?\\w+"); } @Test public void key() { - assertThat(faker.music().key(), matchesRegularExpression("([A-Z])+(b|#){0,1}")); + assertThat(faker.music().key()).matches("([A-Z])+(b|#){0,1}"); } @Test public void chord() { - assertThat(faker.music().chord(), matchesRegularExpression("([A-Z])+(b|#){0,1}+(-?[a-zA-Z0-9]{0,4})")); + assertThat(faker.music().chord()).matches("([A-Z])+(b|#){0,1}+(-?[a-zA-Z0-9]{0,4})"); } @Test public void genre() { - assertThat(faker.music().genre(), matchesRegularExpression("[[ -]?\\w+]+")); + assertThat(faker.music().genre()).matches("[[ -]?\\w+]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/NameTest.java b/src/test/java/org/thejavaguy/javafaker/NameTest.java index 8f415d0..bcbf203 100644 --- a/src/test/java/org/thejavaguy/javafaker/NameTest.java +++ b/src/test/java/org/thejavaguy/javafaker/NameTest.java @@ -1,11 +1,8 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.IsEqual.equalTo; -import static org.hamcrest.core.IsNot.not; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; @@ -16,12 +13,12 @@ public class NameTest extends AbstractFakerTest{ @Test public void testName() { - assertThat(faker.name().name(), matchesRegularExpression("([\\w']+\\.?( )?){2,3}")); + assertThat(faker.name().name()).matches("([\\w']+\\.?( )?){2,3}"); } @Test public void testNameWithMiddle() { - assertThat(faker.name().nameWithMiddle(), matchesRegularExpression("([\\w']+\\.?( )?){3,4}")); + assertThat(faker.name().nameWithMiddle()).matches("([\\w']+\\.?( )?){3,4}"); } @TestTemplate @Repeat(times = 10) @@ -30,42 +27,42 @@ public void testNameWithMiddleDoesNotHaveRepeatedName() { String[] splitNames = nameWithMiddle.split(" "); String firstName = splitNames[0]; String middleName = splitNames[1]; - assertThat(firstName, not(equalTo(middleName))); + assertThat(firstName).isNotEqualTo(middleName); } @Test public void testFullName() { - assertThat(faker.name().fullName(), matchesRegularExpression("([\\w']+\\.?( )?){2,4}")); + assertThat(faker.name().fullName()).matches("([\\w']+\\.?( )?){2,4}"); } @Test public void testFirstName() { - assertThat(faker.name().firstName(), matchesRegularExpression("\\w+")); + assertThat(faker.name().firstName()).matches("\\w+"); } @Test public void testLastName() { - assertThat(faker.name().lastName(), matchesRegularExpression("[A-Za-z']+")); + assertThat(faker.name().lastName()).matches("[A-Za-z']+"); } @Test public void testPrefix() { - assertThat(faker.name().prefix(), matchesRegularExpression("\\w+\\.?")); + assertThat(faker.name().prefix()).matches("\\w+\\.?"); } @Test public void testSuffix() { - assertThat(faker.name().suffix(), matchesRegularExpression("\\w+\\.?")); + assertThat(faker.name().suffix()).matches("\\w+\\.?"); } @Test public void testTitle() { - assertThat(faker.name().title(), matchesRegularExpression("(\\w+\\.?( )?){3}")); + assertThat(faker.name().title()).matches("(\\w+\\.?( )?){3}"); } @Test public void testUsername() { - assertThat(faker.name().username(), matchesRegularExpression("^(\\w+)\\.(\\w+)$")); + assertThat(faker.name().username()).matches("^(\\w+)\\.(\\w+)$"); } @Test @@ -73,12 +70,12 @@ public void testUsernameWithSpaces() { final Name name = spy(new Name(faker)); doReturn("Compound Name").when(name).firstName(); doReturn(name).when(faker).name(); - assertThat(faker.name().username(), matchesRegularExpression("^(\\w+)\\.(\\w+)$")); + assertThat(faker.name().username()).matches("^(\\w+)\\.(\\w+)$"); } @Test public void testBloodGroup() { - assertThat(faker.name().bloodGroup(), matchesRegularExpression("(A|B|AB|O)[+-]")); + assertThat(faker.name().bloodGroup()).matches("(A|B|AB|O)[+-]"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/NationTest.java b/src/test/java/org/thejavaguy/javafaker/NationTest.java index 58de0a2..83fcd4f 100644 --- a/src/test/java/org/thejavaguy/javafaker/NationTest.java +++ b/src/test/java/org/thejavaguy/javafaker/NationTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.is; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,17 +8,17 @@ public class NationTest extends AbstractFakerTest { @Test public void nationality() { - assertThat(faker.nation().nationality(), matchesRegularExpression("\\P{Cc}+")); + assertThat(faker.nation().nationality()).matches("\\P{Cc}+"); } @Test public void language() { - assertThat(faker.nation().language(), matchesRegularExpression("[A-Za-z ]+")); + assertThat(faker.nation().language()).matches("[A-Za-z ]+"); } @Test public void capitalCity() { - assertThat(faker.nation().capitalCity(), matchesRegularExpression("[A-Za-z .'()-]+")); + assertThat(faker.nation().capitalCity()).matches("[A-Za-z .'()-]+"); } @Test @@ -29,8 +26,8 @@ public void flag() { String flag = faker.nation().flag(); // all utf8 emoji flags are at least 4 characters long and start with the same char - assertThat(flag.length(), is(greaterThanOrEqualTo(4))); - assertThat(flag.charAt(0), is('\uD83C')); + assertThat(flag.length()).isGreaterThanOrEqualTo(4); + assertThat(flag.charAt(0)).isEqualTo('\uD83C'); } } diff --git a/src/test/java/org/thejavaguy/javafaker/NumberTest.java b/src/test/java/org/thejavaguy/javafaker/NumberTest.java index fb06db0..38a46e6 100644 --- a/src/test/java/org/thejavaguy/javafaker/NumberTest.java +++ b/src/test/java/org/thejavaguy/javafaker/NumberTest.java @@ -1,14 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.lessThanOrEqualTo; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.math.BigDecimal; import java.util.List; @@ -43,11 +35,11 @@ public void testRandomDigit() { Set nums = Sets.newHashSet(); for (int i = 0; i < 1000; ++i) { int value = faker.number().randomDigit(); - assertThat(value, is(lessThanOrEqualTo(9))); - assertThat(value, is(greaterThanOrEqualTo(0))); + assertThat(value).isLessThanOrEqualTo(9); + assertThat(value).isGreaterThanOrEqualTo(0); nums.add(value); } - assertThat(nums, contains(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)); + assertThat(nums).containsExactly(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } @Test @@ -55,25 +47,25 @@ public void testRandomDigitNotZero() { Set nums = Sets.newHashSet(); for (int i = 0; i < 1000; ++i) { int value = faker.number().randomDigitNotZero(); - assertThat(value, is(lessThanOrEqualTo(9))); - assertThat(value, is(greaterThan(0))); + assertThat(value).isLessThanOrEqualTo(9); + assertThat(value).isGreaterThan(0); nums.add(value); } - assertThat(nums, contains(1, 2, 3, 4, 5, 6, 7, 8, 9)); + assertThat(nums).containsExactly(1, 2, 3, 4, 5, 6, 7, 8, 9); } @Test public void testRandomNumber() { long value = faker.number().randomNumber(); - assertThat(value, is(lessThan(Long.MAX_VALUE))); + assertThat(value).isLessThan(Long.MAX_VALUE); } @Test public void testRandomNumberWithSingleDigitStrict() { for (int i = 0; i < 100; ++i) { long value = faker.number().randomNumber(1, true); - assertThat(value, is(lessThan(10L))); - assertThat(value, is(greaterThanOrEqualTo(0L))); + assertThat(value).isLessThan(10L); + assertThat(value).isGreaterThanOrEqualTo(0L); } } @@ -81,7 +73,7 @@ public void testRandomNumberWithSingleDigitStrict() { public void testRandomNumberWithZeroDigitsStrict() { for (int i = 0; i < 100; ++i) { long value = faker.number().randomNumber(0, true); - assertThat(value, is(0L)); + assertThat(value).isEqualTo(0L); } } @@ -91,7 +83,7 @@ public void testRandomNumberWithGivenDigitsStrict() { for (int x = 0; x < 100; ++x) { long value = faker.number().randomNumber(i, true); String stringValue = String.valueOf(value); - assertThat(stringValue.length(), is(i)); + assertThat(stringValue.length()).isEqualTo(i); } } } @@ -104,7 +96,7 @@ public void testRandomDouble() { String strVal = BigDecimal.valueOf(value).stripTrailingZeros().toString(); if (strVal.contains(".") && !strVal.contains("+")) { int ind = strVal.indexOf("."); - assertThat(strVal.length() - ind - 1, is(lessThanOrEqualTo(i))); + assertThat(strVal.length() - ind - 1).isLessThanOrEqualTo(i); } } } @@ -114,20 +106,20 @@ public void testRandomDouble() { public void testNumberBetween() { for (int i = 1; i < 100; ++i) { int v = faker.number().numberBetween(0, i); - assertThat(v, is(lessThanOrEqualTo(i))); - assertThat(v, is(greaterThanOrEqualTo(0))); + assertThat(v).isLessThanOrEqualTo(i); + assertThat(v).isGreaterThanOrEqualTo(0); } for (long i = 1L; i < 100L; ++i) { long v = faker.number().numberBetween(0, i); - assertThat(v, is(lessThanOrEqualTo(i))); - assertThat(v, is(greaterThanOrEqualTo(0L))); + assertThat(v).isLessThanOrEqualTo(i); + assertThat(v).isGreaterThanOrEqualTo(0L); } int min1 = 1; long v1 = faker.number().numberBetween(min1, 980000000L); - assertThat(v1, is(greaterThan((long) min1))); - assertThat(v1, is(lessThan(980000000L))); + assertThat(v1).isGreaterThan((long) min1); + assertThat(v1).isLessThan(980000000L); } @TestTemplate @@ -136,8 +128,8 @@ public void testLongNumberBetweenRepeated() { long low = 1; long high = 10; long v = faker.number().numberBetween(low, high); - assertThat(v, is(lessThan(high))); - assertThat(v, is(greaterThanOrEqualTo(low))); + assertThat(v).isLessThan(high); + assertThat(v).isGreaterThanOrEqualTo(low); } @TestTemplate @@ -146,8 +138,8 @@ public void testIntNumberBetweenRepeated() { int low = 1; int high = 10; int v = faker.number().numberBetween(low, high); - assertThat(v, is(lessThan(high))); - assertThat(v, is(greaterThanOrEqualTo(low))); + assertThat(v).isLessThan(high); + assertThat(v).isGreaterThanOrEqualTo(low); } @Test @@ -157,11 +149,11 @@ public void testNumberBetweenOneAndThree() { final int upperLimit = 3; for (int i = 0; i < 1000; ++i) { int value = faker.number().numberBetween(lowerLimit, upperLimit); - assertThat(value, is(lessThan(upperLimit))); - assertThat(value, is(greaterThanOrEqualTo(lowerLimit))); + assertThat(value).isLessThan(upperLimit); + assertThat(value).isGreaterThanOrEqualTo(lowerLimit); nums.add(value); } - assertThat(nums, contains(0, 1, 2)); + assertThat(nums).containsExactly(0, 1, 2); } @Test @@ -171,31 +163,23 @@ public void testLongBetweenOneAndThree() { final long upperLimit = 3; for (int i = 0; i < 1000; ++i) { long value = faker.number().numberBetween(lowerLimit, upperLimit); - assertThat(value, is(lessThan(upperLimit))); - assertThat(value, is(greaterThanOrEqualTo(lowerLimit))); + assertThat(value).isLessThan(upperLimit); + assertThat(value).isGreaterThanOrEqualTo(lowerLimit); nums.add(value); } - assertThat(nums, contains(0L, 1L, 2L)); + assertThat(nums).containsExactly(0L, 1L, 2L); } @Test public void numberBetweenIntIntZeroMinMax() { - assertThat("Calling numberBetween with min==max yields min, with 0", - faker.number().numberBetween(0, 0), - is(0)); - assertThat("Calling numberBetween with min==max yields min", - faker.number().numberBetween(2, 2), - is(2)); + assertThat(faker.number().numberBetween(0, 0)).as("Calling numberBetween with min==max yields min, with 0").isEqualTo(0); + assertThat(faker.number().numberBetween(2, 2)).as("Calling numberBetween with min==max yields min").isEqualTo(2); } @Test public void numberBetweenLongLongZeroMinMax() { - assertThat("Calling numberBetween with min==max yields min, with 0", - faker.number().numberBetween(0L, 0L), - is(0L)); - assertThat("Calling numberBetween with min==max yields min", - faker.number().numberBetween(2L, 2L), - is(2L)); + assertThat(faker.number().numberBetween(0L, 0L)).as("Calling numberBetween with min==max yields min, with 0").isEqualTo(0L); + assertThat(faker.number().numberBetween(2L, 2L)).as("Calling numberBetween with min==max yields min").isEqualTo(2L); } /** @@ -217,14 +201,12 @@ public void randomDoubleRandomizationQuality() { }; final double percentGreaterThan80Percent = randomizationQualityTest(individualRunGtPercentUnique, minMaxRangeToUniquePercentageFunction); - assertThat("Percentage of runs > 80% unique is gte 90%", - percentGreaterThan80Percent, greaterThanOrEqualTo(percentRunsGtUniquePercentage)); + assertThat(percentGreaterThan80Percent).as("Percentage of runs > 80% unique is gte 90%").isGreaterThanOrEqualTo(percentRunsGtUniquePercentage); // this covers Issue # 121, the number of times the function is called with the MIN/MAX values here // is RANDOMIZATION_TESTS_MAX_NUMBERS_TO_GET final double extremeRunUniquePercent = minMaxRangeToUniquePercentageFunction.apply(Pair.of((long) Integer.MIN_VALUE, (long) Integer.MAX_VALUE)); - assertThat("Percentage of extreme runs > 80%", - extremeRunUniquePercent, greaterThanOrEqualTo(individualRunGtPercentUnique)); + assertThat(extremeRunUniquePercent).as("Percentage of extreme runs > 80%").isGreaterThanOrEqualTo(individualRunGtPercentUnique); } /** @@ -247,14 +229,12 @@ public void numberBetweenIntIntRandomizationQuality() { }; final double percentGreaterThan80Percent = randomizationQualityTest(individualRunGtPercentUnique, minMaxRangeToUniquePercentageFunction); - assertThat("Percentage of runs > 80% unique is gte 90%", - percentGreaterThan80Percent, greaterThanOrEqualTo(percentRunsGtUniquePercentage)); + assertThat(percentGreaterThan80Percent).as("Percentage of runs > 80% unique is gte 90%").isGreaterThanOrEqualTo(percentRunsGtUniquePercentage); // this covers Issue # 121, the number of times the function is called with the MIN/MAX values here // is RANDOMIZATION_TESTS_MAX_NUMBERS_TO_GET final double extremeRunUniquePercent = minMaxRangeToUniquePercentageFunction.apply(Pair.of((long) Integer.MIN_VALUE, (long) Integer.MAX_VALUE)); - assertThat("Percentage of extreme runs > 80%", - extremeRunUniquePercent, greaterThanOrEqualTo(individualRunGtPercentUnique)); + assertThat(extremeRunUniquePercent).as("Percentage of extreme runs > 80%").isGreaterThanOrEqualTo(individualRunGtPercentUnique); } /** @@ -276,14 +256,12 @@ public void numberBetweenLongLongRandomizationQuality() { }; final double percentGreaterThan80Percent = randomizationQualityTest(individualRunGtPercentUnique, minMaxRangeToUniquePercentageFunction); - assertThat("Percentage of runs > 80% unique is gte 90%", - percentGreaterThan80Percent, greaterThanOrEqualTo(percentRunsGtUniquePercentage)); + assertThat(percentGreaterThan80Percent).as("Percentage of runs > 80% unique is gte 90%").isGreaterThanOrEqualTo(percentRunsGtUniquePercentage); // this covers Issue # 121, the number of times the function is called with the MIN/MAX values here // is RANDOMIZATION_TESTS_MAX_NUMBERS_TO_GET. final double extremeRunUniquePercent = minMaxRangeToUniquePercentageFunction.apply(Pair.of(Long.MIN_VALUE, Long.MAX_VALUE)); - assertThat("Percentage of extreme runs > 80%", - extremeRunUniquePercent, greaterThanOrEqualTo(individualRunGtPercentUnique)); + assertThat(extremeRunUniquePercent).as("Percentage of extreme runs > 80%").isGreaterThanOrEqualTo(individualRunGtPercentUnique); } @Test @@ -292,21 +270,21 @@ public void testRandomDoubleMaxEqualsMin() { double expected = BigDecimal.valueOf(42).doubleValue(); - assertThat(actual, equalTo(expected)); + assertThat(actual).isEqualTo(expected); } @Test public void testDigit() { String digit = faker.number().digit(); - assertThat(digit, matchesRegularExpression("[0-9]")); + assertThat(digit).matches("[0-9]"); } @Test public void testDigits() { String digits = faker.number().digits(5); - assertThat(digits, matchesRegularExpression("[0-9]{5}")); + assertThat(digits).matches("[0-9]{5}"); } /** diff --git a/src/test/java/org/thejavaguy/javafaker/OptionsTest.java b/src/test/java/org/thejavaguy/javafaker/OptionsTest.java index cb9f6ad..3b74899 100644 --- a/src/test/java/org/thejavaguy/javafaker/OptionsTest.java +++ b/src/test/java/org/thejavaguy/javafaker/OptionsTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.in; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.oneOf; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Arrays; import java.util.List; @@ -22,23 +19,23 @@ public void setupOptions() { @Test public void testOptionWithArray() { - assertThat(faker.options().option(options), is(oneOf(options))); + assertThat(faker.options().option(options)).isIn((Object[]) options); } @Test public void testOptionWithVarargsString() { - assertThat(faker.options().option("A", "B", "C"), is(oneOf(options))); + assertThat(faker.options().option("A", "B", "C")).isIn((Object[]) options); } @Test public void testOptionWithVarargsInteger() { Integer[] integerOptions = new Integer[] { 1, 3, 4, 5}; - assertThat(faker.options().option(1, 3, 4, 5), is(oneOf(integerOptions))); + assertThat(faker.options().option(1, 3, 4, 5)).isIn((Object[]) integerOptions); } @Test public void testOptionWithEnum() { - assertThat(faker.options().option(Day.class), is(oneOf(Day.values()))); + assertThat(faker.options().option(Day.class)).isIn((Object[]) Day.values()); } @Test @@ -46,7 +43,7 @@ public void testNextArrayElement() { Integer[] array = new Integer[] { 1, 2, 3, 5, 8, 13, 21 }; for (int i = 1; i < 10; i++) { - assertThat(faker.options().nextElement(array), is(in(array))); + assertThat(faker.options().nextElement(array)).isIn(array); } } @@ -54,7 +51,7 @@ public void testNextArrayElement() { public void testNextListElement() { List list = Arrays.asList(1, 2, 3, 5, 8, 13, 21); for (int i = 1; i < 10; i++) { - assertThat(faker.options().nextElement(list), is(in(list))); + assertThat(faker.options().nextElement(list)).isIn(list); } } diff --git a/src/test/java/org/thejavaguy/javafaker/OverwatchTest.java b/src/test/java/org/thejavaguy/javafaker/OverwatchTest.java index 93fab05..5e05c8a 100644 --- a/src/test/java/org/thejavaguy/javafaker/OverwatchTest.java +++ b/src/test/java/org/thejavaguy/javafaker/OverwatchTest.java @@ -1,8 +1,7 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; @@ -10,12 +9,12 @@ public class OverwatchTest extends AbstractFakerTest { @Test public void hero() { - assertThat(faker.overwatch().hero(), matchesRegularExpression("^(\\w+\\.?\\s?)+$")); + assertThat(faker.overwatch().hero()).matches("^(\\w+\\.?\\s?)+$"); } @Test public void location() { - assertThat(faker.overwatch().location(), matchesRegularExpression("^(.+'?:?\\s?)+$")); + assertThat(faker.overwatch().location()).matches("^(.+'?:?\\s?)+$"); } @Test diff --git a/src/test/java/org/thejavaguy/javafaker/PhoneNumberTest.java b/src/test/java/org/thejavaguy/javafaker/PhoneNumberTest.java index 6c0a9fc..3e3edf3 100644 --- a/src/test/java/org/thejavaguy/javafaker/PhoneNumberTest.java +++ b/src/test/java/org/thejavaguy/javafaker/PhoneNumberTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -12,40 +11,40 @@ public class PhoneNumberTest extends AbstractFakerTest { @Test public void testCellPhone_enUS() { final Faker f = new Faker(Locale.US); - assertThat(f.phoneNumber().cellPhone(), matchesRegularExpression("\\(?\\d+\\)?([- .]\\d+){1,3}")); + assertThat(f.phoneNumber().cellPhone()).matches("\\(?\\d+\\)?([- .]\\d+){1,3}"); } @Test public void testPhone_esMx() { final Faker f = new Faker(new Locale("es_MX")); for (int i=0;i<100;i++) { - assertThat(f.phoneNumber().cellPhone(), matchesRegularExpression("(044 )?\\(?\\d+\\)?([- .]\\d+){1,3}")); - assertThat(f.phoneNumber().phoneNumber(), matchesRegularExpression("\\(?\\d+\\)?([- .]\\d+){1,3}")); + assertThat(f.phoneNumber().cellPhone()).matches("(044 )?\\(?\\d+\\)?([- .]\\d+){1,3}"); + assertThat(f.phoneNumber().phoneNumber()).matches("\\(?\\d+\\)?([- .]\\d+){1,3}"); } } @Test public void testCellPhone() { - assertThat(faker.phoneNumber().cellPhone(), matchesRegularExpression("\\(?\\d+\\)?([- .]\\d+){1,3}")); + assertThat(faker.phoneNumber().cellPhone()).matches("\\(?\\d+\\)?([- .]\\d+){1,3}"); } @Test public void testPhoneNumber() { - assertThat(faker.phoneNumber().phoneNumber(), matchesRegularExpression("\\(?\\d+\\)?([- .]x?\\d+){1,5}")); + assertThat(faker.phoneNumber().phoneNumber()).matches("\\(?\\d+\\)?([- .]x?\\d+){1,5}"); } @Test public void testExtension() { - assertThat(faker.phoneNumber().extension(), matchesRegularExpression("\\d{4}")); + assertThat(faker.phoneNumber().extension()).matches("\\d{4}"); } @Test public void testSubscriberNumber() { - assertThat(faker.phoneNumber().subscriberNumber(), matchesRegularExpression("\\d{4}")); + assertThat(faker.phoneNumber().subscriberNumber()).matches("\\d{4}"); } @Test public void testSubscriberNumberWithLength() { - assertThat(faker.phoneNumber().subscriberNumber(10), matchesRegularExpression("\\d{10}")); + assertThat(faker.phoneNumber().subscriberNumber(10)).matches("\\d{10}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/PhotographyTest.java b/src/test/java/org/thejavaguy/javafaker/PhotographyTest.java index 9874c54..3c67792 100644 --- a/src/test/java/org/thejavaguy/javafaker/PhotographyTest.java +++ b/src/test/java/org/thejavaguy/javafaker/PhotographyTest.java @@ -1,10 +1,9 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; @@ -58,14 +57,14 @@ public void imageTag() { @Repeat(times=7) public void shutter() { final String value = faker.photography().shutter(); - assertThat(value, matchesRegularExpression("\\d{1,}\\/{0,1}\\d*")); + assertThat(value).matches("\\d{1,}\\/{0,1}\\d*"); } @TestTemplate @Repeat(times=7) public void iso() { final String value = faker.photography().iso(); - assertThat(value, matchesRegularExpression("\\d{1,}")); + assertThat(value).matches("\\d{1,}"); } private static void assertNonNullOrEmpty(String value) { diff --git a/src/test/java/org/thejavaguy/javafaker/PokemonTest.java b/src/test/java/org/thejavaguy/javafaker/PokemonTest.java index 392896f..872f74e 100644 --- a/src/test/java/org/thejavaguy/javafaker/PokemonTest.java +++ b/src/test/java/org/thejavaguy/javafaker/PokemonTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,11 +8,11 @@ public class PokemonTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.pokemon().name(), matchesRegularExpression("[\\w']+.?( \\w+)?")); + assertThat(faker.pokemon().name()).matches("[\\w']+.?( \\w+)?"); } @Test public void location() { - assertThat(faker.pokemon().location(), matchesRegularExpression("\\w+( \\w+)?( \\w+)?")); + assertThat(faker.pokemon().location()).matches("\\w+( \\w+)?( \\w+)?"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/PrincessBrideTest.java b/src/test/java/org/thejavaguy/javafaker/PrincessBrideTest.java index e2a0623..68664b2 100644 --- a/src/test/java/org/thejavaguy/javafaker/PrincessBrideTest.java +++ b/src/test/java/org/thejavaguy/javafaker/PrincessBrideTest.java @@ -1,21 +1,17 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; public class PrincessBrideTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.princessBride().character(), matchesRegularExpression("[A-Za-z .-]+")); + assertThat(faker.princessBride().character()).matches("[A-Za-z .-]+"); } @Test public void quote() { - assertThat(faker.princessBride().quote(), is(not(emptyOrNullString()))); + assertThat(faker.princessBride().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ProgrammingLanguageTest.java b/src/test/java/org/thejavaguy/javafaker/ProgrammingLanguageTest.java index 71faa8a..a6600fc 100644 --- a/src/test/java/org/thejavaguy/javafaker/ProgrammingLanguageTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ProgrammingLanguageTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,12 +8,12 @@ public class ProgrammingLanguageTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.programmingLanguage().name(), matchesRegularExpression("[A-Za-z0-9 :,.+*()#/\\–\\-@πéöü'′!]+")); + assertThat(faker.programmingLanguage().name()).matches("[A-Za-z0-9 :,.+*()#/\\–\\-@πéöü'′!]+"); } @Test public void creator() { - assertThat(faker.programmingLanguage().creator(), matchesRegularExpression("[A-Za-z .,\\-]+")); + assertThat(faker.programmingLanguage().creator()).matches("[A-Za-z .,\\-]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/RandomFakerTest.java b/src/test/java/org/thejavaguy/javafaker/RandomFakerTest.java index 03c282d..a97716f 100644 --- a/src/test/java/org/thejavaguy/javafaker/RandomFakerTest.java +++ b/src/test/java/org/thejavaguy/javafaker/RandomFakerTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Random; @@ -28,7 +27,7 @@ public void testNumerifyRandomnessCanBeControlled() { resetRandomSeed(); final String secondInvocation = faker.numerify("###"); - assertThat(firstInvocation, is(secondInvocation)); + assertThat(firstInvocation).isEqualTo(secondInvocation); } @Test @@ -38,7 +37,7 @@ public void testLetterifyRandomnessCanBeControlled() { resetRandomSeed(); final String secondInvocation = faker.letterify("???"); - assertThat(firstInvocation, is(secondInvocation)); + assertThat(firstInvocation).isEqualTo(secondInvocation); } @Test @@ -48,7 +47,7 @@ public void testNameRandomnessCanBeControlled() { resetRandomSeed(); final String secondInvocation = faker.name().name(); - assertThat(firstInvocation, is(secondInvocation)); + assertThat(firstInvocation).isEqualTo(secondInvocation); } @Test @@ -58,7 +57,7 @@ public void testEmailRandomnessCanBeControlled() { resetRandomSeed(); final String secondInvocation = faker.internet().emailAddress(); - assertThat(firstInvocation, is(secondInvocation)); + assertThat(firstInvocation).isEqualTo(secondInvocation); } private void resetRandomSeed() { diff --git a/src/test/java/org/thejavaguy/javafaker/RelationshipTest.java b/src/test/java/org/thejavaguy/javafaker/RelationshipTest.java index 0c65cd9..6fe459f 100644 --- a/src/test/java/org/thejavaguy/javafaker/RelationshipTest.java +++ b/src/test/java/org/thejavaguy/javafaker/RelationshipTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.when; @@ -25,37 +22,37 @@ public void before() { @Test public void anyTest() { - assertThat(faker.relationships().any(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().any()).isNotEmpty(); } @Test public void directTest() { - assertThat(faker.relationships().direct(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().direct()).isNotEmpty(); } @Test public void extendedTest() { - assertThat(faker.relationships().extended(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().extended()).isNotEmpty(); } @Test public void inLawTest() { - assertThat(faker.relationships().inLaw(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().inLaw()).isNotEmpty(); } @Test public void spouseTest() { - assertThat(faker.relationships().spouse(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().spouse()).isNotEmpty(); } @Test public void parentTest() { - assertThat(faker.relationships().parent(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().parent()).isNotEmpty(); } @Test public void siblingTest() { - assertThat(faker.relationships().sibling(), is(not(emptyOrNullString()))); + assertThat(faker.relationships().sibling()).isNotEmpty(); } @Test diff --git a/src/test/java/org/thejavaguy/javafaker/RickAndMortyTest.java b/src/test/java/org/thejavaguy/javafaker/RickAndMortyTest.java index 2498147..5b910d5 100644 --- a/src/test/java/org/thejavaguy/javafaker/RickAndMortyTest.java +++ b/src/test/java/org/thejavaguy/javafaker/RickAndMortyTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,16 +8,16 @@ public class RickAndMortyTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.rickAndMorty().character(), matchesRegularExpression("^([\\w'-.]+ ?){2,}$")); + assertThat(faker.rickAndMorty().character()).matches("^([\\w'-.]+ ?){2,}$"); } @Test public void location() { - assertThat(faker.rickAndMorty().location(), matchesRegularExpression("^([\\w-.]+ ?){2,}$")); + assertThat(faker.rickAndMorty().location()).matches("^([\\w-.]+ ?){2,}$"); } @Test public void quote() { - assertThat(faker.rickAndMorty().quote(), is(not(emptyOrNullString()))); + assertThat(faker.rickAndMorty().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/RobinTest.java b/src/test/java/org/thejavaguy/javafaker/RobinTest.java index 10747a8..9432f98 100644 --- a/src/test/java/org/thejavaguy/javafaker/RobinTest.java +++ b/src/test/java/org/thejavaguy/javafaker/RobinTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class RobinTest extends AbstractFakerTest { @Test public void quote() { - assertThat(faker.robin().quote(), matchesRegularExpression("^(\\w+\\.?-?'?\\s?)+(\\(?)?(\\w+\\s?\\.?)+(\\))?$")); + assertThat(faker.robin().quote()).matches("^(\\w+\\.?-?'?\\s?)+(\\(?)?(\\w+\\s?\\.?)+(\\))?$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/RockBandTest.java b/src/test/java/org/thejavaguy/javafaker/RockBandTest.java index 969cb57..425a811 100644 --- a/src/test/java/org/thejavaguy/javafaker/RockBandTest.java +++ b/src/test/java/org/thejavaguy/javafaker/RockBandTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,6 +8,6 @@ public class RockBandTest extends AbstractFakerTest { @Test public void name() { - assertThat(faker.rockBand().name(), matchesRegularExpression("([\\w'/.,&]+ ?)+")); + assertThat(faker.rockBand().name()).matches("([\\w'/.,&]+ ?)+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ShakespeareTest.java b/src/test/java/org/thejavaguy/javafaker/ShakespeareTest.java index d1434f2..d91cc7e 100644 --- a/src/test/java/org/thejavaguy/javafaker/ShakespeareTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ShakespeareTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,22 +8,22 @@ public class ShakespeareTest extends AbstractFakerTest{ @Test public void testHamletQuote() { - assertThat(faker.shakespeare().hamletQuote(), is(not(emptyOrNullString()))); + assertThat(faker.shakespeare().hamletQuote()).isNotEmpty(); } @Test public void testAsYouLikeItQuote() { - assertThat(faker.shakespeare().asYouLikeItQuote(), is(not(emptyOrNullString()))); + assertThat(faker.shakespeare().asYouLikeItQuote()).isNotEmpty(); } @Test public void testKingRichardIIIQuote() { - assertThat(faker.shakespeare().kingRichardIIIQuote(), is(not(emptyOrNullString()))); + assertThat(faker.shakespeare().kingRichardIIIQuote()).isNotEmpty(); } @Test public void testRomeoAndJulietQuote() { - assertThat(faker.shakespeare().romeoAndJulietQuote(), is(not(emptyOrNullString()))); + assertThat(faker.shakespeare().romeoAndJulietQuote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/SipTest.java b/src/test/java/org/thejavaguy/javafaker/SipTest.java index c581422..3038af4 100644 --- a/src/test/java/org/thejavaguy/javafaker/SipTest.java +++ b/src/test/java/org/thejavaguy/javafaker/SipTest.java @@ -1,13 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.both; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.startsWith; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -15,127 +8,141 @@ public class SipTest extends AbstractFakerTest { @Test public void method_returnUpperCaseWithMinimum3Chars() { - assertThat(faker.sip().method(), matchesRegularExpression("^[A-Z]{3,}$")); + assertThat(faker.sip().method()).matches("^[A-Z]{3,}$"); } @Test public void contentType_returnLowerCaseTwoWordsSepereatedBySlashMinimum3And4Chars() { - assertThat(faker.sip().contentType(), matchesRegularExpression("^[a-z]{4,}[/]{1,}[a-z0-9-]{3,}$")); + assertThat(faker.sip().contentType()).matches("^[a-z]{4,}[/]{1,}[a-z0-9-]{3,}$"); } @Test public void messagingPort_return4DigitIntBetween1000And9999() { - assertThat(faker.sip().messagingPort(), both(greaterThanOrEqualTo(1000)).and(lessThan(10000))); + assertThat(faker.sip().messagingPort()) + .isGreaterThanOrEqualTo(1000) + .isLessThan(10000); } @Test public void rtpPort_returnPositiveEvenInt() { int sut = faker.sip().rtpPort(); - assertThat(sut, greaterThanOrEqualTo(2)); - assertThat(sut % 2, is(0)); + assertThat(sut).isGreaterThanOrEqualTo(2); + assertThat(sut % 2).isEqualTo(0); } @Test public void provisionalResponseCode_return3DigitIntBetween100And199() { - assertThat(faker.sip().provisionalResponseCode(), both(greaterThanOrEqualTo(100)).and(lessThan(200))); + assertThat(faker.sip().provisionalResponseCode()) + .isGreaterThanOrEqualTo(100) + .isLessThan(200); } @Test public void successResponse_Codereturn3DigitIntBetween200And299() { - assertThat(faker.sip().successResponseCode(), both(greaterThanOrEqualTo(200)).and(lessThan(300))); + assertThat(faker.sip().successResponseCode()) + .isGreaterThanOrEqualTo(200) + .isLessThan(300); } @Test public void redirectResponseCode_Codereturn3DigitIntBetween300And399() { - assertThat(faker.sip().redirectResponseCode(), both(greaterThanOrEqualTo(300)).and(lessThan(400))); + assertThat(faker.sip().redirectResponseCode()) + .isGreaterThanOrEqualTo(300) + .isLessThan(400); } @Test public void clientErrorResponseCode_Codereturn3DigitIntBetween400And499() { - assertThat(faker.sip().clientErrorResponseCode(), both(greaterThanOrEqualTo(400)).and(lessThan(500))); + assertThat(faker.sip().clientErrorResponseCode()) + .isGreaterThanOrEqualTo(400) + .isLessThan(500); } @Test public void serverErrorResponseCode_Codereturn3DigitIntBetween500And599() { - assertThat(faker.sip().serverErrorResponseCode(), both(greaterThanOrEqualTo(500)).and(lessThan(600))); + assertThat(faker.sip().serverErrorResponseCode()) + .isGreaterThanOrEqualTo(500) + .isLessThan(600); } @Test public void globalErrorResponseCode_Codereturn3DigitIntBetween600And699() { - assertThat(faker.sip().globalErrorResponseCode(), both(greaterThanOrEqualTo(600)).and(lessThan(700))); + assertThat(faker.sip().globalErrorResponseCode()) + .isGreaterThanOrEqualTo(600) + .isLessThan(700); } @Test public void provisionalResponsePhrase_returnAnyNonDigitString() { - assertThat(faker.sip().provisionalResponsePhrase(), matchesRegularExpression("\\D+")); + assertThat(faker.sip().provisionalResponsePhrase()).matches("\\D+"); } @Test public void successResponsePhrase_returnAnyNonDigitString() { - assertThat(faker.sip().successResponsePhrase(), matchesRegularExpression("\\D+")); + assertThat(faker.sip().successResponsePhrase()).matches("\\D+"); } @Test public void redirectResponsePhrase_returnAnyNonDigitString() { - assertThat(faker.sip().redirectResponsePhrase(), matchesRegularExpression("\\D+")); + assertThat(faker.sip().redirectResponsePhrase()).matches("\\D+"); } @Test public void clientErrorResponsePhrase_returnAnyNonDigitString() { - assertThat(faker.sip().clientErrorResponsePhrase(), matchesRegularExpression("\\D+")); + assertThat(faker.sip().clientErrorResponsePhrase()).matches("\\D+"); } @Test public void serverErrorResponsePhrase_returnAnyNonDigitString() { - assertThat(faker.sip().serverErrorResponsePhrase(), matchesRegularExpression("\\D+")); + assertThat(faker.sip().serverErrorResponsePhrase()).matches("\\D+"); } @Test public void globalErrorResponsePhrase_returnAnyNonDigitString() { - assertThat(faker.sip().globalErrorResponsePhrase(), matchesRegularExpression("\\D+")); + assertThat(faker.sip().globalErrorResponsePhrase()).matches("\\D+"); } @Test public void bodyString_returnAValidSdpBodyString() { String[] sut = faker.sip().bodyString().split("\n"); - assertThat(sut.length, is(7)); + assertThat(sut.length).isEqualTo(7); - assertThat(sut[0], is("v=0")); + assertThat(sut[0]).isEqualTo("v=0"); String[] secondLine = sut[1].split(" "); - assertThat(secondLine[0], startsWith("o=")); - assertThat(secondLine[1], matchesRegularExpression("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")); - assertThat(secondLine[secondLine.length - 1], matchesRegularExpression("[a-z]+\\.\\w{2,4}")); + assertThat(secondLine[0]).startsWith("o="); + assertThat(secondLine[1]).matches("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"); + assertThat(secondLine[secondLine.length - 1]).matches("[a-z]+\\.\\w{2,4}"); - assertThat(sut[2], is("s=-")); + assertThat(sut[2]).isEqualTo("s=-"); String[] fourthLine = sut[3].split(" "); - assertThat(fourthLine[0], is("c=IN")); - assertThat(fourthLine[fourthLine.length - 1], matchesRegularExpression("^\\d{1,3}.\\d{1,3}.\\d{1,3}.\\d{1,3}$")); + assertThat(fourthLine[0]).isEqualTo("c=IN"); + assertThat(fourthLine[fourthLine.length - 1]).matches("^\\d{1,3}.\\d{1,3}.\\d{1,3}.\\d{1,3}$"); - assertThat(sut[4], is("t=0 0")); + assertThat(sut[4]).isEqualTo("t=0 0"); String[] sixthLine = sut[5].split(" "); - assertThat(sixthLine[0], is("m=audio")); - assertThat(Integer.parseInt(sixthLine[1]), greaterThanOrEqualTo(2)); - assertThat(Integer.parseInt(sixthLine[1]) % 2, is(0)); + assertThat(sixthLine[0]).isEqualTo("m=audio"); + assertThat(Integer.parseInt(sixthLine[1])).isGreaterThanOrEqualTo(2); + assertThat(Integer.parseInt(sixthLine[1]) % 2).isEqualTo(0); - assertThat(sut[6], is("a=rtpmap:0 PCMU/8000")); + assertThat(sut[6]).isEqualTo("a=rtpmap:0 PCMU/8000"); } @Test public void bodyBytes_isNotNull() { byte[] sut = faker.sip().bodyBytes(); - assertThat(sut.length, notNullValue()); + assertThat(sut.length).isNotNull(); } @Test public void nameAddress_returnValidNameAddressString() { String[] sut = faker.sip().nameAddress().split("@"); - assertThat(sut[0].split(":")[1], matchesRegularExpression("\\w+")); - assertThat(sut[1].split(":")[0], matchesRegularExpression("^\\d{1,3}.\\d{1,3}.\\d{1,3}.\\d{1,3}$")); + assertThat(sut[0].split(":")[1]).matches("\\w+"); + assertThat(sut[1].split(":")[0]).matches("^\\d{1,3}.\\d{1,3}.\\d{1,3}.\\d{1,3}$"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/SlackEmojiTest.java b/src/test/java/org/thejavaguy/javafaker/SlackEmojiTest.java index 4097816..8cd729e 100644 --- a/src/test/java/org/thejavaguy/javafaker/SlackEmojiTest.java +++ b/src/test/java/org/thejavaguy/javafaker/SlackEmojiTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,46 +10,46 @@ public class SlackEmojiTest extends AbstractFakerTest { @Test public void people() { - assertThat(faker.slackEmoji().people(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().people()).matches(EMOTICON_REGEX); } @Test public void nature() { - assertThat(faker.slackEmoji().nature(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().nature()).matches(EMOTICON_REGEX); } @Test public void food_and_drink() { - assertThat(faker.slackEmoji().foodAndDrink(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().foodAndDrink()).matches(EMOTICON_REGEX); } @Test public void celebration() { - assertThat(faker.slackEmoji().celebration(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().celebration()).matches(EMOTICON_REGEX); } @Test public void activity() { - assertThat(faker.slackEmoji().activity(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().activity()).matches(EMOTICON_REGEX); } @Test public void travel_and_places() { - assertThat(faker.slackEmoji().travelAndPlaces(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().travelAndPlaces()).matches(EMOTICON_REGEX); } @Test public void objects_and_symbols() { - assertThat(faker.slackEmoji().objectsAndSymbols(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().objectsAndSymbols()).matches(EMOTICON_REGEX); } @Test public void custom() { - assertThat(faker.slackEmoji().custom(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().custom()).matches(EMOTICON_REGEX); } @Test public void emoji() { - assertThat(faker.slackEmoji().emoji(), matchesRegularExpression(EMOTICON_REGEX)); + assertThat(faker.slackEmoji().emoji()).matches(EMOTICON_REGEX); } } diff --git a/src/test/java/org/thejavaguy/javafaker/SpaceTest.java b/src/test/java/org/thejavaguy/javafaker/SpaceTest.java index 49ee1b4..0e5ffe2 100644 --- a/src/test/java/org/thejavaguy/javafaker/SpaceTest.java +++ b/src/test/java/org/thejavaguy/javafaker/SpaceTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,66 +8,66 @@ public class SpaceTest extends AbstractFakerTest { @Test public void planet() { - assertThat(faker.space().planet(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().planet()).matches("(\\w+ ?){2,3}"); } @Test public void moon() { - assertThat(faker.space().moon(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().moon()).matches("(\\w+ ?){2,3}"); } @Test public void galaxy() { - assertThat(faker.space().galaxy(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().galaxy()).matches("(\\w+ ?){2,3}"); } @Test public void nebula() { - assertThat(faker.space().nebula(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().nebula()).matches("(\\w+ ?){2,3}"); } @Test public void starCluster() { - assertThat(faker.space().starCluster(), matchesRegularExpression("(\\w+[ -]?){1,3}")); + assertThat(faker.space().starCluster()).matches("(\\w+[ -]?){1,3}"); } @Test public void constellation() { - assertThat(faker.space().constellation(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().constellation()).matches("(\\w+ ?){2,3}"); } @Test public void star() { - assertThat(faker.space().star(), matchesRegularExpression("(\\w+[ -]?){2,3}")); + assertThat(faker.space().star()).matches("(\\w+[ -]?){2,3}"); } @Test public void agency() { - assertThat(faker.space().agency(), matchesRegularExpression("(\\w+ ?){2,5}")); + assertThat(faker.space().agency()).matches("(\\w+ ?){2,5}"); } @Test public void agencyAbbreviation() { - assertThat(faker.space().agencyAbbreviation(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().agencyAbbreviation()).matches("(\\w+ ?){2,3}"); } @Test public void nasaSpaceCraft() { - assertThat(faker.space().nasaSpaceCraft(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().nasaSpaceCraft()).matches("(\\w+ ?){2,3}"); } @Test public void company() { - assertThat(faker.space().company(), matchesRegularExpression("((\\w|')+ ?){2,4}")); + assertThat(faker.space().company()).matches("((\\w|')+ ?){2,4}"); } @Test public void distanceMeasurement() { - assertThat(faker.space().distanceMeasurement(), matchesRegularExpression("(\\w+ ?){2,3}")); + assertThat(faker.space().distanceMeasurement()).matches("(\\w+ ?){2,3}"); } @Test public void meteorite() { - assertThat(faker.space().meteorite(), matchesRegularExpression("(?U)([\\w()]+[ -–]?){1,4}")); + assertThat(faker.space().meteorite()).matches("(?U)([\\w()]+[ -–]?){1,4}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/StarCraftTest.java b/src/test/java/org/thejavaguy/javafaker/StarCraftTest.java index c93ae11..fa60299 100644 --- a/src/test/java/org/thejavaguy/javafaker/StarCraftTest.java +++ b/src/test/java/org/thejavaguy/javafaker/StarCraftTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -15,29 +11,29 @@ public class StarCraftTest extends AbstractFakerTest { @Test public void testUnit() { String unit = faker.starCraft().unit(); - assertThat(unit, is(not(emptyOrNullString()))); - assertThat(unit, matchesRegularExpression(noLeadingTrailingWhitespaceRegex)); + assertThat(unit).isNotEmpty(); + assertThat(unit).matches(noLeadingTrailingWhitespaceRegex); } @Test public void testBuilding() { String building = faker.starCraft().building(); - assertThat(building, is(not(emptyOrNullString()))); - assertThat(building, matchesRegularExpression(noLeadingTrailingWhitespaceRegex)); + assertThat(building).isNotEmpty(); + assertThat(building).matches(noLeadingTrailingWhitespaceRegex); } @Test public void testCharacter() { String character = faker.starCraft().character(); - assertThat(character, is(not(emptyOrNullString()))); - assertThat(character, matchesRegularExpression(noLeadingTrailingWhitespaceRegex)); + assertThat(character).isNotEmpty(); + assertThat(character).matches(noLeadingTrailingWhitespaceRegex); } @Test public void testPlanet() { String planet = faker.starCraft().planet(); - assertThat(planet, is(not(emptyOrNullString()))); - assertThat(planet, matchesRegularExpression(noLeadingTrailingWhitespaceRegex)); + assertThat(planet).isNotEmpty(); + assertThat(planet).matches(noLeadingTrailingWhitespaceRegex); } } diff --git a/src/test/java/org/thejavaguy/javafaker/StarTrekTest.java b/src/test/java/org/thejavaguy/javafaker/StarTrekTest.java index a75ef15..b2b8c69 100644 --- a/src/test/java/org/thejavaguy/javafaker/StarTrekTest.java +++ b/src/test/java/org/thejavaguy/javafaker/StarTrekTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,24 +8,24 @@ public class StarTrekTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.starTrek().character(), matchesRegularExpression("^(\\w+-?'?\\.?\\s?)+$")); + assertThat(faker.starTrek().character()).matches("^(\\w+-?'?\\.?\\s?)+$"); } @Test public void location() { - assertThat(faker.starTrek().location(), matchesRegularExpression("^(\\w+'?\\s?)+$")); + assertThat(faker.starTrek().location()).matches("^(\\w+'?\\s?)+$"); } @Test public void specie() { - assertThat(faker.starTrek().specie(), matchesRegularExpression("^(\\w+-?'?\\s?)+$")); + assertThat(faker.starTrek().specie()).matches("^(\\w+-?'?\\s?)+$"); } @Test public void villain() { - assertThat(faker.starTrek().villain(), matchesRegularExpression("^(\\w+'?\\.?\\s?)+$")); + assertThat(faker.starTrek().villain()).matches("^(\\w+'?\\.?\\s?)+$"); } @Test - public void klingon() { assertThat(faker.starTrek().klingon(), is(not(emptyOrNullString()))); } + public void klingon() { assertThat(faker.starTrek().klingon()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/StockTest.java b/src/test/java/org/thejavaguy/javafaker/StockTest.java index a1cdd22..0b202c6 100644 --- a/src/test/java/org/thejavaguy/javafaker/StockTest.java +++ b/src/test/java/org/thejavaguy/javafaker/StockTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -11,12 +8,12 @@ public class StockTest extends AbstractFakerTest { @Test public void testNasdaq() { - assertThat(faker.stock().nsdqSymbol(), is(not(emptyOrNullString()))); + assertThat(faker.stock().nsdqSymbol()).isNotEmpty(); } @Test public void testNYSE() { - assertThat(faker.stock().nyseSymbol(), is(not(emptyOrNullString()))); + assertThat(faker.stock().nyseSymbol()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/SuperheroTest.java b/src/test/java/org/thejavaguy/javafaker/SuperheroTest.java index 09be4a2..22bbf7d 100644 --- a/src/test/java/org/thejavaguy/javafaker/SuperheroTest.java +++ b/src/test/java/org/thejavaguy/javafaker/SuperheroTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,26 +8,26 @@ public class SuperheroTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.superhero().name(), matchesRegularExpression("[A-Za-z' -/]+")); + assertThat(faker.superhero().name()).matches("[A-Za-z' -/]+"); } @Test public void testPrefix() { - assertThat(faker.superhero().prefix(), matchesRegularExpression("[A-Za-z -]+")); + assertThat(faker.superhero().prefix()).matches("[A-Za-z -]+"); } @Test public void testSuffix() { - assertThat(faker.superhero().suffix(), matchesRegularExpression("[A-Za-z -]+")); + assertThat(faker.superhero().suffix()).matches("[A-Za-z -]+"); } @Test public void testPower() { - assertThat(faker.superhero().power(), matchesRegularExpression("[A-Za-z/ -]+")); + assertThat(faker.superhero().power()).matches("[A-Za-z/ -]+"); } @Test public void testDescriptor() { - assertThat(faker.superhero().descriptor(), matchesRegularExpression("[A-Za-z' -]+")); + assertThat(faker.superhero().descriptor()).matches("[A-Za-z' -]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/TeamTest.java b/src/test/java/org/thejavaguy/javafaker/TeamTest.java index aaf5dab..ac7d5d4 100644 --- a/src/test/java/org/thejavaguy/javafaker/TeamTest.java +++ b/src/test/java/org/thejavaguy/javafaker/TeamTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -12,28 +10,28 @@ public class TeamTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.team().name(), matchesRegularExpression("(\\w+( )?){2,4}")); + assertThat(faker.team().name()).matches("(\\w+( )?){2,4}"); } @Test public void testCreature() { - assertThat(faker.team().creature(), matchesRegularExpression("\\w+( \\w+)?")); + assertThat(faker.team().creature()).matches("\\w+( \\w+)?"); } @Test public void testState() { - assertThat(faker.team().state(), matchesRegularExpression("(\\w+( )?){1,2}")); + assertThat(faker.team().state()).matches("(\\w+( )?){1,2}"); } @Test public void testStateWithZaLocale() { Faker zaFaker = new Faker(new Locale("en-ZA")); - assertThat(zaFaker.team().state(), isStringWithContents()); + assertThat(zaFaker.team().state()).isNotBlank(); } @Test public void testSport() { - assertThat(faker.team().sport(), matchesRegularExpression("(\\p{L}|\\s)+")); + assertThat(faker.team().sport()).matches("(\\p{L}|\\s)+"); } diff --git a/src/test/java/org/thejavaguy/javafaker/TwinPeaksTest.java b/src/test/java/org/thejavaguy/javafaker/TwinPeaksTest.java index 9976b54..e58e165 100644 --- a/src/test/java/org/thejavaguy/javafaker/TwinPeaksTest.java +++ b/src/test/java/org/thejavaguy/javafaker/TwinPeaksTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,16 +8,16 @@ public class TwinPeaksTest extends AbstractFakerTest { @Test public void character() { - assertThat(faker.twinPeaks().character(), matchesRegularExpression("^([\\w']+ ?){2,}$")); + assertThat(faker.twinPeaks().character()).matches("^([\\w']+ ?){2,}$"); } @Test public void location() { - assertThat(faker.twinPeaks().location(), matchesRegularExpression("^[A-Za-z0-9'&,\\- ]+$")); + assertThat(faker.twinPeaks().location()).matches("^[A-Za-z0-9'&,\\- ]+$"); } @Test public void quote() { - assertThat(faker.twinPeaks().quote(), is(not(emptyOrNullString()))); + assertThat(faker.twinPeaks().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/UniversityTest.java b/src/test/java/org/thejavaguy/javafaker/UniversityTest.java index 3acdd87..a950a3d 100644 --- a/src/test/java/org/thejavaguy/javafaker/UniversityTest.java +++ b/src/test/java/org/thejavaguy/javafaker/UniversityTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,16 +8,16 @@ public class UniversityTest extends AbstractFakerTest { @Test public void testName() { - assertThat(faker.university().name(), matchesRegularExpression("[A-Za-z'() ]+")); + assertThat(faker.university().name()).matches("[A-Za-z'() ]+"); } @Test public void testPrefix() { - assertThat(faker.university().prefix(), matchesRegularExpression("\\w+")); + assertThat(faker.university().prefix()).matches("\\w+"); } @Test public void testSuffix() { - assertThat(faker.university().suffix(), matchesRegularExpression("\\w+")); + assertThat(faker.university().suffix()).matches("\\w+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/WeatherTest.java b/src/test/java/org/thejavaguy/javafaker/WeatherTest.java index fd88df3..19c05f3 100644 --- a/src/test/java/org/thejavaguy/javafaker/WeatherTest.java +++ b/src/test/java/org/thejavaguy/javafaker/WeatherTest.java @@ -1,10 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -12,30 +8,30 @@ public class WeatherTest extends AbstractFakerTest { @Test public void description() { - assertThat(faker.weather().description(), is(not(emptyOrNullString()))); + assertThat(faker.weather().description()).isNotEmpty(); } @Test public void temperatureCelsius() { - assertThat(faker.weather().temperatureCelsius(), matchesRegularExpression("[-]?\\d+°C")); + assertThat(faker.weather().temperatureCelsius()).matches("[-]?\\d+°C"); } @Test public void temperatureFahrenheit() { - assertThat(faker.weather().temperatureFahrenheit(), matchesRegularExpression("[-]?\\d+°F")); + assertThat(faker.weather().temperatureFahrenheit()).matches("[-]?\\d+°F"); } @Test public void temperatureCelsiusInRange() { for (int i = 1; i < 100; i++) { - assertThat(faker.weather().temperatureCelsius(-5, 5), matchesRegularExpression("[-]?[0-5]°C")); + assertThat(faker.weather().temperatureCelsius(-5, 5)).matches("[-]?[0-5]°C"); } } @Test public void temperatureFahrenheitInRange() { for (int i = 1; i < 100; i++) { - assertThat(faker.weather().temperatureFahrenheit(-5, 5), matchesRegularExpression("[-]?[0-5]°F")); + assertThat(faker.weather().temperatureFahrenheit(-5, 5)).matches("[-]?[0-5]°F"); } } } diff --git a/src/test/java/org/thejavaguy/javafaker/WitcherTest.java b/src/test/java/org/thejavaguy/javafaker/WitcherTest.java index 4b71e75..3c80afe 100644 --- a/src/test/java/org/thejavaguy/javafaker/WitcherTest.java +++ b/src/test/java/org/thejavaguy/javafaker/WitcherTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,31 +8,31 @@ public class WitcherTest extends AbstractFakerTest { @Test public void testCharacter() { - assertThat(faker.witcher().character(), matchesRegularExpression("[A-Za-z' -éúï]+")); + assertThat(faker.witcher().character()).matches("[A-Za-z' -éúï]+"); } @Test public void testWitcher() { - assertThat(faker.witcher().witcher(), matchesRegularExpression("[A-Za-z -ëúï]+")); + assertThat(faker.witcher().witcher()).matches("[A-Za-z -ëúï]+"); } @Test public void testSchool() { - assertThat(faker.witcher().school(), matchesRegularExpression("[A-Za-z]+")); + assertThat(faker.witcher().school()).matches("[A-Za-z]+"); } @Test public void testLocation() { - assertThat(faker.witcher().location(), matchesRegularExpression("[A-Za-z -áâé]+")); + assertThat(faker.witcher().location()).matches("[A-Za-z -áâé]+"); } @Test public void testQuote() { - assertThat(faker.witcher().quote(), matchesRegularExpression("[-A-Za-z0-9 —;…\\?\\!\\.’‘'”“,\\[\\]]+")); + assertThat(faker.witcher().quote()).matches("[-A-Za-z0-9 —;…\\?\\!\\.’‘'”“,\\[\\]]+"); } @Test public void testMonster() { - assertThat(faker.witcher().monster(), matchesRegularExpression("[A-Za-z -]+")); + assertThat(faker.witcher().monster()).matches("[A-Za-z -]+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/YodaTest.java b/src/test/java/org/thejavaguy/javafaker/YodaTest.java index c00e78f..5c2ee04 100644 --- a/src/test/java/org/thejavaguy/javafaker/YodaTest.java +++ b/src/test/java/org/thejavaguy/javafaker/YodaTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -14,6 +11,6 @@ public class YodaTest extends AbstractFakerTest { @Test public void quote() { - assertThat(faker.yoda().quote(), is(not(emptyOrNullString()))); + assertThat(faker.yoda().quote()).isNotEmpty(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/ZeldaTest.java b/src/test/java/org/thejavaguy/javafaker/ZeldaTest.java index 518897a..4034b5b 100644 --- a/src/test/java/org/thejavaguy/javafaker/ZeldaTest.java +++ b/src/test/java/org/thejavaguy/javafaker/ZeldaTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; @@ -9,11 +8,11 @@ public class ZeldaTest extends AbstractFakerTest { @Test public void game() { - assertThat(faker.zelda().game(), matchesRegularExpression("[A-Za-z'\\- :]+")); + assertThat(faker.zelda().game()).matches("[A-Za-z'\\- :]+"); } @Test public void character() { - assertThat(faker.zelda().character(), matchesRegularExpression("(?U)([\\w'\\-.\\(\\)]+ ?)+")); + assertThat(faker.zelda().character()).matches("(?U)([\\w'\\-.\\(\\)]+ ?)+"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/idnumbers/SwedishIdNumberTest.java b/src/test/java/org/thejavaguy/javafaker/idnumbers/SwedishIdNumberTest.java index 5ab7e64..602853a 100644 --- a/src/test/java/org/thejavaguy/javafaker/idnumbers/SwedishIdNumberTest.java +++ b/src/test/java/org/thejavaguy/javafaker/idnumbers/SwedishIdNumberTest.java @@ -1,7 +1,7 @@ package org.thejavaguy.javafaker.idnumbers; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.Is.is; +import static org.assertj.core.api.Assertions.assertThat; + import org.junit.jupiter.api.Test; @@ -10,18 +10,18 @@ public class SwedishIdNumberTest { @Test public void valid() { SvSEIdNumber idNumber = new SvSEIdNumber(); - assertThat(idNumber.validSwedishSsn("670919-9530"), is(true)); - assertThat(idNumber.validSwedishSsn("811228-9874"), is(true)); + assertThat(idNumber.validSwedishSsn("670919-9530")).isEqualTo(true); + assertThat(idNumber.validSwedishSsn("811228-9874")).isEqualTo(true); } @Test public void invalid() { SvSEIdNumber idNumber = new SvSEIdNumber(); - assertThat(idNumber.validSwedishSsn("8112289873"), is(false)); - assertThat(idNumber.validSwedishSsn("foo228-9873"), is(false)); - assertThat(idNumber.validSwedishSsn("811228-9873"), is(false)); - assertThat(idNumber.validSwedishSsn("811228-9875"), is(false)); - assertThat(idNumber.validSwedishSsn("811200-9874"), is(false)); - assertThat(idNumber.validSwedishSsn("810028-9874"), is(false)); + assertThat(idNumber.validSwedishSsn("8112289873")).isEqualTo(false); + assertThat(idNumber.validSwedishSsn("foo228-9873")).isEqualTo(false); + assertThat(idNumber.validSwedishSsn("811228-9873")).isEqualTo(false); + assertThat(idNumber.validSwedishSsn("811228-9875")).isEqualTo(false); + assertThat(idNumber.validSwedishSsn("811200-9874")).isEqualTo(false); + assertThat(idNumber.validSwedishSsn("810028-9874")).isEqualTo(false); } } diff --git a/src/test/java/org/thejavaguy/javafaker/integration/FakerIT.java b/src/test/java/org/thejavaguy/javafaker/integration/FakerIT.java index 41b0fc2..4aabde1 100644 --- a/src/test/java/org/thejavaguy/javafaker/integration/FakerIT.java +++ b/src/test/java/org/thejavaguy/javafaker/integration/FakerIT.java @@ -1,14 +1,6 @@ package org.thejavaguy.javafaker.integration; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.allOf; -import static org.hamcrest.Matchers.emptyOrNullString; -import static org.hamcrest.Matchers.endsWith; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.hamcrest.Matchers.startsWith; -import static org.hamcrest.core.IsNull.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.reflections.ReflectionUtils.getAllMethods; import static org.reflections.ReflectionUtils.withModifier; import static org.reflections.ReflectionUtils.withParametersCount; @@ -208,11 +200,12 @@ private void testAllMethodsThatReturnStringsActuallyReturnStrings(Object object) final Object returnValue = method.invoke(object); logger.info("{} {}.{} = {}", locale, object.getClass().getSimpleName().toLowerCase(), method.getName(), returnValue); String failureReason = method + " on " + object; - assertThat(failureReason, returnValue, is(instanceOf(String.class))); + assertThat(returnValue).as(failureReason).isInstanceOf(String.class); final String returnValueAsString = (String) returnValue; - assertThat(failureReason, returnValueAsString, is(not(emptyOrNullString()))); - assertThat(failureReason + " is a slash encoded regex", returnValueAsString, - not(allOf(startsWith("/"), endsWith("/")))); + assertThat(returnValueAsString).as(failureReason).isNotEmpty(); + assertThat(returnValueAsString) + .as(failureReason + " is a slash encoded regex") + .doesNotMatch("^/.*/$"); } } @@ -226,20 +219,20 @@ private boolean isExcepted(Object object, Method method) { @ParameterizedTest(name = "testing locale {0} and random {1}") public void testExceptionsNotCoveredInAboveTest(Locale locale,Random random) { initFakerIT(locale, random); - assertThat(faker.bothify("####???"), is(notNullValue())); - assertThat(faker.letterify("????"), is(notNullValue())); - assertThat(faker.numerify("####"), is(notNullValue())); + assertThat(faker.bothify("####???")).isNotNull(); + assertThat(faker.letterify("????")).isNotNull(); + assertThat(faker.numerify("####")).isNotNull(); - assertThat(faker.lorem().paragraph(1), is(notNullValue())); - assertThat(faker.lorem().paragraphs(1), is(notNullValue())); + assertThat(faker.lorem().paragraph(1)).isNotNull(); + assertThat(faker.lorem().paragraphs(1)).isNotNull(); - assertThat(faker.lorem().sentence(1), is(notNullValue())); - assertThat(faker.lorem().sentences(1), is(notNullValue())); + assertThat(faker.lorem().sentence(1)).isNotNull(); + assertThat(faker.lorem().sentences(1)).isNotNull(); - assertThat(faker.address().streetAddress(), is(notNullValue())); + assertThat(faker.address().streetAddress()).isNotNull(); - assertThat(faker.lorem().words(), is(notNullValue())); - assertThat(faker.lorem().words(1), is(notNullValue())); + assertThat(faker.lorem().words()).isNotNull(); + assertThat(faker.lorem().words(1)).isNotNull(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/integration/Issue194SlashFormatRegexIT.java b/src/test/java/org/thejavaguy/javafaker/integration/Issue194SlashFormatRegexIT.java index f4e1f72..b0a5c7d 100644 --- a/src/test/java/org/thejavaguy/javafaker/integration/Issue194SlashFormatRegexIT.java +++ b/src/test/java/org/thejavaguy/javafaker/integration/Issue194SlashFormatRegexIT.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker.integration; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -18,7 +17,7 @@ public void enGBZipCodeReturnsProperRegexifiedValue() { final String postalCode = new Faker(uk).address().zipCode(); - assertThat(postalCode, matchesRegularExpression("[A-PR-UWYZ]([A-HK-Y][0-9][ABEHMNPRVWXY0-9]?|[0-9][ABCDEFGHJKPSTUW0-9]?) [0-9][ABD-HJLNP-UW-Z]{2}")); + assertThat(postalCode).matches("[A-PR-UWYZ]([A-HK-Y][0-9][ABEHMNPRVWXY0-9]?|[0-9][ABCDEFGHJKPSTUW0-9]?) [0-9][ABD-HJLNP-UW-Z]{2}"); } @Test @@ -27,7 +26,7 @@ public void enCAZipCodeReturnsProperRegexifiedValue() { final String postalCode = new Faker(uk).address().zipCode(); - assertThat(postalCode, matchesRegularExpression("[A-CEJ-NPR-TVXY][0-9][A-CEJ-NPR-TV-Z] ?[0-9][A-CEJ-NPR-TV-Z][0-9]")); + assertThat(postalCode).matches("[A-CEJ-NPR-TVXY][0-9][A-CEJ-NPR-TV-Z] ?[0-9][A-CEJ-NPR-TV-Z][0-9]"); } @Test @@ -36,6 +35,6 @@ public void viZipCodeReturnsProperRegexifiedValue() { final String postalCode = new Faker(uk).address().zipCode(); - assertThat(postalCode, matchesRegularExpression("[A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}")); + assertThat(postalCode).matches("[A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}"); } } diff --git a/src/test/java/org/thejavaguy/javafaker/integration/MostSpecificLocaleIT.java b/src/test/java/org/thejavaguy/javafaker/integration/MostSpecificLocaleIT.java index 62c3a84..ae89f3e 100644 --- a/src/test/java/org/thejavaguy/javafaker/integration/MostSpecificLocaleIT.java +++ b/src/test/java/org/thejavaguy/javafaker/integration/MostSpecificLocaleIT.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker.integration; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; +import static org.assertj.core.api.Assertions.assertThat; import java.util.List; import java.util.Locale; @@ -36,9 +33,9 @@ public void resolvesTheMostSpecificLocale() { final List enDefaultCountries = (List) en.fetchObject("address.default_country"); final List enUsDefaultCountries = (List) en_US.fetchObject("address.default_country"); - assertThat(enDefaultCountries, hasSize(1)); - assertThat(enUsDefaultCountries, hasSize(3)); + assertThat(enDefaultCountries).hasSize(1); + assertThat(enUsDefaultCountries).hasSize(3); - assertThat("the default country for en is not en_US", enDefaultCountries, is(not(enUsDefaultCountries))); + assertThat(enDefaultCountries).as("the default country for en is not en_US").isNotEqualTo(enUsDefaultCountries); } } diff --git a/src/test/java/org/thejavaguy/javafaker/integration/UkLocalDirectivesTest.java b/src/test/java/org/thejavaguy/javafaker/integration/UkLocalDirectivesTest.java index 4eabedd..b40f2f9 100644 --- a/src/test/java/org/thejavaguy/javafaker/integration/UkLocalDirectivesTest.java +++ b/src/test/java/org/thejavaguy/javafaker/integration/UkLocalDirectivesTest.java @@ -1,7 +1,6 @@ package org.thejavaguy.javafaker.integration; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Locale; @@ -45,9 +44,7 @@ public void resolvesDirectivesOnlyInYmlFile() { startsWithFemPrefix |= streetName.startsWith(femPrefix); } - assertThat("the streetname starts with a fem or masc prefix", - startsWithFemPrefix || startsWithMascPrefix, - is(true)); + assertThat(startsWithFemPrefix || startsWithMascPrefix).as("the streetname starts with a fem or masc prefix").isEqualTo(true); } diff --git a/src/test/java/org/thejavaguy/javafaker/matchers/CountOfCharactersMatcher.java b/src/test/java/org/thejavaguy/javafaker/matchers/CountOfCharactersMatcher.java deleted file mode 100644 index 4497e4d..0000000 --- a/src/test/java/org/thejavaguy/javafaker/matchers/CountOfCharactersMatcher.java +++ /dev/null @@ -1,47 +0,0 @@ -package org.thejavaguy.javafaker.matchers; - -import org.hamcrest.Description; -import org.hamcrest.Factory; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - -public class CountOfCharactersMatcher extends TypeSafeMatcher { - - private final char character; - private Matcher matcher; - - public CountOfCharactersMatcher(char character, Matcher matcher) { - this.character = character; - this.matcher = matcher; - } - - @Factory - public static Matcher countOf(char character, Matcher matcher) { - return new CountOfCharactersMatcher(character, matcher); - } - - @Override - protected boolean matchesSafely(String item) { - int count = count(item); - return matcher.matches(count); - } - - private int count(String item) { - int count = 0; - for (char c : item.toCharArray()) { - count += (c == character) ? 1 : 0; - } - return count; - } - - @Override - public void describeTo(Description description) { - description.appendText("count of " + character + " ").appendDescriptionOf(matcher); - } - - @Override - protected void describeMismatchSafely(String item, Description mismatchDescription) { - mismatchDescription.appendText("count of " + character + " "); - matcher.describeMismatch(count(item), mismatchDescription); - } -} diff --git a/src/test/java/org/thejavaguy/javafaker/matchers/IsANumber.java b/src/test/java/org/thejavaguy/javafaker/matchers/IsANumber.java deleted file mode 100644 index 106eb6f..0000000 --- a/src/test/java/org/thejavaguy/javafaker/matchers/IsANumber.java +++ /dev/null @@ -1,29 +0,0 @@ -package org.thejavaguy.javafaker.matchers; - -import org.hamcrest.Description; -import org.hamcrest.Factory; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - -public class IsANumber extends TypeSafeMatcher { - - @Override - protected boolean matchesSafely(String item) { - try { - Double.valueOf(item); - } catch (NumberFormatException nfe) { - return false; - } - return true; - } - - @Override - public void describeTo(Description description) { - description.appendText("is a number"); - } - - @Factory - public static Matcher isANumber() { - return new IsANumber(); - } -} diff --git a/src/test/java/org/thejavaguy/javafaker/matchers/IsANumberTest.java b/src/test/java/org/thejavaguy/javafaker/matchers/IsANumberTest.java deleted file mode 100644 index 3a1fe9f..0000000 --- a/src/test/java/org/thejavaguy/javafaker/matchers/IsANumberTest.java +++ /dev/null @@ -1,29 +0,0 @@ -package org.thejavaguy.javafaker.matchers; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.Is.is; - -import org.junit.jupiter.api.Test; - -public class IsANumberTest { - - @Test - public void testNumberShouldBeANumber() { - assertThat(new IsANumber().matchesSafely("34"), is(true)); - } - - @Test - public void testBlankIsNotANumber() { - assertThat(new IsANumber().matchesSafely(""), is(false)); - } - - @Test - public void testOtherCharsIsNotANumber() { - assertThat(new IsANumber().matchesSafely("df3DF-="), is(false)); - } - - @Test - public void testEmptyStringIsNotANumber() { - assertThat(new IsANumber().matchesSafely(" "), is(false)); - } -} diff --git a/src/test/java/org/thejavaguy/javafaker/matchers/IsStringWithContents.java b/src/test/java/org/thejavaguy/javafaker/matchers/IsStringWithContents.java deleted file mode 100644 index 4e9e24a..0000000 --- a/src/test/java/org/thejavaguy/javafaker/matchers/IsStringWithContents.java +++ /dev/null @@ -1,28 +0,0 @@ -package org.thejavaguy.javafaker.matchers; - -import org.hamcrest.Description; -import org.hamcrest.Factory; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - -public class IsStringWithContents extends TypeSafeMatcher { - - @Override - protected boolean matchesSafely(String s) { - if (s == null) return false; - - return s.trim().length() > 0; - } - - - @Override - public void describeTo(Description description) { - description.appendText("is string with contents"); - } - - @Factory - public static Matcher isStringWithContents() { - return new IsStringWithContents(); - } - -} diff --git a/src/test/java/org/thejavaguy/javafaker/matchers/IsStringWithContentsTest.java b/src/test/java/org/thejavaguy/javafaker/matchers/IsStringWithContentsTest.java deleted file mode 100644 index 6df1d50..0000000 --- a/src/test/java/org/thejavaguy/javafaker/matchers/IsStringWithContentsTest.java +++ /dev/null @@ -1,37 +0,0 @@ -package org.thejavaguy.javafaker.matchers; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.core.Is.is; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class IsStringWithContentsTest { - - private IsStringWithContents matcher; - - @BeforeEach - public void before() { - matcher = new IsStringWithContents(); - } - - @Test - public void emptyStringShouldFail() { - assertThat(matcher.matchesSafely(""), is(false)); - } - - @Test - public void nullStringShouldFail() { - assertThat(matcher.matchesSafely(null), is(false)); - } - - @Test - public void stringShouldPass() { - assertThat(matcher.matchesSafely("123"), is(true)); - } - - @Test - public void whiteSpaceShouldFail() { - assertThat(matcher.matchesSafely(" "), is(false)); - } -} diff --git a/src/test/java/org/thejavaguy/javafaker/matchers/MatchesRegularExpression.java b/src/test/java/org/thejavaguy/javafaker/matchers/MatchesRegularExpression.java deleted file mode 100644 index dc7728f..0000000 --- a/src/test/java/org/thejavaguy/javafaker/matchers/MatchesRegularExpression.java +++ /dev/null @@ -1,30 +0,0 @@ -package org.thejavaguy.javafaker.matchers; - -import org.hamcrest.Description; -import org.hamcrest.Factory; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - -public class MatchesRegularExpression extends TypeSafeMatcher { - - private final String regularExpression; - - public MatchesRegularExpression(String regularExpression) { - this.regularExpression = regularExpression; - } - - @Override - protected boolean matchesSafely(String item) { - return item.matches(regularExpression); - } - - @Override - public void describeTo(Description description) { - description.appendText("to match the regular expression " + regularExpression); - } - - @Factory - public static Matcher matchesRegularExpression(String regularExpression) { - return new MatchesRegularExpression(regularExpression); - } -} diff --git a/src/test/java/org/thejavaguy/javafaker/service/FakeValuesGroupingTest.java b/src/test/java/org/thejavaguy/javafaker/service/FakeValuesGroupingTest.java index ce887b7..27a2af0 100644 --- a/src/test/java/org/thejavaguy/javafaker/service/FakeValuesGroupingTest.java +++ b/src/test/java/org/thejavaguy/javafaker/service/FakeValuesGroupingTest.java @@ -1,8 +1,6 @@ package org.thejavaguy.javafaker.service; -import static org.hamcrest.CoreMatchers.*; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -23,8 +21,8 @@ public void before() { @Test public void handlesOneFakeValue() { - assertThat(fakeValuesGrouping.get("address"), is(addressValues.get("address"))); - assertThat(fakeValuesGrouping.get("address"), is(notNullValue())); + assertThat(fakeValuesGrouping.get("address")).isEqualTo(addressValues.get("address")); + assertThat(fakeValuesGrouping.get("address")).isNotNull(); } @Test @@ -32,10 +30,10 @@ public void handlesMultipleFakeValues() { FakeValues catValues = new FakeValues(Locale.ENGLISH, "cat.yml", "creature"); fakeValuesGrouping.add(catValues); - assertThat(fakeValuesGrouping.get("address"), is(addressValues.get("address"))); - assertThat(fakeValuesGrouping.get("address"), is(notNullValue())); + assertThat(fakeValuesGrouping.get("address")).isEqualTo(addressValues.get("address")); + assertThat(fakeValuesGrouping.get("address")).isNotNull(); - assertThat(fakeValuesGrouping.get("creature"), is(catValues.get("creature"))); - assertThat(fakeValuesGrouping.get("creature"), is(notNullValue())); + assertThat(fakeValuesGrouping.get("creature")).isEqualTo(catValues.get("creature")); + assertThat(fakeValuesGrouping.get("creature")).isNotNull(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/service/FakeValuesServiceTest.java b/src/test/java/org/thejavaguy/javafaker/service/FakeValuesServiceTest.java index 5ebddb8..30f4578 100644 --- a/src/test/java/org/thejavaguy/javafaker/service/FakeValuesServiceTest.java +++ b/src/test/java/org/thejavaguy/javafaker/service/FakeValuesServiceTest.java @@ -1,12 +1,6 @@ package org.thejavaguy.javafaker.service; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.emptyString; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.oneOf; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.doReturn; @@ -15,7 +9,6 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import java.text.ParseException; import java.text.SimpleDateFormat; @@ -24,7 +17,6 @@ import java.util.List; import java.util.Locale; -import org.hamcrest.core.Is; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -64,33 +56,33 @@ void closeMocks() throws Exception{ @Test public void fetchStringShouldReturnValue() { - assertThat(fakeValuesService.fetchString("property.dummy"), is("x")); + assertThat(fakeValuesService.fetchString("property.dummy")).isEqualTo("x"); } @Test public void fetchShouldReturnValue() { - assertThat(fakeValuesService.fetch("property.dummy"), Is.is("x")); + assertThat(fakeValuesService.fetch("property.dummy")).isEqualTo("x"); } @Test public void fetchObjectShouldReturnValue() { - assertThat(fakeValuesService.fetchObject("property.dummy"), Is.is(Arrays.asList("x", "y", "z"))); + assertThat(fakeValuesService.fetchObject("property.dummy")).isEqualTo(Arrays.asList("x", "y", "z")); } @Test public void safeFetchShouldReturnValueInList() { doReturn(0).when(randomService).nextInt(Mockito.anyInt()); - assertThat(fakeValuesService.safeFetch("property.dummy", null), is("x")); + assertThat(fakeValuesService.safeFetch("property.dummy", null)).isEqualTo("x"); } @Test public void safeFetchShouldReturnSimpleList() { - assertThat(fakeValuesService.safeFetch("property.simple", null), is("hello")); + assertThat(fakeValuesService.safeFetch("property.simple", null)).isEqualTo("hello"); } @Test public void safeFetchShouldReturnEmptyStringWhenPropertyDoesntExist() { - assertThat(fakeValuesService.safeFetch("property.dummy2", ""), is(emptyString())); + assertThat(fakeValuesService.safeFetch("property.dummy2", "")).isEmpty(); } @Test @@ -100,7 +92,7 @@ public void bothify2Args() { Faker f = new Faker(); String value = fakeValuesService.resolve("property.bothify_2", dummy, f); - assertThat(value, matchesRegularExpression("[A-Z]{2}\\d{2}")); + assertThat(value).matches("[A-Z]{2}\\d{2}"); } @Test @@ -108,7 +100,7 @@ public void regexifyDirective() { final DummyService dummy = mock(DummyService.class); String value = fakeValuesService.resolve("property.regexify1", dummy, faker); - assertThat(value, is(oneOf("55", "44", "45", "54"))); + assertThat(value).isIn("55", "44", "45", "54"); verify(faker).regexify("[45]{2}"); } @@ -117,7 +109,7 @@ public void regexifySlashFormatDirective() { final DummyService dummy = mock(DummyService.class); String value = fakeValuesService.resolve("property.regexify_slash_format", dummy, faker); - assertThat(value, is(oneOf("55", "44", "45", "54"))); + assertThat(value).isIn("55", "44", "45", "54"); verify(faker).regexify("[45]{2}"); } @@ -126,7 +118,7 @@ public void regexifyDirective2() { final DummyService dummy = mock(DummyService.class); String value = fakeValuesService.resolve("property.regexify_cell", dummy, faker); - assertThat(value, is(oneOf("479", "459"))); + assertThat(value).isIn("479", "459"); verify(faker).regexify("4[57]9"); } @@ -142,7 +134,7 @@ public void resolveKeyToPropertyWithAPropertyWithoutAnObject() { final String actual = fakeValuesService.resolve("property.simpleResolution", dummy, faker); // then - assertThat(actual, is("Yo!")); + assertThat(actual).isEqualTo("Yo!"); verify(dummy).hello(); verifyNoMoreInteractions(faker); } @@ -159,7 +151,7 @@ public void resolveKeyToPropertyWithAPropertyWithAnObject() { final String actual = fakeValuesService.resolve("property.advancedResolution", dummy, faker); // then - assertThat(actual, is("Luke Cage")); + assertThat(actual).isEqualTo("Luke Cage"); verify(faker).superhero(); verify(person).name(); } @@ -178,7 +170,7 @@ public void resolveKeyToPropertyWithAList() { final String actual = fakeValuesService.resolve("property.resolutionWithList", dummy, faker); // then - assertThat(actual, is("Yo!")); + assertThat(actual).isEqualTo("Yo!"); verify(dummy).hello(); } @@ -196,7 +188,7 @@ public void resolveKeyWithMultiplePropertiesShouldJoinResults() { String actual = fakeValuesService.resolve("property.multipleResolution", dummy, faker); // then - assertThat(actual, is("Yo Superman! up up and away")); + assertThat(actual).isEqualTo("Yo Superman! up up and away"); verify(faker).superhero(); verify(person).descriptor(); @@ -207,21 +199,21 @@ public void resolveKeyWithMultiplePropertiesShouldJoinResults() { public void testLocaleChain() { final List chain = fakeValuesService.localeChain(Locale.SIMPLIFIED_CHINESE); - assertThat(chain, contains(Locale.SIMPLIFIED_CHINESE, Locale.CHINESE, Locale.ENGLISH)); + assertThat(chain).containsExactly(Locale.SIMPLIFIED_CHINESE, Locale.CHINESE, Locale.ENGLISH); } @Test public void testLocaleChainEnglish() { final List chain = fakeValuesService.localeChain(Locale.ENGLISH); - assertThat(chain, contains(Locale.ENGLISH)); + assertThat(chain).containsExactly(Locale.ENGLISH); } @Test public void testLocaleChainLanguageOnly() { final List chain = fakeValuesService.localeChain(Locale.CHINESE); - assertThat(chain, contains(Locale.CHINESE, Locale.ENGLISH)); + assertThat(chain).containsExactly(Locale.CHINESE, Locale.ENGLISH); } @Test @@ -259,8 +251,8 @@ public void futureDateExpression() throws ParseException { Date date = dateFormat.parse( fakeValuesService.expression( "#{date.future '10','TimeUnit.DAYS'}", faker )); - assertThat( date.getTime(), greaterThan( now.getTime() )); - assertThat( date.getTime(), lessThan( nowPlus10Days.getTime() )); + assertThat(date.getTime()).isGreaterThan(now.getTime()); + assertThat(date.getTime()).isLessThan(nowPlus10Days.getTime()); } @Test @@ -272,15 +264,15 @@ public void pastDateExpression() throws ParseException { Date date = dateFormat.parse( fakeValuesService.expression( "#{date.past '5','TimeUnit.HOURS'}", faker )); - assertThat( date.getTime(), greaterThan( nowMinus5Hours.getTime() )); - assertThat( date.getTime(), lessThan( now.getTime() )); + assertThat(date.getTime()).isGreaterThan(nowMinus5Hours.getTime()); + assertThat(date.getTime()).isLessThan(now.getTime()); } @Test public void expressionWithFourArguments() throws ParseException { - assertThat(fakeValuesService.expression("#{Internet.password '5','8','true','true'}", faker), - matchesRegularExpression("[\\w\\d\\!%#$@_\\^&\\*]{5,8}")); + assertThat(fakeValuesService.expression("#{Internet.password '5','8','true','true'}", faker)) + .matches("[\\w\\d\\!%#$@_\\^&\\*]{5,8}"); } /** @@ -301,7 +293,7 @@ private void expressionShouldFailWith(String expression, String errorMessage) { fakeValuesService.expression(expression, faker); fail("Should have failed with RuntimeException and message of " + errorMessage); } catch (RuntimeException re) { - assertThat(re.getMessage(), is(errorMessage)); + assertThat(re.getMessage()).isEqualTo(errorMessage); } } @Test @@ -316,7 +308,7 @@ public void resolveUsingTheSameKeyTwice() { final String actual = fakeValuesService.resolve("property.sameResolution", dummy, faker); // then - assertThat(actual, is("1 2")); + assertThat(actual).isEqualTo("1 2"); verifyNoMoreInteractions(faker); } @Test @@ -326,7 +318,7 @@ public void FakeValuesServiceWithNullLocaleTest(){ FakeValuesService f=new FakeValuesService(null,r); fail("Should catch IllegalArgumentException"); }catch (IllegalArgumentException e){ - assertThat(e.getMessage(),is("locale is required")); + assertThat(e.getMessage()).isEqualTo("locale is required"); } } public static class DummyService { diff --git a/src/test/java/org/thejavaguy/javafaker/service/FakeValuesTest.java b/src/test/java/org/thejavaguy/javafaker/service/FakeValuesTest.java index 9107f59..12757e4 100644 --- a/src/test/java/org/thejavaguy/javafaker/service/FakeValuesTest.java +++ b/src/test/java/org/thejavaguy/javafaker/service/FakeValuesTest.java @@ -1,9 +1,6 @@ package org.thejavaguy.javafaker.service; -import static org.hamcrest.CoreMatchers.*; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Locale; @@ -23,40 +20,40 @@ public void before() { @Test public void supportsPathIsTrueWithTheSameValueAsThePath() { - assertThat(fakeValues.supportsPath(PATH), is(true)); + assertThat(fakeValues.supportsPath(PATH)).isEqualTo(true); } @Test public void supportsPathIsFalseWhenValueIsNotTheSame() { - assertThat(fakeValues.supportsPath("dog"), is(false)); + assertThat(fakeValues.supportsPath("dog")).isEqualTo(false); } @Test public void getAValueReturnsAValue() { - assertThat(fakeValues.get(PATH), is(notNullValue())); + assertThat(fakeValues.get(PATH)).isNotNull(); } @Test public void getAValueDoesNotReturnAValue() { - assertThat(fakeValues.get("dog"), is(nullValue())); + assertThat(fakeValues.get("dog")).isNull(); } @Test public void getAValueWithANonEnglishFile() { FakeValues frenchFakeValues = new FakeValues(Locale.FRENCH); - assertThat(frenchFakeValues.get(PATH), is(notNullValue())); + assertThat(frenchFakeValues.get(PATH)).isNotNull(); } @Test public void getAValueForHebrewLocale() { FakeValues hebrew = new FakeValues(new Locale("iw")); - assertThat(hebrew.get(PATH), is(notNullValue())); + assertThat(hebrew.get(PATH)).isNotNull(); } @Test public void getAValueFromALocaleThatCantBeLoaded() { FakeValues fakeValues = new FakeValues(new Locale("nothing")); - assertThat(fakeValues.get(PATH), is(nullValue())); + assertThat(fakeValues.get(PATH)).isNull(); } } diff --git a/src/test/java/org/thejavaguy/javafaker/service/RandomServiceTest.java b/src/test/java/org/thejavaguy/javafaker/service/RandomServiceTest.java index f12998f..c722347 100644 --- a/src/test/java/org/thejavaguy/javafaker/service/RandomServiceTest.java +++ b/src/test/java/org/thejavaguy/javafaker/service/RandomServiceTest.java @@ -1,14 +1,7 @@ package org.thejavaguy.javafaker.service; -import static org.hamcrest.CoreMatchers.*; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.lessThanOrEqualTo; -import static org.hamcrest.core.CombinableMatcher.both; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression; import java.util.Arrays; import java.util.Collection; @@ -50,10 +43,10 @@ public void testPositiveBoundariesOnly(String ignoredTitle,RandomService service @ParameterizedTest(name = "Created via {0}") public void testLongWithinBoundary(String ignoredTitle,RandomService service) { initRandomServiceTest(ignoredTitle, service); - assertThat(randomService.nextLong(1), is(0L)); + assertThat(randomService.nextLong(1)).isEqualTo(0L); for (int i = 1; i < 10; i++) { - assertThat(randomService.nextLong(2), lessThan(2L)); + assertThat(randomService.nextLong(2)).isLessThan(2L); } } @@ -61,8 +54,8 @@ public void testLongWithinBoundary(String ignoredTitle,RandomService service) { @ParameterizedTest(name = "Created via {0}") public void testLongMaxBoundary(String ignoredTitle,RandomService service) { initRandomServiceTest(ignoredTitle, service); - assertThat(randomService.nextLong(Long.MAX_VALUE), greaterThan(0L)); - assertThat(randomService.nextLong(Long.MAX_VALUE), lessThan(Long.MAX_VALUE)); + assertThat(randomService.nextLong(Long.MAX_VALUE)).isGreaterThan(0L); + assertThat(randomService.nextLong(Long.MAX_VALUE)).isLessThan(Long.MAX_VALUE); } @MethodSource("data") @@ -70,7 +63,7 @@ public void testLongMaxBoundary(String ignoredTitle,RandomService service) { public void testIntInRange(String ignoredTitle,RandomService service) { initRandomServiceTest(ignoredTitle, service); for (int i = 1; i < 100; i++) { - assertThat(randomService.nextInt(-5, 5), both(lessThanOrEqualTo(5)).and(greaterThanOrEqualTo(-5))); + assertThat(randomService.nextInt(-5, 5)).isGreaterThanOrEqualTo(-5).isLessThanOrEqualTo(5); } } @@ -78,13 +71,13 @@ public void testIntInRange(String ignoredTitle,RandomService service) { @ParameterizedTest(name = "Created via {0}") public void testHex(String ignoredTitle,RandomService service) { initRandomServiceTest(ignoredTitle, service); - assertThat(randomService.hex(8), matchesRegularExpression("^[0-9A-F]{8}$")); + assertThat(randomService.hex(8)).matches("^[0-9A-F]{8}$"); } @MethodSource("data") @ParameterizedTest(name = "Created via {0}") public void testDefaultHex(String ignoredTitle,RandomService service) { initRandomServiceTest(ignoredTitle, service); - assertThat(randomService.hex(), matchesRegularExpression("^[0-9A-F]{8}$")); + assertThat(randomService.hex()).matches("^[0-9A-F]{8}$"); } }