From 4362aab2e1d3b92171423528e0a42b972dd4c15a Mon Sep 17 00:00:00 2001 From: Grzegorz Piwowarek Date: Fri, 28 Oct 2016 07:29:07 +0200 Subject: [PATCH] Add missing files --- core-java/src/main/resources/targetFile.tmp | 2 + .../baeldung/datetime/UseLocalDateTest.java | 54 ++++ .../datetime/UseLocalDateTimeTest.java | 19 ++ .../baeldung/datetime/UseLocalTimeTest.java | 36 +++ .../com/baeldung/datetime/UsePeriodTest.java | 26 ++ .../datetime/UseZonedDateTimeTest.java | 20 ++ .../doublecolon/TestComputerUtils.java | 91 ++++++ .../encoderdecoder/EncoderDecoder.java | 84 ++++++ .../java/com/baeldung/enums/PizzaTest.java | 80 ++++++ .../com/baeldung/file/FileOperationsTest.java | 121 ++++++++ .../java8/Java8CollectionCleanupUnitTest.java | 48 ++++ ...Java8DefaultStaticIntefaceMethodsTest.java | 27 ++ .../java8/Java8ExecutorServiceTest.java | 156 +++++++++++ .../com/baeldung/java8/Java8ForkJoinTest.java | 100 +++++++ .../Java8FunctionalInteracesLambdasTest.java | 94 +++++++ .../java8/Java8MethodReferenceTest.java | 67 +++++ .../com/baeldung/java8/Java8OptionalTest.java | 118 ++++++++ .../com/baeldung/java8/Java8SortUnitTest.java | 115 ++++++++ .../baeldung/java8/Java8StreamApiTest.java | 263 ++++++++++++++++++ .../com/baeldung/java8/Java8StreamsTest.java | 113 ++++++++ .../baeldung/java8/JavaFolderSizeTest.java | 115 ++++++++ .../java8/JavaTryWithResourcesTest.java | 86 ++++++ .../base64/ApacheCommonsEncodeDecodeTest.java | 56 ++++ .../java8/base64/Java8EncodeDecodeTest.java | 109 ++++++++ .../java/com/baeldung/java8/entity/Human.java | 89 ++++++ .../threadpool/CoreThreadPoolTest.java | 146 ++++++++++ .../threadpool/GuavaThreadPoolTest.java | 56 ++++ .../baeldung/util/CurrentDateTimeTest.java | 41 +++ 28 files changed, 2332 insertions(+) create mode 100644 core-java/src/main/resources/targetFile.tmp create mode 100644 core-java/src/test/java/com/baeldung/datetime/UseLocalDateTest.java create mode 100644 core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java create mode 100644 core-java/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java create mode 100644 core-java/src/test/java/com/baeldung/datetime/UsePeriodTest.java create mode 100644 core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java create mode 100644 core-java/src/test/java/com/baeldung/doublecolon/TestComputerUtils.java create mode 100644 core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoder.java create mode 100644 core-java/src/test/java/com/baeldung/enums/PizzaTest.java create mode 100644 core-java/src/test/java/com/baeldung/file/FileOperationsTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8CollectionCleanupUnitTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8ExecutorServiceTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8ForkJoinTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8FunctionalInteracesLambdasTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8OptionalTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8SortUnitTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8StreamApiTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/Java8StreamsTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/JavaFolderSizeTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/JavaTryWithResourcesTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/base64/ApacheCommonsEncodeDecodeTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/base64/Java8EncodeDecodeTest.java create mode 100644 core-java/src/test/java/com/baeldung/java8/entity/Human.java create mode 100644 core-java/src/test/java/com/baeldung/threadpool/CoreThreadPoolTest.java create mode 100644 core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolTest.java create mode 100644 core-java/src/test/java/com/baeldung/util/CurrentDateTimeTest.java diff --git a/core-java/src/main/resources/targetFile.tmp b/core-java/src/main/resources/targetFile.tmp new file mode 100644 index 0000000000..20f137b416 --- /dev/null +++ b/core-java/src/main/resources/targetFile.tmp @@ -0,0 +1,2 @@ +line 1 +a second line \ No newline at end of file diff --git a/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTest.java b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTest.java new file mode 100644 index 0000000000..0537832586 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTest.java @@ -0,0 +1,54 @@ +package com.baeldung.datetime; + +import java.time.DayOfWeek; +import java.time.LocalDate; +import java.time.LocalDateTime; + +import org.junit.Assert; +import org.junit.Test; + +public class UseLocalDateTest { + + UseLocalDate useLocalDate = new UseLocalDate(); + + @Test + public void givenValues_whenUsingFactoryOf_thenLocalDate(){ + Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingFactoryOfMethod(2016,5,10).toString()); + } + + @Test + public void givenString_whenUsingParse_thenLocalDate(){ + Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString()); + } + + @Test + public void whenUsingClock_thenLocalDate(){ + Assert.assertEquals(LocalDate.now(),useLocalDate.getLocalDateFromClock()); + } + + @Test + public void givenDate_whenUsingPlus_thenNextDay(){ + Assert.assertEquals(LocalDate.now().plusDays(1),useLocalDate.getNextDay(LocalDate.now())); + } + + @Test + public void givenDate_whenUsingMinus_thenPreviousDay(){ + Assert.assertEquals(LocalDate.now().minusDays(1),useLocalDate.getPreviousDay(LocalDate.now())); + } + + @Test + public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek(){ + Assert.assertEquals(DayOfWeek.SUNDAY,useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22"))); + } + + @Test + public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth(){ + Assert.assertEquals(1,useLocalDate.getFirstDayOfMonth().getDayOfMonth()); + } + + @Test + public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight(){ + Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"),useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22"))); + } + +} diff --git a/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java new file mode 100644 index 0000000000..69a289fd02 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java @@ -0,0 +1,19 @@ +package com.baeldung.datetime; + +import java.time.LocalDate; +import java.time.LocalTime; +import java.time.Month; + +import org.junit.Assert; +import org.junit.Test; + +public class UseLocalDateTimeTest { + + UseLocalDateTime useLocalDateTime = new UseLocalDateTime(); + + @Test + public void givenString_whenUsingParse_thenLocalDateTime(){ + Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate()); + Assert.assertEquals(LocalTime.of(6,30),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime()); + } +} diff --git a/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java b/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java new file mode 100644 index 0000000000..7776fad363 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java @@ -0,0 +1,36 @@ +package com.baeldung.datetime; + +import java.time.LocalTime; + +import org.junit.Assert; +import org.junit.Test; + +public class UseLocalTimeTest { + + UseLocalTime useLocalTime = new UseLocalTime(); + + @Test + public void givenValues_whenUsingFactoryOf_thenLocalTime(){ + Assert.assertEquals("07:07:07",useLocalTime.getLocalTimeUsingFactoryOfMethod(7,7,7).toString()); + } + + @Test + public void givenString_whenUsingParse_thenLocalTime(){ + Assert.assertEquals("06:30",useLocalTime.getLocalTimeUsingParseMethod("06:30").toString()); + } + + @Test + public void givenTime_whenAddHour_thenLocalTime(){ + Assert.assertEquals("07:30",useLocalTime.addAnHour(LocalTime.of(6,30)).toString()); + } + + @Test + public void getHourFromLocalTime(){ + Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1,1))); + } + + @Test + public void getLocalTimeWithMinuteSetToValue(){ + Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10,10), 20)); + } +} diff --git a/core-java/src/test/java/com/baeldung/datetime/UsePeriodTest.java b/core-java/src/test/java/com/baeldung/datetime/UsePeriodTest.java new file mode 100644 index 0000000000..5237270096 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/datetime/UsePeriodTest.java @@ -0,0 +1,26 @@ +package com.baeldung.datetime; + +import java.time.LocalDate; +import java.time.Period; + +import org.junit.Assert; +import org.junit.Test; + +public class UsePeriodTest { + UsePeriod usingPeriod=new UsePeriod(); + + @Test + public void givenPeriodAndLocalDate_thenCalculateModifiedDate(){ + Period period = Period.ofDays(1); + LocalDate localDate = LocalDate.parse("2007-05-10"); + Assert.assertEquals(localDate.plusDays(1),usingPeriod.modifyDates(localDate, period)); + } + + @Test + public void givenDates_thenGetPeriod(){ + LocalDate localDate1 = LocalDate.parse("2007-05-10"); + LocalDate localDate2 = LocalDate.parse("2007-05-15"); + + Assert.assertEquals(Period.ofDays(5), usingPeriod.getDifferenceBetweenDates(localDate1, localDate2)); + } +} diff --git a/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java b/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java new file mode 100644 index 0000000000..5af01ad678 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java @@ -0,0 +1,20 @@ +package com.baeldung.datetime; + +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.ZonedDateTime; + +import org.junit.Assert; +import org.junit.Test; + +public class UseZonedDateTimeTest { + + UseZonedDateTime zonedDateTime=new UseZonedDateTime(); + + @Test + public void givenZoneId_thenZonedDateTime(){ + ZoneId zoneId=ZoneId.of("Europe/Paris"); + ZonedDateTime zonedDatetime=zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId); + Assert.assertEquals(zoneId,ZoneId.from(zonedDatetime)); + } +} diff --git a/core-java/src/test/java/com/baeldung/doublecolon/TestComputerUtils.java b/core-java/src/test/java/com/baeldung/doublecolon/TestComputerUtils.java new file mode 100644 index 0000000000..85194f5aa6 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/doublecolon/TestComputerUtils.java @@ -0,0 +1,91 @@ +package com.baeldung.doublecolon; + +import com.baeldung.doublecolon.function.TriFunction; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.function.BiFunction; + +import static com.baeldung.doublecolon.ComputerUtils.*; + +public class TestComputerUtils { + + @Before + public void setup() { + } + + @After + public void tearDown() { + } + + @Test + public void testConstructorReference() { + + Computer c1 = new Computer(2015, "white"); + Computer c2 = new Computer(2009, "black"); + Computer c3 = new Computer(2014, "black"); + + BiFunction c4Function = Computer::new; + Computer c4 = c4Function.apply(2013, "white"); + BiFunction c5Function = Computer::new; + Computer c5 = c5Function.apply(2010, "black"); + BiFunction c6Function = Computer::new; + Computer c6 = c6Function.apply(2008, "black"); + + List inventory = Arrays.asList(c1, c2, c3, c4, c5, c6); + + List blackComputer = filter(inventory, blackPredicate); + Assert.assertEquals("The black Computers are: ", blackComputer.size(), 4); + + List after2010Computer = filter(inventory, after2010Predicate); + Assert.assertEquals("The Computer bought after 2010 are: ", after2010Computer.size(), 3); + + List before2011Computer = filter(inventory, c -> c.getAge() < 2011); + Assert.assertEquals("The Computer bought before 2011 are: ", before2011Computer.size(), 3); + + inventory.sort(Comparator.comparing(Computer::getAge)); + + Assert.assertEquals("Oldest Computer in inventory", c6, inventory.get(0)); + + } + + @Test + public void testStaticMethodReference() { + + Computer c1 = new Computer(2015, "white", 35); + Computer c2 = new Computer(2009, "black", 65); + TriFunction c6Function = Computer::new; + Computer c3 = c6Function.apply(2008, "black", 90); + + List inventory = Arrays.asList(c1, c2, c3); + inventory.forEach(ComputerUtils::repair); + + Assert.assertEquals("Computer repaired", new Integer(100), c1.getHealty()); + } + + @Test + public void testInstanceMethodArbitraryObjectParticularType() { + + Computer c1 = new Computer(2015, "white", 35); + Computer c2 = new MacbookPro(2009, "black", 65); + List inventory = Arrays.asList(c1, c2); + inventory.forEach(Computer::turnOnPc); + + } + + @Test + public void testSuperMethodReference() { + + final TriFunction integerStringIntegerObjectTriFunction = MacbookPro::new; + final MacbookPro macbookPro = integerStringIntegerObjectTriFunction.apply(2010, "black", 100); + Double initialValue = new Double(999.99); + final Double actualValue = macbookPro.calculateValue(initialValue); + Assert.assertEquals(766.659, actualValue, 0.0); + } + +} diff --git a/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoder.java b/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoder.java new file mode 100644 index 0000000000..208a23eb91 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoder.java @@ -0,0 +1,84 @@ +package com.baeldung.encoderdecoder; + +import org.hamcrest.CoreMatchers; +import org.junit.Assert; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.UnsupportedEncodingException; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLDecoder; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class EncoderDecoder { + + private static final String URL = "http://www.baeldung.com?key1=value+1&key2=value%40%21%242&key3=value%253"; + private static final Logger LOGGER = LoggerFactory.getLogger(EncoderDecoder.class); + + private String encodeValue(String value) { + String encoded = null; + try { + encoded = URLEncoder.encode(value, StandardCharsets.UTF_8.toString()); + } catch (UnsupportedEncodingException e) { + LOGGER.error("Error encoding parameter {}", e.getMessage(), e); + } + return encoded; + } + + + private String decode(String value) { + String decoded = null; + try { + decoded = URLDecoder.decode(value, StandardCharsets.UTF_8.toString()); + } catch (UnsupportedEncodingException e) { + LOGGER.error("Error encoding parameter {}", e.getMessage(), e); + } + return decoded; + } + + @Test + public void givenURL_whenAnalyze_thenCorrect() throws Exception { + URL url = new URL(URL); + + Assert.assertThat(url.getProtocol(), CoreMatchers.is("http")); + Assert.assertThat(url.getHost(), CoreMatchers.is("www.baeldung.com")); + Assert.assertThat(url.getQuery(), CoreMatchers.is("key1=value+1&key2=value%40%21%242&key3=value%253")); + } + + @Test + public void givenRequestParam_whenUTF8Scheme_thenEncode() throws Exception { + Map requestParams = new HashMap<>(); + requestParams.put("key1", "value 1"); + requestParams.put("key2", "value@!$2"); + requestParams.put("key3", "value%3"); + + String encodedQuery = requestParams.keySet().stream() + .map(key -> key + "=" + encodeValue(requestParams.get(key))) + .collect(Collectors.joining("&")); + String encodedURL = "http://www.baeldung.com?" + encodedQuery; + + Assert.assertThat(URL, CoreMatchers.is(encodedURL)); + } + + @Test + public void givenRequestParam_whenUTF8Scheme_thenDecodeRequestParams() throws Exception { + URL url = new URL(URL); + String query = url.getQuery(); + + String decodedQuery = Arrays.stream(query.split("&")) + .map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1])) + .collect(Collectors.joining("&")); + + Assert.assertEquals( + "http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery); + } + +} diff --git a/core-java/src/test/java/com/baeldung/enums/PizzaTest.java b/core-java/src/test/java/com/baeldung/enums/PizzaTest.java new file mode 100644 index 0000000000..deeebaa240 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/enums/PizzaTest.java @@ -0,0 +1,80 @@ +package com.baeldung.enums; + + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.EnumMap; +import java.util.List; + +import static junit.framework.TestCase.assertTrue; + +public class PizzaTest { + + @Test + public void givenPizaOrder_whenReady_thenDeliverable() { + Pizza testPz = new Pizza(); + testPz.setStatus(Pizza.PizzaStatusEnum.READY); + assertTrue(testPz.isDeliverable()); + } + + @Test + public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() { + List pzList = new ArrayList<>(); + Pizza pz1 = new Pizza(); + pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED); + + Pizza pz2 = new Pizza(); + pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED); + + Pizza pz3 = new Pizza(); + pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED); + + Pizza pz4 = new Pizza(); + pz4.setStatus(Pizza.PizzaStatusEnum.READY); + + pzList.add(pz1); + pzList.add(pz2); + pzList.add(pz3); + pzList.add(pz4); + + List undeliveredPzs = Pizza.getAllUndeliveredPizzas(pzList); + assertTrue(undeliveredPzs.size() == 3); + } + + @Test + public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() { + + List pzList = new ArrayList<>(); + Pizza pz1 = new Pizza(); + pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED); + + Pizza pz2 = new Pizza(); + pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED); + + Pizza pz3 = new Pizza(); + pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED); + + Pizza pz4 = new Pizza(); + pz4.setStatus(Pizza.PizzaStatusEnum.READY); + + pzList.add(pz1); + pzList.add(pz2); + pzList.add(pz3); + pzList.add(pz4); + + EnumMap> map = Pizza.groupPizzaByStatus(pzList); + assertTrue(map.get(Pizza.PizzaStatusEnum.DELIVERED).size() == 1); + assertTrue(map.get(Pizza.PizzaStatusEnum.ORDERED).size() == 2); + assertTrue(map.get(Pizza.PizzaStatusEnum.READY).size() == 1); + } + + @Test + public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() { + Pizza pz = new Pizza(); + pz.setStatus(Pizza.PizzaStatusEnum.READY); + pz.deliver(); + assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED); + } + +} diff --git a/core-java/src/test/java/com/baeldung/file/FileOperationsTest.java b/core-java/src/test/java/com/baeldung/file/FileOperationsTest.java new file mode 100644 index 0000000000..e21af9552a --- /dev/null +++ b/core-java/src/test/java/com/baeldung/file/FileOperationsTest.java @@ -0,0 +1,121 @@ +package com.baeldung.file; + +import org.apache.commons.io.FileUtils; +import org.hamcrest.CoreMatchers; +import org.hamcrest.Matchers; +import org.junit.Assert; +import org.junit.Test; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.URISyntaxException; +import java.net.URL; +import java.net.URLConnection; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.stream.Stream; + +public class FileOperationsTest { + + @Test + public void givenFileName_whenUsingClassloader_thenFileData() throws IOException { + String expectedData = "Hello World from fileTest.txt!!!"; + + ClassLoader classLoader = getClass().getClassLoader(); + File file = new File(classLoader.getResource("fileTest.txt").getFile()); + InputStream inputStream = new FileInputStream(file); + String data = readFromInputStream(inputStream); + + Assert.assertEquals(expectedData, data.trim()); + } + + @Test + public void givenFileNameAsAbsolutePath_whenUsingClasspath_thenFileData() throws IOException { + String expectedData = "Hello World from fileTest.txt!!!"; + + Class clazz = FileOperationsTest.class; + InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt"); + String data = readFromInputStream(inputStream); + + Assert.assertEquals(expectedData, data.trim()); + } + + @Test + public void givenFileName_whenUsingJarFile_thenFileData() throws IOException { + String expectedData = "BSD License"; + + Class clazz = Matchers.class; + InputStream inputStream = clazz.getResourceAsStream("/LICENSE.txt"); + String data = readFromInputStream(inputStream); + + Assert.assertThat(data.trim(), CoreMatchers.containsString(expectedData)); + } + + @Test + public void givenURLName_whenUsingURL_thenFileData() throws IOException { + String expectedData = "Baeldung"; + + URL urlObject = new URL("http://www.baeldung.com/"); + + URLConnection urlConnection = urlObject.openConnection(); + + InputStream inputStream = urlConnection.getInputStream(); + String data = readFromInputStream(inputStream); + + Assert.assertThat(data.trim(), CoreMatchers.containsString(expectedData)); + } + + @Test + public void givenFileName_whenUsingFileUtils_thenFileData() throws IOException { + String expectedData = "Hello World from fileTest.txt!!!"; + + ClassLoader classLoader = getClass().getClassLoader(); + File file = new File(classLoader.getResource("fileTest.txt").getFile()); + String data = FileUtils.readFileToString(file); + + Assert.assertEquals(expectedData, data.trim()); + } + + @Test + public void givenFilePath_whenUsingFilesReadAllBytes_thenFileData() throws IOException, URISyntaxException { + String expectedData = "Hello World from fileTest.txt!!!"; + + Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI()); + + byte[] fileBytes = Files.readAllBytes(path); + String data = new String(fileBytes); + + Assert.assertEquals(expectedData, data.trim()); + } + + @Test + public void givenFilePath_whenUsingFilesLines_thenFileData() throws IOException, URISyntaxException { + String expectedData = "Hello World from fileTest.txt!!!"; + + Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI()); + + StringBuilder data = new StringBuilder(); + Stream lines = Files.lines(path); + lines.forEach(line -> data.append(line).append("\n")); + lines.close(); + + Assert.assertEquals(expectedData, data.toString().trim()); + } + + private String readFromInputStream(InputStream inputStream) throws IOException { + StringBuilder resultStringBuilder = new StringBuilder(); + try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream))) { + String line; + while ((line = bufferedReader.readLine()) != null) { + resultStringBuilder.append(line).append("\n"); + } + } + + return resultStringBuilder.toString(); + } +} \ No newline at end of file diff --git a/core-java/src/test/java/com/baeldung/java8/Java8CollectionCleanupUnitTest.java b/core-java/src/test/java/com/baeldung/java8/Java8CollectionCleanupUnitTest.java new file mode 100644 index 0000000000..ef4b80c6e8 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8CollectionCleanupUnitTest.java @@ -0,0 +1,48 @@ +package com.baeldung.java8; + +import com.google.common.collect.Lists; +import org.junit.Test; + +import java.util.List; +import java.util.stream.Collectors; + +import static org.hamcrest.Matchers.hasSize; +import static org.junit.Assert.assertThat; + +public class Java8CollectionCleanupUnitTest { + + // tests - + + @Test + public void givenListContainsNulls_whenFilteringParallel_thenCorrect() { + final List list = Lists.newArrayList(null, 1, 2, null, 3, null); + final List listWithoutNulls = list.parallelStream().filter(i -> i != null).collect(Collectors.toList()); + + assertThat(listWithoutNulls, hasSize(3)); + } + + @Test + public void givenListContainsNulls_whenFilteringSerial_thenCorrect() { + final List list = Lists.newArrayList(null, 1, 2, null, 3, null); + final List listWithoutNulls = list.stream().filter(i -> i != null).collect(Collectors.toList()); + + assertThat(listWithoutNulls, hasSize(3)); + } + + @Test + public void givenListContainsNulls_whenRemovingNullsWithRemoveIf_thenCorrect() { + final List listWithoutNulls = Lists.newArrayList(null, 1, 2, null, 3, null); + listWithoutNulls.removeIf(p -> p == null); + + assertThat(listWithoutNulls, hasSize(3)); + } + + @Test + public void givenListContainsDuplicates_whenRemovingDuplicatesWithJava8_thenCorrect() { + final List listWithDuplicates = Lists.newArrayList(1, 1, 2, 2, 3, 3); + final List listWithoutDuplicates = listWithDuplicates.parallelStream().distinct().collect(Collectors.toList()); + + assertThat(listWithoutDuplicates, hasSize(3)); + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java b/core-java/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java new file mode 100644 index 0000000000..21a5e34b9b --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java @@ -0,0 +1,27 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.Vehicle; +import com.baeldung.java_8_features.VehicleImpl; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class Java8DefaultStaticIntefaceMethodsTest { + + @Test + public void callStaticInterfaceMethdosMethods_whenExpectedResults_thenCorrect() { + Vehicle vehicle = new VehicleImpl(); + String overview = vehicle.getOverview(); + long[] startPosition = vehicle.startPosition(); + + assertEquals(overview, "ATV made by N&F Vehicles"); + assertEquals(startPosition[0], 23); + assertEquals(startPosition[1], 15); + } + + @Test + public void callDefaultInterfaceMethods_whenExpectedResults_thenCorrect() { + String producer = Vehicle.producer(); + assertEquals(producer, "N&F Vehicles"); + } +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8ExecutorServiceTest.java b/core-java/src/test/java/com/baeldung/java8/Java8ExecutorServiceTest.java new file mode 100644 index 0000000000..581ccec182 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8ExecutorServiceTest.java @@ -0,0 +1,156 @@ +package com.baeldung.java8; + + +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.*; + +import static org.junit.Assert.*; + + +public class Java8ExecutorServiceTest { + + private Runnable runnableTask; + private Callable callableTask; + private List> callableTasks; + + @Before + public void init() { + + runnableTask = () -> { + try { + TimeUnit.MILLISECONDS.sleep(300); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }; + + callableTask = () -> { + TimeUnit.MILLISECONDS.sleep(300); + return "Task's execution"; + }; + + callableTasks = new ArrayList<>(); + callableTasks.add(callableTask); + callableTasks.add(callableTask); + callableTasks.add(callableTask); + } + + @Test + public void creationSubmittingTaskShuttingDown_whenShutDown_thenCorrect() { + + ExecutorService executorService = Executors.newFixedThreadPool(10); + executorService.submit(runnableTask); + executorService.submit(callableTask); + executorService.shutdown(); + + assertTrue(executorService.isShutdown()); + } + + @Test + public void creationSubmittingTasksShuttingDownNow_whenShutDownAfterAwating_thenCorrect() { + + ExecutorService threadPoolExecutor = + new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue<>()); + + for (int i = 0; i < 100; i++) { + threadPoolExecutor.submit(callableTask); + } + + List notExecutedTasks = smartShutdown(threadPoolExecutor); + + assertTrue(threadPoolExecutor.isShutdown()); + assertFalse(notExecutedTasks.isEmpty()); + assertTrue(notExecutedTasks.size() > 0 && notExecutedTasks.size() < 98); + } + + private List smartShutdown(ExecutorService executorService) { + + List notExecutedTasks = new ArrayList<>(); + executorService.shutdown(); + try { + if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) { + notExecutedTasks = executorService.shutdownNow(); + } + } catch (InterruptedException e) { + notExecutedTasks = executorService.shutdownNow(); + } + return notExecutedTasks; + } + + @Test + public void submittingTasks_whenExecutedOneAndAll_thenCorrect() { + + ExecutorService executorService = Executors.newFixedThreadPool(10); + + String result = null; + List> futures = new ArrayList<>(); + try { + result = executorService.invokeAny(callableTasks); + futures = executorService.invokeAll(callableTasks); + } catch (InterruptedException | ExecutionException e) { + e.printStackTrace(); + } + + assertEquals("Task's execution", result); + assertTrue(futures.size() == 3); + } + + @Test + public void submittingTaskShuttingDown_whenGetExpectedResult_thenCorrect() { + + ExecutorService executorService = Executors.newFixedThreadPool(10); + + Future future = executorService.submit(callableTask); + String result = null; + try { + result = future.get(); + result = future.get(200, TimeUnit.MILLISECONDS); + } catch (InterruptedException | ExecutionException | TimeoutException e) { + e.printStackTrace(); + } + + executorService.shutdown(); + + assertEquals("Task's execution", result); + } + + @Test + public void submittingTask_whenCanceled_thenCorrect() { + + ExecutorService executorService = Executors.newFixedThreadPool(10); + + Future future = executorService.submit(callableTask); + + boolean canceled = future.cancel(true); + boolean isCancelled = future.isCancelled(); + + executorService.shutdown(); + + assertTrue(canceled); + assertTrue(isCancelled); + } + + @Test + public void submittingTaskScheduling_whenExecuted_thenCorrect() { + + ScheduledExecutorService executorService = Executors + .newSingleThreadScheduledExecutor(); + + Future resultFuture = executorService.schedule(callableTask, 1, TimeUnit.SECONDS); + String result = null; + try { + result = resultFuture.get(); + } catch (InterruptedException | ExecutionException e) { + e.printStackTrace(); + } + + executorService.shutdown(); + + assertEquals("Task's execution", result); + } +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8ForkJoinTest.java b/core-java/src/test/java/com/baeldung/java8/Java8ForkJoinTest.java new file mode 100644 index 0000000000..273b2d78db --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8ForkJoinTest.java @@ -0,0 +1,100 @@ +package com.baeldung.java8; + + +import com.baeldung.forkjoin.CustomRecursiveAction; +import com.baeldung.forkjoin.CustomRecursiveTask; +import com.baeldung.forkjoin.util.PoolUtil; +import org.junit.Before; +import org.junit.Test; + +import java.util.Random; +import java.util.concurrent.ForkJoinPool; + +import static org.junit.Assert.*; + +public class Java8ForkJoinTest { + + private int[] arr; + private CustomRecursiveTask customRecursiveTask; + + @Before + public void init() { + Random random = new Random(); + arr = new int[50]; + for (int i = 0; i < arr.length; i++) { + arr[i] = random.nextInt(35); + } + customRecursiveTask = new CustomRecursiveTask(arr); + } + + + @Test + public void callPoolUtil_whenExistsAndExpectedType_thenCorrect() { + + ForkJoinPool forkJoinPool = PoolUtil.forkJoinPool; + ForkJoinPool forkJoinPoolTwo = PoolUtil.forkJoinPool; + + assertNotNull(forkJoinPool); + assertEquals(2, forkJoinPool.getParallelism()); + assertEquals(forkJoinPool, forkJoinPoolTwo); + + } + + @Test + public void callCommonPool_whenExistsAndExpectedType_thenCorrect() { + + ForkJoinPool commonPool = ForkJoinPool.commonPool(); + ForkJoinPool commonPoolTwo = ForkJoinPool.commonPool(); + + assertNotNull(commonPool); + assertEquals(commonPool, commonPoolTwo); + + } + + @Test + public void executeRecursiveAction_whenExecuted_thenCorrect() { + + CustomRecursiveAction myRecursiveAction = new CustomRecursiveAction("ddddffffgggghhhh"); + ForkJoinPool.commonPool().invoke(myRecursiveAction); + + assertTrue(myRecursiveAction.isDone()); + + } + + @Test + public void executeRecursiveTask_whenExecuted_thenCorrect() { + + ForkJoinPool forkJoinPool = ForkJoinPool.commonPool(); + + forkJoinPool.execute(customRecursiveTask); + int result = customRecursiveTask.join(); + assertTrue(customRecursiveTask.isDone()); + + forkJoinPool.submit(customRecursiveTask); + int resultTwo = customRecursiveTask.join(); + assertTrue(customRecursiveTask.isDone()); + + } + + @Test + public void executeRecursiveTaskWithFJ_whenExecuted_thenCorrect() { + + CustomRecursiveTask customRecursiveTaskFirst = new CustomRecursiveTask(arr); + CustomRecursiveTask customRecursiveTaskSecond = new CustomRecursiveTask(arr); + CustomRecursiveTask customRecursiveTaskLast = new CustomRecursiveTask(arr); + + customRecursiveTaskFirst.fork(); + customRecursiveTaskSecond.fork(); + customRecursiveTaskLast.fork(); + int result = 0; + result += customRecursiveTaskLast.join(); + result += customRecursiveTaskSecond.join(); + result += customRecursiveTaskFirst.join(); + + assertTrue(customRecursiveTaskFirst.isDone()); + assertTrue(customRecursiveTaskSecond.isDone()); + assertTrue(customRecursiveTaskLast.isDone()); + assertTrue(result != 0); + + } +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8FunctionalInteracesLambdasTest.java b/core-java/src/test/java/com/baeldung/java8/Java8FunctionalInteracesLambdasTest.java new file mode 100644 index 0000000000..faaf3ae407 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8FunctionalInteracesLambdasTest.java @@ -0,0 +1,94 @@ +package com.baeldung.java8; + +import com.baeldung.Foo; +import com.baeldung.FooExtended; +import com.baeldung.UseFoo; +import org.junit.Before; +import org.junit.Test; + +import java.util.function.Function; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; + +public class Java8FunctionalInteracesLambdasTest { + + private UseFoo useFoo; + + @Before + public void init() { + useFoo = new UseFoo(); + } + + @Test + public void functionalInterfaceInstantiation_whenReturnDefiniteString_thenCorrect() { + final Foo foo = parameter -> parameter + "from lambda"; + final String result = useFoo.add("Message ", foo); + + assertEquals("Message from lambda", result); + } + + @Test + public void standardFIParameter_whenReturnDefiniteString_thenCorrect() { + final Function fn = parameter -> parameter + "from lambda"; + final String result = useFoo.addWithStandardFI("Message ", fn); + + assertEquals("Message from lambda", result); + } + + @Test + public void defaultMethodFromExtendedInterface_whenReturnDefiniteString_thenCorrect() { + final FooExtended fooExtended = string -> string; + final String result = fooExtended.defaultMethod(); + + assertEquals("String from Bar", result); + } + + @Test + public void lambdaAndInnerClassInstantiation_whenReturnSameString_thenCorrect() { + final Foo foo = parameter -> parameter + "from Foo"; + + final Foo fooByIC = new Foo() { + @Override + public String method(final String string) { + return string + "from Foo"; + } + }; + + assertEquals(foo.method("Something "), fooByIC.method("Something ")); + } + + @Test + public void accessVariablesFromDifferentScopes_whenReturnPredefinedString_thenCorrect() { + assertEquals("Results: resultIC = Inner class value, resultLambda = Enclosing scope value", useFoo.scopeExperiment()); + } + + @Test + public void shorteningLambdas_whenReturnEqualsResults_thenCorrect() { + final Foo foo = parameter -> buildString(parameter); + + final Foo fooHuge = parameter -> { + final String result = "Something " + parameter; + // many lines of code + return result; + }; + + assertEquals(foo.method("Something"), fooHuge.method("Something")); + } + + private String buildString(final String parameter) { + final String result = "Something " + parameter; + // many lines of code + return result; + } + + @Test + public void mutatingOfEffectivelyFinalVariable_whenNotEquals_thenCorrect() { + final int[] total = new int[1]; + final Runnable r = () -> total[0]++; + r.run(); + + assertNotEquals(0, total[0]); + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java b/core-java/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java new file mode 100644 index 0000000000..d9d88c5052 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java @@ -0,0 +1,67 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.User; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class Java8MethodReferenceTest { + + private List list; + + @Before + public void init() { + list = new ArrayList<>(); + list.add("One"); + list.add("OneAndOnly"); + list.add("Derek"); + list.add("Change"); + list.add("factory"); + list.add("justBefore"); + list.add("Italy"); + list.add("Italy"); + list.add("Thursday"); + list.add(""); + list.add(""); + } + + @Test + public void checkStaticMethodReferences_whenWork_thenCorrect() { + + List users = new ArrayList<>(); + users.add(new User()); + users.add(new User()); + boolean isReal = users.stream().anyMatch(u -> User.isRealUser(u)); + boolean isRealRef = users.stream().anyMatch(User::isRealUser); + assertTrue(isReal); + assertTrue(isRealRef); + } + + @Test + public void checkInstanceMethodReferences_whenWork_thenCorrect() { + User user = new User(); + boolean isLegalName = list.stream().anyMatch(user::isLegalName); + assertTrue(isLegalName); + } + + @Test + public void checkParticularTypeReferences_whenWork_thenCorrect() { + long count = list.stream().filter(String::isEmpty).count(); + assertEquals(count, 2); + } + + @Test + public void checkConstructorReferences_whenWork_thenCorrect() { + Stream stream = list.stream().map(User::new); + List userList = stream.collect(Collectors.toList()); + assertEquals(userList.size(), list.size()); + assertTrue(userList.get(0) instanceof User); + } +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8OptionalTest.java b/core-java/src/test/java/com/baeldung/java8/Java8OptionalTest.java new file mode 100644 index 0000000000..26de39bc0e --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8OptionalTest.java @@ -0,0 +1,118 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.*; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.*; + +public class Java8OptionalTest { + + private List list; + + @Before + public void init() { + list = new ArrayList<>(); + list.add("One"); + list.add("OneAndOnly"); + list.add("Derek"); + list.add("Change"); + list.add("factory"); + list.add("justBefore"); + list.add("Italy"); + list.add("Italy"); + list.add("Thursday"); + list.add(""); + list.add(""); + } + + @Test + public void checkOptional_whenAsExpected_thenCorrect() { + + Optional optionalEmpty = Optional.empty(); + assertFalse(optionalEmpty.isPresent()); + + String str = "value"; + Optional optional = Optional.of(str); + assertEquals(optional.get(), "value"); + + Optional optionalNullable = Optional.ofNullable(str); + Optional optionalNull = Optional.ofNullable(null); + assertEquals(optionalNullable.get(), "value"); + assertFalse(optionalNull.isPresent()); + + List listOpt = Optional.of(list).orElse(new ArrayList<>()); + List listNull = null; + List listOptNull = Optional.ofNullable(listNull).orElse(new ArrayList<>()); + assertTrue(listOpt == list); + assertTrue(listOptNull.isEmpty()); + + Optional user = Optional.ofNullable(getUser()); + String result = user.map(User::getAddress) + .map(Address::getStreet) + .orElse("not specified"); + assertEquals(result, "1st Avenue"); + + Optional optionalUser = Optional.ofNullable(getOptionalUser()); + String resultOpt = optionalUser.flatMap(OptionalUser::getAddress) + .flatMap(OptionalAddress::getStreet) + .orElse("not specified"); + assertEquals(resultOpt, "1st Avenue"); + + Optional userNull = Optional.ofNullable(getUserNull()); + String resultNull = userNull.map(User::getAddress) + .map(Address::getStreet) + .orElse("not specified"); + assertEquals(resultNull, "not specified"); + + Optional optionalUserNull = Optional.ofNullable(getOptionalUserNull()); + String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress) + .flatMap(OptionalAddress::getStreet) + .orElse("not specified"); + assertEquals(resultOptNull, "not specified"); + + } + + @Test(expected = CustomException.class) + public void callMethod_whenCustomException_thenCorrect() { + User user = new User(); + String result = user.getOrThrow(); + } + + private User getUser() { + User user = new User(); + Address address = new Address(); + address.setStreet("1st Avenue"); + user.setAddress(address); + return user; + } + + private OptionalUser getOptionalUser() { + OptionalUser user = new OptionalUser(); + OptionalAddress address = new OptionalAddress(); + address.setStreet("1st Avenue"); + user.setAddress(address); + return user; + } + + private OptionalUser getOptionalUserNull() { + OptionalUser user = new OptionalUser(); + OptionalAddress address = new OptionalAddress(); + address.setStreet(null); + user.setAddress(address); + return user; + } + + private User getUserNull() { + User user = new User(); + Address address = new Address(); + address.setStreet(null); + user.setAddress(address); + return user; + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8SortUnitTest.java b/core-java/src/test/java/com/baeldung/java8/Java8SortUnitTest.java new file mode 100644 index 0000000000..f371c0d7da --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8SortUnitTest.java @@ -0,0 +1,115 @@ +package com.baeldung.java8; + +import com.baeldung.java8.entity.Human; +import com.google.common.collect.Lists; +import com.google.common.primitives.Ints; +import org.junit.Assert; +import org.junit.Test; + +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import static org.hamcrest.Matchers.equalTo; + +public class Java8SortUnitTest { + + // tests - + + @Test + public final void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + Collections.sort(humans, new Comparator() { + @Override + public final int compare(final Human h1, final Human h2) { + return h1.getName().compareTo(h2.getName()); + } + }); + + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort((final Human h1, final Human h2) -> h1.getName().compareTo(h2.getName())); + + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenLambdaShortForm_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); + + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12)); + humans.sort((lhs, rhs) -> { + if (lhs.getName().equals(rhs.getName())) { + return lhs.getAge() - rhs.getAge(); + } else { + return lhs.getName().compareTo(rhs.getName()); + } + }); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenCompositionVerbose_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12)); + final Comparator byName = (h1, h2) -> h1.getName().compareTo(h2.getName()); + final Comparator byAge = (h1, h2) -> Ints.compare(h1.getAge(), h2.getAge()); + + humans.sort(byName.thenComparing(byAge)); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenComposition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12)); + + humans.sort(Comparator.comparing(Human::getName).thenComparing(Human::getAge)); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void whenSortingEntitiesByAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort((h1, h2) -> Ints.compare(h1.getAge(), h2.getAge())); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void whenSortingEntitiesByNameReversed_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + final Comparator comparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); + + humans.sort(comparator.reversed()); + Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); + } + + @Test + public final void givenMethodDefinition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort(Human::compareByNameThenAge); + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + + @Test + public final void givenInstanceMethod_whenSortingEntitiesByName_thenCorrectlySorted() { + final List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); + + humans.sort(Comparator.comparing(Human::getName)); + Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8StreamApiTest.java b/core-java/src/test/java/com/baeldung/java8/Java8StreamApiTest.java new file mode 100644 index 0000000000..37326c6d26 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8StreamApiTest.java @@ -0,0 +1,263 @@ +package com.baeldung.java8; + +import com.baeldung.streamApi.Product; +import org.junit.Before; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.*; +import java.util.regex.Pattern; +import java.util.stream.*; + +import static org.junit.Assert.*; + +public class Java8StreamApiTest { + + private long counter; + + private static Logger log = LoggerFactory.getLogger(Java8StreamApiTest.class); + + private List productList; + + @Before + public void init() { + productList = Arrays.asList( + new Product(23, "potatoes"), new Product(14, "orange"), + new Product(13, "lemon"), new Product(23, "bread"), + new Product(13, "sugar")); + } + + @Test + public void checkPipeline_whenStreamOneElementShorter_thenCorrect() { + + List list = Arrays.asList("abc1", "abc2", "abc3"); + long size = list.stream().skip(1) + .map(element -> element.substring(0, 3)).count(); + assertEquals(list.size() - 1, size); + } + + @Test + public void checkOrder_whenChangeQuantityOfMethodCalls_thenCorrect() { + + List list = Arrays.asList("abc1", "abc2", "abc3"); + + counter = 0; + long sizeFirst = list.stream() + .skip(2).map(element -> { + wasCalled(); + return element.substring(0, 3); + }).count(); + assertEquals(1, counter); + + counter = 0; + long sizeSecond = list.stream().map(element -> { + wasCalled(); + return element.substring(0, 3); + }).skip(2).count(); + assertEquals(3, counter); + } + + @Test + public void createEmptyStream_whenEmpty_thenCorrect() { + + Stream streamEmpty = Stream.empty(); + assertEquals(0, streamEmpty.count()); + + List names = Collections.emptyList(); + Stream streamOf = Product.streamOf(names); + assertTrue(streamOf.count() == 0); + } + + @Test + public void createStream_whenCreated_thenCorrect() { + + Collection collection = Arrays.asList("a", "b", "c"); + Stream streamOfCollection = collection.stream(); + assertEquals(3, streamOfCollection.count()); + + Stream streamOfArray = Stream.of("a", "b", "c"); + assertEquals(3, streamOfArray.count()); + + String[] arr = new String[]{"a", "b", "c"}; + Stream streamOfArrayPart = Arrays.stream(arr, 1, 3); + assertEquals(2, streamOfArrayPart.count()); + + IntStream intStream = IntStream.range(1, 3); + LongStream longStream = LongStream.rangeClosed(1, 3); + Random random = new Random(); + DoubleStream doubleStream = random.doubles(3); + assertEquals(2, intStream.count()); + assertEquals(3, longStream.count()); + assertEquals(3, doubleStream.count()); + + IntStream streamOfChars = "abc".chars(); + IntStream str = "".chars(); + assertEquals(3, streamOfChars.count()); + + Stream streamOfString = Pattern.compile(", ").splitAsStream("a, b, c"); + assertEquals("a", streamOfString.findFirst().get()); + + Path path = getPath(); + Stream streamOfStrings = null; + try { + streamOfStrings = Files.lines(path, Charset.forName("UTF-8")); + } catch (IOException e) { + log.error("Error creating streams from paths {}", path, e.getMessage(), e); + } + assertEquals("a", streamOfStrings.findFirst().get()); + + Stream streamBuilder = Stream.builder().add("a").add("b").add("c").build(); + assertEquals(3, streamBuilder.count()); + + Stream streamGenerated = Stream.generate(() -> "element").limit(10); + assertEquals(10, streamGenerated.count()); + + Stream streamIterated = Stream.iterate(40, n -> n + 2).limit(20); + assertTrue(40 <= streamIterated.findAny().get()); + } + + @Test + public void runStreamPipeline_whenOrderIsRight_thenCorrect() { + + List list = Arrays.asList("abc1", "abc2", "abc3"); + Optional stream = list.stream() + .filter(element -> { + log.info("filter() was called"); + return element.contains("2"); + }).map(element -> { + log.info("map() was called"); + return element.toUpperCase(); + }).findFirst(); + } + + @Test + public void reduce_whenExpected_thenCorrect() { + + OptionalInt reduced = IntStream.range(1, 4).reduce((a, b) -> a + b); + assertEquals(6, reduced.getAsInt()); + + int reducedTwoParams = IntStream.range(1, 4).reduce(10, (a, b) -> a + b); + assertEquals(16, reducedTwoParams); + + int reducedThreeParams = Stream.of(1, 2, 3) + .reduce(10, (a, b) -> a + b, (a, b) -> { + log.info("combiner was called"); + return a + b; + }); + assertEquals(16, reducedThreeParams); + + int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream() + .reduce(10, (a, b) -> a + b, (a, b) -> { + log.info("combiner was called"); + return a + b; + }); + assertEquals(36, reducedThreeParamsParallel); + } + + @Test + public void collecting_whenAsExpected_thenCorrect() { + + List collectorCollection = productList.stream() + .map(Product::getName).collect(Collectors.toList()); + + assertTrue(collectorCollection instanceof List); + assertEquals(5, collectorCollection.size()); + + String listToString = productList.stream().map(Product::getName) + .collect(Collectors.joining(", ", "[", "]")); + + assertTrue(listToString.contains(",") && listToString.contains("[") && listToString.contains("]")); + + double averagePrice = productList.stream().collect(Collectors.averagingInt(Product::getPrice)); + assertTrue(17.2 == averagePrice); + + int summingPrice = productList.stream().collect(Collectors.summingInt(Product::getPrice)); + assertEquals(86, summingPrice); + + IntSummaryStatistics statistics = productList.stream() + .collect(Collectors.summarizingInt(Product::getPrice)); + assertEquals(23, statistics.getMax()); + + Map> collectorMapOfLists = productList.stream() + .collect(Collectors.groupingBy(Product::getPrice)); + assertEquals(3, collectorMapOfLists.keySet().size()); + + Map> mapPartioned = productList.stream() + .collect(Collectors.partitioningBy(element -> element.getPrice() > 15)); + assertEquals(2, mapPartioned.keySet().size()); + + } + + @Test(expected = UnsupportedOperationException.class) + public void collect_whenThrows_thenCorrect() { + Set unmodifiableSet = productList.stream() + .collect(Collectors.collectingAndThen(Collectors.toSet(), + Collections::unmodifiableSet)); + unmodifiableSet.add(new Product(4, "tea")); + } + + @Test + public void customCollector_whenResultContainsAllElementsFrSource_thenCorrect() { + Collector> toLinkedList = + Collector.of(LinkedList::new, LinkedList::add, + (first, second) -> { + first.addAll(second); + return first; + }); + + LinkedList linkedListOfPersons = productList.stream().collect(toLinkedList); + assertTrue(linkedListOfPersons.containsAll(productList)); + } + + @Test + public void parallelStream_whenWorks_thenCorrect() { + Stream streamOfCollection = productList.parallelStream(); + boolean isParallel = streamOfCollection.isParallel(); + boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12) + .anyMatch(price -> price > 200); + assertTrue(isParallel && haveBigPrice); + } + + @Test + public void parallel_whenIsParallel_thenCorrect() { + IntStream intStreamParallel = + IntStream.range(1, 150).parallel().map(element -> element * 34); + boolean isParallel = intStreamParallel.isParallel(); + assertTrue(isParallel); + } + + @Test + public void parallel_whenIsSequential_thenCorrect() { + IntStream intStreamParallel = + IntStream.range(1, 150).parallel().map(element -> element * 34); + IntStream intStreamSequential = intStreamParallel.sequential(); + boolean isParallel = intStreamParallel.isParallel(); + assertFalse(isParallel); + } + + private Path getPath() { + Path path = null; + try { + path = Files.createTempFile(null, ".txt"); + } catch (IOException e) { + log.error(e.getMessage()); + } + + try (BufferedWriter writer = Files.newBufferedWriter(path)) { + writer.write("a\nb\nc"); + } catch (IOException e) { + log.error(e.getMessage()); + } + return path; + } + + private void wasCalled() { + counter++; + } +} diff --git a/core-java/src/test/java/com/baeldung/java8/Java8StreamsTest.java b/core-java/src/test/java/com/baeldung/java8/Java8StreamsTest.java new file mode 100644 index 0000000000..1f1dda49ce --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/Java8StreamsTest.java @@ -0,0 +1,113 @@ +package com.baeldung.java8; + +import com.baeldung.java_8_features.Detail; +import org.junit.Before; +import org.junit.Test; + +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.junit.Assert.*; + +public class Java8StreamsTest { + + private List list; + + @Before + public void init() { + list = new ArrayList<>(); + list.add("One"); + list.add("OneAndOnly"); + list.add("Derek"); + list.add("Change"); + list.add("factory"); + list.add("justBefore"); + list.add("Italy"); + list.add("Italy"); + list.add("Thursday"); + list.add(""); + list.add(""); + } + + @Test + public void checkStreamCount_whenCreating_givenDifferentSources() { + String[] arr = new String[]{"a", "b", "c"}; + Stream streamArr = Arrays.stream(arr); + assertEquals(streamArr.count(), 3); + + Stream streamOf = Stream.of("a", "b", "c"); + assertEquals(streamOf.count(), 3); + + long count = list.stream().distinct().count(); + assertEquals(count, 9); + } + + + @Test + public void checkStreamCount_whenOperationFilter_thanCorrect() { + Stream streamFilter = list.stream().filter(element -> element.isEmpty()); + assertEquals(streamFilter.count(), 2); + } + + + @Test + public void checkStreamCount_whenOperationMap_thanCorrect() { + List uris = new ArrayList<>(); + uris.add("C:\\My.txt"); + Stream streamMap = uris.stream().map(uri -> Paths.get(uri)); + assertEquals(streamMap.count(), 1); + + List details = new ArrayList<>(); + details.add(new Detail()); + details.add(new Detail()); + Stream streamFlatMap = details.stream() + .flatMap(detail -> detail.getParts().stream()); + assertEquals(streamFlatMap.count(), 4); + } + + + @Test + public void checkStreamCount_whenOperationMatch_thenCorrect() { + boolean isValid = list.stream().anyMatch(element -> element.contains("h")); + boolean isValidOne = list.stream().allMatch(element -> element.contains("h")); + boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h")); + assertTrue(isValid); + assertFalse(isValidOne); + assertFalse(isValidTwo); + } + + + @Test + public void checkStreamReducedValue_whenOperationReduce_thenCorrect() { + List integers = new ArrayList<>(); + integers.add(1); + integers.add(1); + integers.add(1); + Integer reduced = integers.stream().reduce(23, (a, b) -> a + b); + assertTrue(reduced == 26); + } + + @Test + public void checkStreamContains_whenOperationCollect_thenCorrect() { + List resultList = list.stream() + .map(element -> element.toUpperCase()) + .collect(Collectors.toList()); + assertEquals(resultList.size(), list.size()); + assertTrue(resultList.contains("")); + } + + + @Test + public void checkParallelStream_whenDoWork() { + list.parallelStream().forEach(element -> doWork(element)); + } + + private void doWork(String string) { + assertTrue(true); //just imitate an amount of work + } +} diff --git a/core-java/src/test/java/com/baeldung/java8/JavaFolderSizeTest.java b/core-java/src/test/java/com/baeldung/java8/JavaFolderSizeTest.java new file mode 100644 index 0000000000..f2e7452137 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/JavaFolderSizeTest.java @@ -0,0 +1,115 @@ +package com.baeldung.java8; + +import org.apache.commons.io.FileUtils; +import org.junit.Before; +import org.junit.Test; + +import java.io.File; +import java.io.IOException; +import java.nio.file.*; +import java.nio.file.attribute.BasicFileAttributes; +import java.text.DecimalFormat; +import java.util.concurrent.atomic.AtomicLong; +import java.util.stream.StreamSupport; + +import static org.junit.Assert.assertEquals; + +public class JavaFolderSizeTest { + + private String path; + + @Before + public void init() { + final String separator = File.separator; + path = String.format("src%stest%sresources", separator, separator); + } + + @Test + public void whenGetFolderSizeRecursive_thenCorrect() { + final long expectedSize = 136; + + final File folder = new File(path); + final long size = getFolderSize(folder); + + assertEquals(expectedSize, size); + } + + @Test + public void whenGetFolderSizeUsingJava7_thenCorrect() throws IOException { + final long expectedSize = 136; + + final AtomicLong size = new AtomicLong(0); + final Path folder = Paths.get(path); + + Files.walkFileTree(folder, new SimpleFileVisitor() { + @Override + public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException { + size.addAndGet(attrs.size()); + return FileVisitResult.CONTINUE; + } + }); + + assertEquals(expectedSize, size.longValue()); + } + + @Test + public void whenGetFolderSizeUsingJava8_thenCorrect() throws IOException { + final long expectedSize = 136; + + final Path folder = Paths.get(path); + final long size = Files.walk(folder).filter(p -> p.toFile().isFile()).mapToLong(p -> p.toFile().length()).sum(); + + assertEquals(expectedSize, size); + } + + @Test + public void whenGetFolderSizeUsingApacheCommonsIO_thenCorrect() { + final long expectedSize = 136; + + final File folder = new File(path); + final long size = FileUtils.sizeOfDirectory(folder); + + assertEquals(expectedSize, size); + } + + @Test + public void whenGetFolderSizeUsingGuava_thenCorrect() { + final long expectedSize = 136; + + final File folder = new File(path); + + final Iterable files = com.google.common.io.Files.fileTreeTraverser().breadthFirstTraversal(folder); + final long size = StreamSupport.stream(files.spliterator(), false) + .filter(File::isFile) + .mapToLong(File::length).sum(); + + assertEquals(expectedSize, size); + } + + @Test + public void whenGetReadableSize_thenCorrect() { + final File folder = new File(path); + final long size = getFolderSize(folder); + + final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"}; + final int unitIndex = (int) (Math.log10(size) / 3); + final double unitValue = 1 << (unitIndex * 10); + + final String readableSize = new DecimalFormat("#,##0.#").format(size / unitValue) + " " + units[unitIndex]; + assertEquals("136 B", readableSize); + } + + private long getFolderSize(final File folder) { + long length = 0; + final File[] files = folder.listFiles(); + + for (File file : files) { + if (file.isFile()) { + length += file.length(); + } else { + length += getFolderSize(file); + } + } + return length; + } +} \ No newline at end of file diff --git a/core-java/src/test/java/com/baeldung/java8/JavaTryWithResourcesTest.java b/core-java/src/test/java/com/baeldung/java8/JavaTryWithResourcesTest.java new file mode 100644 index 0000000000..224c4e9d6a --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/JavaTryWithResourcesTest.java @@ -0,0 +1,86 @@ +package com.baeldung.java8; + +import org.junit.Assert; +import org.junit.Test; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.Date; +import java.util.Scanner; + +public class JavaTryWithResourcesTest { + + private static final String TEST_STRING_HELLO_WORLD = "Hello World"; + private Date resource1Date, resource2Date; + + // tests + + /* Example for using Try_with_resources */ + @Test + public void whenWritingToStringWriter_thenCorrectlyWritten() { + final StringWriter sw = new StringWriter(); + try (PrintWriter pw = new PrintWriter(sw, true)) { + pw.print(TEST_STRING_HELLO_WORLD); + } + + Assert.assertEquals(sw.getBuffer().toString(), TEST_STRING_HELLO_WORLD); + } + + /* Example for using multiple resources */ + @Test + public void givenStringToScanner_whenWritingToStringWriter_thenCorrectlyWritten() { + + final StringWriter sw = new StringWriter(); + try (Scanner sc = new Scanner(TEST_STRING_HELLO_WORLD); PrintWriter pw = new PrintWriter(sw, true)) { + while (sc.hasNext()) { + pw.print(sc.nextLine()); + } + } + + Assert.assertEquals(sw.getBuffer().toString(), TEST_STRING_HELLO_WORLD); + } + + /* Example to show order in which the resources are closed */ + @Test + public void whenFirstAutoClosableResourceIsinitializedFirst_thenFirstAutoClosableResourceIsReleasedFirst() throws Exception { + try (AutoCloseableResourcesFirst af = new AutoCloseableResourcesFirst(); AutoCloseableResourcesSecond as = new AutoCloseableResourcesSecond()) { + af.doSomething(); + as.doSomething(); + } + Assert.assertTrue(resource1Date.after(resource2Date)); + } + + class AutoCloseableResourcesFirst implements AutoCloseable { + public AutoCloseableResourcesFirst() { + System.out.println("Constructor -> AutoCloseableResources_First"); + } + + public void doSomething() { + System.out.println("Something -> AutoCloseableResources_First"); + } + + @Override + public void close() throws Exception { + System.out.println("Closed AutoCloseableResources_First"); + resource1Date = new Date(); + } + } + + class AutoCloseableResourcesSecond implements AutoCloseable { + public AutoCloseableResourcesSecond() { + System.out.println("Constructor -> AutoCloseableResources_Second"); + } + + public void doSomething() { + System.out.println("Something -> AutoCloseableResources_Second"); + } + + @Override + public void close() throws Exception { + System.out.println("Closed AutoCloseableResources_Second"); + resource2Date = new Date(); + Thread.sleep(10000); + } + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/base64/ApacheCommonsEncodeDecodeTest.java b/core-java/src/test/java/com/baeldung/java8/base64/ApacheCommonsEncodeDecodeTest.java new file mode 100644 index 0000000000..164a571817 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/base64/ApacheCommonsEncodeDecodeTest.java @@ -0,0 +1,56 @@ +package com.baeldung.java8.base64; + +import org.apache.commons.codec.binary.Base64; +import org.junit.Test; + +import java.io.UnsupportedEncodingException; + +import static org.junit.Assert.*; + +public class ApacheCommonsEncodeDecodeTest { + + // tests + + @Test + public void whenStringIsEncoded() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final Base64 base64 = new Base64(); + final String encodedString = new String(base64.encode(originalInput.getBytes())); + + assertNotNull(encodedString); + assertNotEquals(originalInput, encodedString); + } + + @Test + public void whenStringIsEncoded_thenStringCanBeDecoded() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final Base64 base64 = new Base64(); + final String encodedString = new String(base64.encode(originalInput.getBytes())); + + final String decodedString = new String(base64.decode(encodedString.getBytes())); + + assertNotNull(decodedString); + assertEquals(originalInput, decodedString); + } + + @Test + public void whenStringIsEncodedUsingStaticMethod() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final String encodedString = new String(Base64.encodeBase64(originalInput.getBytes())); + + assertNotNull(encodedString); + assertNotEquals(originalInput, encodedString); + } + + @Test + public void whenStringIsEncodedUsingStaticMethod_thenStringCanBeDecodedUsingStaticMethod() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final String encodedString = new String(Base64.encodeBase64(originalInput.getBytes())); + + final String decodedString = new String(Base64.decodeBase64(encodedString.getBytes())); + + assertNotNull(decodedString); + assertEquals(originalInput, decodedString); + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/base64/Java8EncodeDecodeTest.java b/core-java/src/test/java/com/baeldung/java8/base64/Java8EncodeDecodeTest.java new file mode 100644 index 0000000000..18dccf71ba --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/base64/Java8EncodeDecodeTest.java @@ -0,0 +1,109 @@ +package com.baeldung.java8.base64; + +import org.junit.Test; + +import java.io.UnsupportedEncodingException; +import java.util.Base64; +import java.util.UUID; + +import static org.junit.Assert.*; + +public class Java8EncodeDecodeTest { + + // tests + + @Test + public void whenStringIsEncoded_thenOk() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes()); + + assertNotNull(encodedString); + assertNotEquals(originalInput, encodedString); + } + + @Test + public void whenStringIsEncoded_thenStringCanBeDecoded() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes()); + + final byte[] decodedBytes = Base64.getDecoder().decode(encodedString); + final String decodedString = new String(decodedBytes); + + assertNotNull(decodedString); + assertEquals(originalInput, decodedString); + } + + @Test + public void whenStringIsEncodedWithoutPadding_thenOk() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final String encodedString = Base64.getEncoder().withoutPadding().encodeToString(originalInput.getBytes()); + + assertNotNull(encodedString); + assertNotEquals(originalInput, encodedString); + } + + @Test + public void whenStringIsEncodedWithoutPadding_thenStringCanBeDecoded() throws UnsupportedEncodingException { + final String originalInput = "test input"; + final String encodedString = Base64.getEncoder().withoutPadding().encodeToString(originalInput.getBytes()); + + final byte[] decodedBytes = Base64.getDecoder().decode(encodedString); + final String decodedString = new String(decodedBytes); + + assertNotNull(decodedString); + assertEquals(originalInput, decodedString); + } + + @Test + public void whenUrlIsEncoded_thenOk() throws UnsupportedEncodingException { + final String originalUrl = "https://www.google.co.nz/?gfe_rd=cr&ei=dzbFVf&gws_rd=ssl#q=java"; + final String encodedUrl = Base64.getUrlEncoder().encodeToString(originalUrl.getBytes()); + assertNotNull(encodedUrl); + assertNotEquals(originalUrl, encodedUrl); + } + + @Test + public void whenUrlIsEncoded_thenURLCanBeDecoded() throws UnsupportedEncodingException { + final String originalUrl = "https://www.google.co.nz/?gfe_rd=cr&ei=dzbFVf&gws_rd=ssl#q=java"; + final String encodedUrl = Base64.getUrlEncoder().encodeToString(originalUrl.getBytes()); + + final byte[] decodedBytes = Base64.getUrlDecoder().decode(encodedUrl.getBytes()); + final String decodedUrl = new String(decodedBytes); + + assertNotNull(decodedUrl); + assertEquals(originalUrl, decodedUrl); + } + + @Test + public void whenMimeIsEncoded_thenOk() throws UnsupportedEncodingException { + final StringBuilder buffer = getMimeBuffer(); + + final byte[] forEncode = buffer.toString().getBytes(); + final String encodedMime = Base64.getMimeEncoder().encodeToString(forEncode); + + assertNotNull(encodedMime); + } + + @Test + public void whenMimeIsEncoded_thenItCanBeDecoded() throws UnsupportedEncodingException { + final StringBuilder buffer = getMimeBuffer(); + + final byte[] forEncode = buffer.toString().getBytes(); + final String encodedMime = Base64.getMimeEncoder().encodeToString(forEncode); + + final byte[] decodedBytes = Base64.getMimeDecoder().decode(encodedMime); + final String decodedMime = new String(decodedBytes); + assertNotNull(decodedMime); + } + + // + + private static StringBuilder getMimeBuffer() { + final StringBuilder buffer = new StringBuilder(); + for (int count = 0; count < 10; ++count) { + buffer.append(UUID.randomUUID().toString()); + } + return buffer; + } + +} diff --git a/core-java/src/test/java/com/baeldung/java8/entity/Human.java b/core-java/src/test/java/com/baeldung/java8/entity/Human.java new file mode 100644 index 0000000000..cab8546129 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java8/entity/Human.java @@ -0,0 +1,89 @@ +package com.baeldung.java8.entity; + +public class Human { + private String name; + private int age; + + public Human() { + super(); + } + + public Human(final String name, final int age) { + super(); + + this.name = name; + this.age = age; + } + + // API + + public String getName() { + return name; + } + + public void setName(final String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(final int age) { + this.age = age; + } + + // compare + + public static int compareByNameThenAge(final Human lhs, final Human rhs) { + if (lhs.name.equals(rhs.name)) { + return lhs.age - rhs.age; + } else { + return lhs.name.compareTo(rhs.name); + } + } + + // + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + age; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + return result; + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final Human other = (Human) obj; + if (age != other.age) { + return false; + } + if (name == null) { + if (other.name != null) { + return false; + } + } else if (!name.equals(other.name)) { + return false; + } + return true; + } + + @Override + public String toString() { + final StringBuilder builder = new StringBuilder(); + builder.append("Human [name=").append(name).append(", age=").append(age).append("]"); + return builder.toString(); + } + +} diff --git a/core-java/src/test/java/com/baeldung/threadpool/CoreThreadPoolTest.java b/core-java/src/test/java/com/baeldung/threadpool/CoreThreadPoolTest.java new file mode 100644 index 0000000000..df336f4a93 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/threadpool/CoreThreadPoolTest.java @@ -0,0 +1,146 @@ +package com.baeldung.threadpool; + +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class CoreThreadPoolTest { + + @Test(timeout = 1000) + public void whenCallingExecuteWithRunnable_thenRunnableIsExecuted() throws InterruptedException { + + CountDownLatch lock = new CountDownLatch(1); + + Executor executor = Executors.newSingleThreadExecutor(); + executor.execute(() -> { + System.out.println("Hello World"); + lock.countDown(); + }); + + lock.await(1000, TimeUnit.MILLISECONDS); + } + + @Test + public void whenUsingExecutorServiceAndFuture_thenCanWaitOnFutureResult() throws InterruptedException, ExecutionException { + + ExecutorService executorService = Executors.newFixedThreadPool(10); + Future future = executorService.submit(() -> "Hello World"); + String result = future.get(); + + assertEquals("Hello World", result); + + } + + @Test + public void whenUsingFixedThreadPool_thenCoreAndMaximumThreadSizeAreTheSame() { + + ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2); + executor.submit(() -> { + Thread.sleep(1000); + return null; + }); + executor.submit(() -> { + Thread.sleep(1000); + return null; + }); + executor.submit(() -> { + Thread.sleep(1000); + return null; + }); + + assertEquals(2, executor.getPoolSize()); + assertEquals(1, executor.getQueue().size()); + + } + + @Test + public void whenUsingCachedThreadPool_thenPoolSizeGrowsUnbounded() { + ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool(); + executor.submit(() -> { + Thread.sleep(1000); + return null; + }); + executor.submit(() -> { + Thread.sleep(1000); + return null; + }); + executor.submit(() -> { + Thread.sleep(1000); + return null; + }); + + assertEquals(3, executor.getPoolSize()); + assertEquals(0, executor.getQueue().size()); + + } + + @Test(timeout = 1000) + public void whenUsingSingleThreadPool_thenTasksExecuteSequentially() throws InterruptedException { + + CountDownLatch lock = new CountDownLatch(2); + AtomicInteger counter = new AtomicInteger(); + + ExecutorService executor = Executors.newSingleThreadExecutor(); + executor.submit(() -> { + counter.set(1); + lock.countDown(); + }); + executor.submit(() -> { + counter.compareAndSet(1, 2); + lock.countDown(); + }); + + lock.await(1000, TimeUnit.MILLISECONDS); + assertEquals(2, counter.get()); + + } + + @Test(timeout = 1000) + public void whenSchedulingTask_thenTaskExecutesWithinGivenPeriod() throws InterruptedException { + + CountDownLatch lock = new CountDownLatch(1); + + ScheduledExecutorService executor = Executors.newScheduledThreadPool(5); + executor.schedule(() -> { + System.out.println("Hello World"); + lock.countDown(); + }, 500, TimeUnit.MILLISECONDS); + + lock.await(1000, TimeUnit.MILLISECONDS); + + } + + @Test(timeout = 1000) + public void whenSchedulingTaskWithFixedPeriod_thenTaskExecutesMultipleTimes() throws InterruptedException { + + CountDownLatch lock = new CountDownLatch(3); + + ScheduledExecutorService executor = Executors.newScheduledThreadPool(5); + ScheduledFuture future = executor.scheduleAtFixedRate(() -> { + System.out.println("Hello World"); + lock.countDown(); + }, 500, 100, TimeUnit.MILLISECONDS); + + lock.await(); + future.cancel(true); + + } + + @Test + public void whenUsingForkJoinPool_thenSumOfTreeElementsIsCalculatedCorrectly() { + + TreeNode tree = new TreeNode(5, + new TreeNode(3), new TreeNode(2, + new TreeNode(2), new TreeNode(8))); + + ForkJoinPool forkJoinPool = ForkJoinPool.commonPool(); + int sum = forkJoinPool.invoke(new CountingTask(tree)); + + assertEquals(20, sum); + } + + +} diff --git a/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolTest.java b/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolTest.java new file mode 100644 index 0000000000..92e0f9a8cb --- /dev/null +++ b/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolTest.java @@ -0,0 +1,56 @@ +package com.baeldung.threadpool; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.stream.Collectors; + +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class GuavaThreadPoolTest { + + @Test + public void whenExecutingTaskWithDirectExecutor_thenTheTaskIsExecutedInTheCurrentThread() { + + Executor executor = MoreExecutors.directExecutor(); + + AtomicBoolean executed = new AtomicBoolean(); + + executor.execute(() -> { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + executed.set(true); + }); + + assertTrue(executed.get()); + } + + @Test + public void whenJoiningFuturesWithAllAsList_thenCombinedFutureCompletesAfterAllFuturesComplete() throws ExecutionException, InterruptedException { + + ExecutorService executorService = Executors.newCachedThreadPool(); + ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executorService); + + ListenableFuture future1 = listeningExecutorService.submit(() -> "Hello"); + ListenableFuture future2 = listeningExecutorService.submit(() -> "World"); + + String greeting = Futures.allAsList(future1, future2).get() + .stream() + .collect(Collectors.joining(" ")); + assertEquals("Hello World", greeting); + + } + +} diff --git a/core-java/src/test/java/com/baeldung/util/CurrentDateTimeTest.java b/core-java/src/test/java/com/baeldung/util/CurrentDateTimeTest.java new file mode 100644 index 0000000000..3384680d8e --- /dev/null +++ b/core-java/src/test/java/com/baeldung/util/CurrentDateTimeTest.java @@ -0,0 +1,41 @@ +package com.baeldung.util; + +import org.junit.Test; + +import java.time.*; +import java.time.temporal.ChronoField; + +import static org.junit.Assert.assertEquals; + +public class CurrentDateTimeTest { + + private static final Clock clock = Clock.fixed(Instant.parse("2016-10-09T15:10:30.00Z"), ZoneId.of("UTC")); + + @Test + public void shouldReturnCurrentDate() { + + final LocalDate now = LocalDate.now(clock); + + assertEquals(9, now.get(ChronoField.DAY_OF_MONTH)); + assertEquals(10, now.get(ChronoField.MONTH_OF_YEAR)); + assertEquals(2016, now.get(ChronoField.YEAR)); + } + + @Test + public void shouldReturnCurrentTime() { + + final LocalTime now = LocalTime.now(clock); + + assertEquals(15, now.get(ChronoField.HOUR_OF_DAY)); + assertEquals(10, now.get(ChronoField.MINUTE_OF_HOUR)); + assertEquals(30, now.get(ChronoField.SECOND_OF_MINUTE)); + } + + @Test + public void shouldReturnCurrentTimestamp() { + + final Instant now = Instant.now(clock); + + assertEquals(clock.instant().getEpochSecond(), now.getEpochSecond()); + } +}