iSharkFly-Open/Java-Tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/eugenp/tutorials

Browse Source
This commit is contained in:
Thai Nguyen
2016-10-30 21:31:01 +07:00
parent f66494192c 2fcf097d88
commit c6c4313911
119 changed files with 17018 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core-java/pom.xml
+35
View File
@@ -279,6 +279,41 @@
</plugins>
</build>
<profiles>
<profile>
<id>integration</id>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<executions>
<execution>
<phase>integration-test</phase>
<goals>
<goal>test</goal>
</goals>
<configuration>
<excludes>
<exclude>**/*ManualTest.java</exclude>
</excludes>
<includes>
<include>**/*IntegrationTest.java</include>
</includes>
</configuration>
</execution>
</executions>
<configuration>
<systemPropertyVariables>
<test.mime>json</test.mime>
</systemPropertyVariables>
</configuration>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<properties>
<!-- persistence -->
core-java/src/main/java/com/baeldung/printscreen/Screenshot.java
-1
View File
@@ -14,7 +14,6 @@ public class Screenshot {
}
public void getScreenshot(int timeToWait) throws Exception {
Thread.sleep(timeToWait);
Rectangle rectangle = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
Robot robot = new Robot();
BufferedImage img = robot.createScreenCapture(rectangle);
core-java/src/main/java/org/baeldung/equalshashcode/entities/ComplexClass.java
+1 -3
View File
@@ -1,7 +1,5 @@
package org.baeldung.equalshashcode.entities;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -10,7 +8,7 @@ public class ComplexClass {
private List<?> genericList;
private Set<Integer> integerSet;
public ComplexClass(ArrayList<?> genericArrayList, HashSet<Integer> integerHashSet) {
public ComplexClass(List<?> genericArrayList, Set<Integer> integerHashSet) {
super();
this.genericList = genericArrayList;
this.integerSet = integerHashSet;
core-java/src/main/resources/fileTest.txt
+1
View File
@@ -0,0 +1 @@
Hello World from fileTest.txt!!!
core-java/src/test/java/com/baeldung/CharToStringTest.java → core-java/src/test/java/com/baeldung/CharToStringUnitTest.java
+1 -1
View File
@@ -4,7 +4,7 @@ import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class CharToStringTest {
public class CharToStringUnitTest {
@Test
public void givenChar_whenCallingStringValueOf_shouldConvertToString() {
core-java/src/test/java/com/baeldung/collectors/Java8CollectorsTest.java → core-java/src/test/java/com/baeldung/collectors/Java8CollectorsUnitTest.java
+1 -1
View File
@@ -36,7 +36,7 @@ import static java.util.stream.Collectors.toSet;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
public class Java8CollectorsTest {
public class Java8CollectorsUnitTest {
private final List<String> givenList = Arrays.asList("a", "bb", "ccc", "dd");
core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeTest.java → core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java
+1 -1
View File
@@ -7,7 +7,7 @@ import java.time.Month;
import org.junit.Assert;
import org.junit.Test;
public class UseLocalDateTimeTest {
public class UseLocalDateTimeUnitTest {
UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
core-java/src/test/java/com/baeldung/datetime/UseLocalDateTest.java → core-java/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java
+1 -1
View File
@@ -7,7 +7,7 @@ import java.time.LocalDateTime;
import org.junit.Assert;
import org.junit.Test;
public class UseLocalDateTest {
public class UseLocalDateUnitTest {
UseLocalDate useLocalDate = new UseLocalDate();
core-java/src/test/java/com/baeldung/datetime/UseLocalTimeTest.java → core-java/src/test/java/com/baeldung/datetime/UseLocalTimeUnitTest.java
+1 -1
View File
@@ -5,7 +5,7 @@ import java.time.LocalTime;
import org.junit.Assert;
import org.junit.Test;
public class UseLocalTimeTest {
public class UseLocalTimeUnitTest {
UseLocalTime useLocalTime = new UseLocalTime();
core-java/src/test/java/com/baeldung/datetime/UsePeriodTest.java → core-java/src/test/java/com/baeldung/datetime/UsePeriodUnitTest.java
+1 -1
View File
@@ -6,7 +6,7 @@ import java.time.Period;
import org.junit.Assert;
import org.junit.Test;
public class UsePeriodTest {
public class UsePeriodUnitTest {
UsePeriod usingPeriod=new UsePeriod();
@Test
core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeTest.java → core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeUnitTest.java
+1 -1
View File
@@ -7,7 +7,7 @@ import java.time.ZonedDateTime;
import org.junit.Assert;
import org.junit.Test;
public class UseZonedDateTimeTest {
public class UseZonedDateTimeUnitTest {
UseZonedDateTime zonedDateTime=new UseZonedDateTime();
core-java/src/test/java/com/baeldung/doublecolon/TestComputerUtils.java → core-java/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java
+1 -1
View File
@@ -13,7 +13,7 @@ import java.util.function.BiFunction;
import static com.baeldung.doublecolon.ComputerUtils.*;
public class TestComputerUtils {
public class ComputerUtilsUnitTest {
@Before
public void setup() {
core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoder.java → core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoderUnitTest.java
+15 -16
View File
@@ -7,7 +7,6 @@ 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;
@@ -15,13 +14,13 @@ 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 {
import static java.util.stream.Collectors.joining;
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);
public class EncoderDecoderUnitTest {
private static final Logger LOGGER = LoggerFactory.getLogger(EncoderDecoderUnitTest.class);
private static final String testUrl = "http://www.baeldung.com?key1=value+1&key2=value%40%21%242&key3=value%253";
private String encodeValue(String value) {
String encoded = null;
@@ -46,7 +45,7 @@ public class EncoderDecoder {
@Test
public void givenURL_whenAnalyze_thenCorrect() throws Exception {
URL url = new URL(URL);
URL url = new URL(testUrl);
Assert.assertThat(url.getProtocol(), CoreMatchers.is("http"));
Assert.assertThat(url.getHost(), CoreMatchers.is("www.baeldung.com"));
@@ -60,25 +59,25 @@ public class EncoderDecoder {
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;
String encodedURL = requestParams.keySet().stream()
.map(key -> key + "=" + encodeValue(requestParams.get(key)))
.collect(joining("&", "http://www.baeldung.com?", ""));
Assert.assertThat(URL, CoreMatchers.is(encodedURL));
Assert.assertThat(testUrl, CoreMatchers.is(encodedURL));
}
@Test
public void givenRequestParam_whenUTF8Scheme_thenDecodeRequestParams() throws Exception {
URL url = new URL(URL);
URL url = new URL(testUrl);
String query = url.getQuery();
String decodedQuery = Arrays.stream(query.split("&"))
.map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1]))
.collect(Collectors.joining("&"));
.map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1]))
.collect(joining("&"));
Assert.assertEquals(
"http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery);
"http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery);
}
}
core-java/src/test/java/com/baeldung/enums/PizzaTest.java → core-java/src/test/java/com/baeldung/enums/PizzaUnitTest.java
+1 -1
View File
@@ -9,7 +9,7 @@ import java.util.List;
import static junit.framework.TestCase.assertTrue;
public class PizzaTest {
public class PizzaUnitTest {
@Test
public void givenPizaOrder_whenReady_thenDeliverable() {
core-java/src/test/java/com/baeldung/file/FileOperationsTest.java → core-java/src/test/java/com/baeldung/file/FileOperationsUnitTest.java
+19 -19
View File
@@ -1,11 +1,5 @@
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;
@@ -20,7 +14,13 @@ import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;
public class FileOperationsTest {
import org.apache.commons.io.FileUtils;
import org.hamcrest.CoreMatchers;
import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Test;
public class FileOperationsUnitTest {
@Test
public void givenFileName_whenUsingClassloader_thenFileData() throws IOException {
@@ -30,15 +30,15 @@ public class FileOperationsTest {
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;
Class clazz = FileOperationsUnitTest.class;
InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt");
String data = readFromInputStream(inputStream);
@@ -69,44 +69,44 @@ public class FileOperationsTest {
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<String> 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))) {
core-java/src/test/java/com/baeldung/java/networking/udp/UDPTest.java → core-java/src/test/java/com/baeldung/java/networking/udp/UDPIntegrationTest.java
+1 -1
View File
@@ -10,7 +10,7 @@ import java.io.IOException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
public class UDPTest {
public class UDPIntegrationTest {
private EchoClient client;
@Before
core-java/src/test/java/com/baeldung/java/networking/url/UrlUnitTest.java
+104
View File
@@ -0,0 +1,104 @@
package com.baeldung.java.networking.url;
import static org.junit.Assert.assertEquals;
import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Test;
public class UrlUnitTest {
@Test
public void givenUrl_whenCanIdentifyProtocol_thenCorrect() throws MalformedURLException {
final URL url = new URL("http://baeldung.com");
assertEquals("http", url.getProtocol());
}
@Test
public void givenUrl_whenCanGetHost_thenCorrect() throws MalformedURLException {
final URL url = new URL("http://baeldung.com");
assertEquals("baeldung.com", url.getHost());
}
@Test
public void givenUrl_whenCanGetFileName_thenCorrect2() throws MalformedURLException {
final URL url = new URL("http://baeldung.com/articles?topic=java&version=8");
assertEquals("/articles?topic=java&version=8", url.getFile());
}
@Test
public void givenUrl_whenCanGetFileName_thenCorrect1() throws MalformedURLException {
final URL url = new URL("http://baeldung.com/guidelines.txt");
assertEquals("/guidelines.txt", url.getFile());
}
@Test
public void givenUrl_whenCanGetPathParams_thenCorrect() throws MalformedURLException {
final URL url = new URL("http://baeldung.com/articles?topic=java&version=8");
assertEquals("/articles", url.getPath());
}
@Test
public void givenUrl_whenCanGetQueryParams_thenCorrect() throws MalformedURLException {
final URL url = new URL("http://baeldung.com/articles?topic=java");
assertEquals("topic=java", url.getQuery());
}
@Test
public void givenUrl_whenGetsDefaultPort_thenCorrect() throws MalformedURLException {
final URL url = new URL("http://baeldung.com");
assertEquals(-1, url.getPort());
assertEquals(80, url.getDefaultPort());
}
@Test
public void givenUrl_whenGetsPort_thenCorrect() throws MalformedURLException {
final URL url = new URL("http://baeldung.com:8090");
assertEquals(8090, url.getPort());
assertEquals(80, url.getDefaultPort());
}
@Test
public void givenBaseUrl_whenCreatesRelativeUrl_thenCorrect() throws MalformedURLException {
final URL baseUrl = new URL("http://baeldung.com");
final URL relativeUrl = new URL(baseUrl, "a-guide-to-java-sockets");
assertEquals("http://baeldung.com/a-guide-to-java-sockets", relativeUrl.toString());
}
@Test
public void givenAbsoluteUrl_whenIgnoresBaseUrl_thenCorrect() throws MalformedURLException {
final URL baseUrl = new URL("http://baeldung.com");
final URL relativeUrl = new URL(baseUrl, "http://baeldung.com/a-guide-to-java-sockets");
assertEquals("http://baeldung.com/a-guide-to-java-sockets", relativeUrl.toString());
}
@Test
public void givenUrlComponents_whenConstructsCompleteUrl_thenCorrect() throws MalformedURLException {
final String protocol = "http";
final String host = "baeldung.com";
final String file = "/guidelines.txt";
final URL url = new URL(protocol, host, file);
assertEquals("http://baeldung.com/guidelines.txt", url.toString());
}
@Test
public void givenUrlComponents_whenConstructsCompleteUrl_thenCorrect2() throws MalformedURLException {
final String protocol = "http";
final String host = "baeldung.com";
final String file = "/articles?topic=java&version=8";
final URL url = new URL(protocol, host, file);
assertEquals("http://baeldung.com/articles?topic=java&version=8", url.toString());
}
@Test
public void givenUrlComponentsWithPort_whenConstructsCompleteUrl_thenCorrect() throws MalformedURLException {
final String protocol = "http";
final String host = "baeldung.com";
final int port = 9000;
final String file = "/guidelines.txt";
final URL url = new URL(protocol, host, port, file);
assertEquals("http://baeldung.com:9000/guidelines.txt", url.toString());
}
}
core-java/src/test/java/com/baeldung/java/nio/selector/EchoTest.java → core-java/src/test/java/com/baeldung/java/nio/selector/NioEchoIntegrationTest.java
+1 -1
View File
@@ -6,7 +6,7 @@ import java.io.IOException;
import org.junit.Test;
public class EchoTest {
public class NioEchoIntegrationTest {
@Test
public void givenClient_whenServerEchosMessage_thenCorrect() throws IOException, InterruptedException {
core-java/src/test/java/com/baeldung/java/nio2/FileUnitTest.java
+264
View File
@@ -0,0 +1,264 @@
package com.baeldung.java.nio2;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.nio.file.DirectoryNotEmptyException;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Date;
import org.junit.Test;
public class FileUnitTest {
private static final String HOME = System.getProperty("user.home");
// checking file or dir
@Test
public void givenExistentPath_whenConfirmsFileExists_thenCorrect() {
final Path p = Paths.get(HOME);
assertTrue(Files.exists(p));
}
@Test
public void givenNonexistentPath_whenConfirmsFileNotExists_thenCorrect() {
final Path p = Paths.get(HOME + "/inexistent_file.txt");
assertTrue(Files.notExists(p));
}
@Test
public void givenExistentDirPath_whenConfirmsNotRegularFile_thenCorrect() {
final Path p = Paths.get(HOME);
assertFalse(Files.isRegularFile(p));
}
@Test
public void givenExistentDirPath_whenConfirmsReadable_thenCorrect() {
final Path p = Paths.get(HOME);
assertTrue(Files.isReadable(p));
}
@Test
public void givenExistentDirPath_whenConfirmsWritable_thenCorrect() {
final Path p = Paths.get(HOME);
assertTrue(Files.isWritable(p));
}
@Test
public void givenExistentDirPath_whenConfirmsExecutable_thenCorrect() {
final Path p = Paths.get(HOME);
assertTrue(Files.isExecutable(p));
}
@Test
public void givenSameFilePaths_whenConfirmsIsSame_thenCorrect() throws IOException {
final Path p1 = Paths.get(HOME);
final Path p2 = Paths.get(HOME);
assertTrue(Files.isSameFile(p1, p2));
}
// reading, writing and creating files
// creating file
@Test
public void givenFilePath_whenCreatesNewFile_thenCorrect() throws IOException {
final String fileName = "myfile_" + new Date().getTime() + ".txt";
final Path p = Paths.get(HOME + "/" + fileName);
assertFalse(Files.exists(p));
Files.createFile(p);
assertTrue(Files.exists(p));
}
@Test
public void givenDirPath_whenCreatesNewDir_thenCorrect() throws IOException {
final String dirName = "myDir_" + new Date().getTime();
final Path p = Paths.get(HOME + "/" + dirName);
assertFalse(Files.exists(p));
Files.createDirectory(p);
assertTrue(Files.exists(p));
assertFalse(Files.isRegularFile(p));
assertTrue(Files.isDirectory(p));
}
@Test
public void givenDirPath_whenFailsToCreateRecursively_thenCorrect() {
final String dirName = "myDir_" + new Date().getTime() + "/subdir";
final Path p = Paths.get(HOME + "/" + dirName);
assertFalse(Files.exists(p));
try {
Files.createDirectory(p);
} catch (final IOException e) {
assertTrue(e instanceof NoSuchFileException);
}
}
@Test
public void givenDirPath_whenCreatesRecursively_thenCorrect() throws IOException {
final Path dir = Paths.get(HOME + "/myDir_" + new Date().getTime());
final Path subdir = dir.resolve("subdir");
assertFalse(Files.exists(dir));
assertFalse(Files.exists(subdir));
Files.createDirectories(subdir);
assertTrue(Files.exists(dir));
assertTrue(Files.exists(subdir));
}
@Test
public void givenFilePath_whenCreatesTempFile_thenCorrect() throws IOException {
final String prefix = "log_";
final String suffix = ".txt";
Path p = Paths.get(HOME + "/");
p = Files.createTempFile(p, prefix, suffix);
// like log_8821081429012075286.txt
assertTrue(Files.exists(p));
}
@Test
public void givenFilePath_whenCreatesTempFileWithDefaultsNaming_thenCorrect() throws IOException {
Path p = Paths.get(HOME + "/");
p = Files.createTempFile(p, null, null);
// like 8600179353689423985.tmp
System.out.println(p);
assertTrue(Files.exists(p));
}
@Test
public void givenNoFilePath_whenCreatesTempFileInTempDir_thenCorrect() throws IOException {
final Path p = Files.createTempFile(null, null);
// like C:\Users\new\AppData\Local\Temp\6100927974988978748.tmp
assertTrue(Files.exists(p));
}
// delete file
@Test
public void givenPath_whenDeletes_thenCorrect() throws IOException {
final Path p = Paths.get(HOME + "/fileToDelete.txt");
assertFalse(Files.exists(p));
Files.createFile(p);
assertTrue(Files.exists(p));
Files.delete(p);
assertFalse(Files.exists(p));
}
@Test
public void givenPath_whenFailsToDeleteNonEmptyDir_thenCorrect() throws IOException {
final Path dir = Paths.get(HOME + "/emptyDir" + new Date().getTime());
Files.createDirectory(dir);
assertTrue(Files.exists(dir));
final Path file = dir.resolve("file.txt");
Files.createFile(file);
try {
Files.delete(dir);
} catch (final IOException e) {
assertTrue(e instanceof DirectoryNotEmptyException);
}
assertTrue(Files.exists(dir));
}
@Test
public void givenInexistentFile_whenDeleteFails_thenCorrect() throws IOException {
final Path p = Paths.get(HOME + "/inexistentFile.txt");
assertFalse(Files.exists(p));
try {
Files.delete(p);
} catch (final IOException e) {
assertTrue(e instanceof NoSuchFileException);
}
}
@Test
public void givenInexistentFile_whenDeleteIfExistsWorks_thenCorrect() throws IOException {
final Path p = Paths.get(HOME + "/inexistentFile.txt");
assertFalse(Files.exists(p));
Files.deleteIfExists(p);
}
// copy file
@Test
public void givenFilePath_whenCopiesToNewLocation_thenCorrect() throws IOException {
final Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
final Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
Files.createDirectory(dir1);
Files.createDirectory(dir2);
final Path file1 = dir1.resolve("filetocopy.txt");
final Path file2 = dir2.resolve("filetocopy.txt");
Files.createFile(file1);
assertTrue(Files.exists(file1));
assertFalse(Files.exists(file2));
Files.copy(file1, file2);
assertTrue(Files.exists(file2));
}
@Test
public void givenPath_whenCopyFailsDueToExistingFile_thenCorrect() throws IOException {
final Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
final Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
Files.createDirectory(dir1);
Files.createDirectory(dir2);
final Path file1 = dir1.resolve("filetocopy.txt");
final Path file2 = dir2.resolve("filetocopy.txt");
Files.createFile(file1);
Files.createFile(file2);
assertTrue(Files.exists(file1));
assertTrue(Files.exists(file2));
try {
Files.copy(file1, file2);
} catch (final IOException e) {
assertTrue(e instanceof FileAlreadyExistsException);
}
Files.copy(file1, file2, StandardCopyOption.REPLACE_EXISTING);
}
// moving files
@Test
public void givenFilePath_whenMovesToNewLocation_thenCorrect() throws IOException {
final Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
final Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
Files.createDirectory(dir1);
Files.createDirectory(dir2);
final Path file1 = dir1.resolve("filetocopy.txt");
final Path file2 = dir2.resolve("filetocopy.txt");
Files.createFile(file1);
assertTrue(Files.exists(file1));
assertFalse(Files.exists(file2));
Files.move(file1, file2);
assertTrue(Files.exists(file2));
assertFalse(Files.exists(file1));
}
@Test
public void givenFilePath_whenMoveFailsDueToExistingFile_thenCorrect() throws IOException {
final Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
final Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
Files.createDirectory(dir1);
Files.createDirectory(dir2);
final Path file1 = dir1.resolve("filetocopy.txt");
final Path file2 = dir2.resolve("filetocopy.txt");
Files.createFile(file1);
Files.createFile(file2);
assertTrue(Files.exists(file1));
assertTrue(Files.exists(file2));
try {
Files.move(file1, file2);
} catch (final IOException e) {
assertTrue(e instanceof FileAlreadyExistsException);
}
Files.move(file1, file2, StandardCopyOption.REPLACE_EXISTING);
assertTrue(Files.exists(file2));
assertFalse(Files.exists(file1));
}
}
core-java/src/test/java/com/baeldung/java/nio2/PathManualTest.java
+196
View File
@@ -0,0 +1,196 @@
package com.baeldung.java.nio2;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.net.URI;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.junit.Test;
public class PathManualTest {
private static final String HOME = System.getProperty("user.home");
// creating a path
@Test
public void givenPathString_whenCreatesPathObject_thenCorrect() {
final Path p = Paths.get("/articles/baeldung");
assertEquals("\\articles\\baeldung", p.toString());
}
@Test
public void givenPathParts_whenCreatesPathObject_thenCorrect() {
final Path p = Paths.get("/articles", "baeldung");
assertEquals("\\articles\\baeldung", p.toString());
}
// retrieving path info
@Test
public void givenPath_whenRetrievesFileName_thenCorrect() {
final Path p = Paths.get("/articles/baeldung/logs");
assertEquals("logs", p.getFileName().toString());
}
@Test
public void givenPath_whenRetrievesNameByIndex_thenCorrect() {
final Path p = Paths.get("/articles/baeldung/logs");
assertEquals("articles", p.getName(0).toString());
assertEquals("baeldung", p.getName(1).toString());
assertEquals("logs", p.getName(2).toString());
}
@Test
public void givenPath_whenCountsParts_thenCorrect() {
final Path p = Paths.get("/articles/baeldung/logs");
assertEquals(3, p.getNameCount());
}
@Test
public void givenPath_whenCanRetrieveSubsequenceByIndex_thenCorrect() {
final Path p = Paths.get("/articles/baeldung/logs");
assertEquals("articles", p.subpath(0, 1).toString());
assertEquals("articles\\baeldung", p.subpath(0, 2).toString());
assertEquals("articles\\baeldung\\logs", p.subpath(0, 3).toString());
assertEquals("baeldung", p.subpath(1, 2).toString());
assertEquals("baeldung\\logs", p.subpath(1, 3).toString());
assertEquals("logs", p.subpath(2, 3).toString());
}
@Test
public void givenPath_whenRetrievesParent_thenCorrect() {
final Path p1 = Paths.get("/articles/baeldung/logs");
final Path p2 = Paths.get("/articles/baeldung");
final Path p3 = Paths.get("/articles");
final Path p4 = Paths.get("/");
assertEquals("\\articles\\baeldung", p1.getParent().toString());
assertEquals("\\articles", p2.getParent().toString());
assertEquals("\\", p3.getParent().toString());
assertEquals(null, p4.getParent());
}
@Test
public void givenPath_whenRetrievesRoot_thenCorrect() {
final Path p1 = Paths.get("/articles/baeldung/logs");
final Path p2 = Paths.get("c:/articles/baeldung/logs");
assertEquals("\\", p1.getRoot().toString());
assertEquals("c:\\", p2.getRoot().toString());
}
// removing redundancies from path
@Test
public void givenPath_whenRemovesRedundancies_thenCorrect1() {
Path p = Paths.get("/home/./baeldung/articles");
p = p.normalize();
assertEquals("\\home\\baeldung\\articles", p.toString());
}
@Test
public void givenPath_whenRemovesRedundancies_thenCorrect2() {
Path p = Paths.get("/home/baeldung/../articles");
p = p.normalize();
assertEquals("\\home\\articles", p.toString());
}
// converting a path
@Test
public void givenPath_whenConvertsToBrowseablePath_thenCorrect() {
final Path p = Paths.get("/home/baeldung/articles.html");
final URI uri = p.toUri();
assertEquals("file:///E:/home/baeldung/articles.html", uri.toString());
}
@Test
public void givenPath_whenConvertsToAbsolutePath_thenCorrect() {
final Path p = Paths.get("/home/baeldung/articles.html");
assertEquals("E:\\home\\baeldung\\articles.html", p.toAbsolutePath().toString());
}
@Test
public void givenAbsolutePath_whenRetainsAsAbsolute_thenCorrect() {
final Path p = Paths.get("E:\\home\\baeldung\\articles.html");
assertEquals("E:\\home\\baeldung\\articles.html", p.toAbsolutePath().toString());
}
@Test
public void givenExistingPath_whenGetsRealPathToFile_thenCorrect() throws IOException {
final Path p = Paths.get(HOME);
assertEquals(HOME, p.toRealPath().toString());
}
@Test
public void givenInExistentPath_whenFailsToConvert_thenCorrect() {
final Path p = Paths.get("E:\\home\\baeldung\\articles.html");
try {
p.toRealPath();
} catch (final IOException e) {
assertTrue(true);
}
}
// joining paths
@Test
public void givenTwoPaths_whenJoinsAndResolves_thenCorrect() throws IOException {
final Path p = Paths.get("/baeldung/articles");
assertEquals("\\baeldung\\articles\\java", p.resolve("java").toString());
}
@Test
public void givenAbsolutePath_whenResolutionRetainsIt_thenCorrect() throws IOException {
final Path p = Paths.get("/baeldung/articles");
assertEquals("C:\\baeldung\\articles\\java", p.resolve("C:\\baeldung\\articles\\java").toString());
}
@Test
public void givenPathWithRoot_whenResolutionRetainsIt_thenCorrect2() throws IOException {
final Path p = Paths.get("/baeldung/articles");
assertEquals("\\java", p.resolve("/java").toString());
}
// creating a path between 2 paths
@Test
public void givenSiblingPaths_whenCreatesPathToOther_thenCorrect() throws IOException {
final Path p1 = Paths.get("articles");
final Path p2 = Paths.get("authors");
assertEquals("..\\authors", p1.relativize(p2).toString());
assertEquals("..\\articles", p2.relativize(p1).toString());
}
@Test
public void givenNonSiblingPaths_whenCreatesPathToOther_thenCorrect() throws IOException {
final Path p1 = Paths.get("/baeldung");
final Path p2 = Paths.get("/baeldung/authors/articles");
assertEquals("authors\\articles", p1.relativize(p2).toString());
assertEquals("..\\..", p2.relativize(p1).toString());
}
// comparing 2 paths
@Test
public void givenTwoPaths_whenTestsEquality_thenCorrect() throws IOException {
final Path p1 = Paths.get("/baeldung/articles");
final Path p2 = Paths.get("/baeldung/articles");
final Path p3 = Paths.get("/baeldung/authors");
assertTrue(p1.equals(p2));
assertFalse(p1.equals(p3));
}
@Test
public void givenPath_whenInspectsStart_thenCorrect() {
final Path p1 = Paths.get("/baeldung/articles");
assertTrue(p1.startsWith("/baeldung"));
}
@Test
public void givenPath_whenInspectsEnd_thenCorrect() {
final Path p1 = Paths.get("/baeldung/articles");
assertTrue(p1.endsWith("articles"));
}
}
core-java/src/test/java/com/baeldung/java/reflection/ReflectionUnitTest.java
+85 -80
View File
File diff suppressed because it is too large Load Diff
core-java/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java → core-java/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsUnitTest.java
+1 -1
View File
@@ -6,7 +6,7 @@ import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class Java8DefaultStaticIntefaceMethodsTest {
public class Java8DefaultStaticIntefaceMethodsUnitTest {
@Test
public void callStaticInterfaceMethdosMethods_whenExpectedResults_thenCorrect() {
core-java/src/test/java/com/baeldung/java8/Java8ExecutorServiceTest.java → core-java/src/test/java/com/baeldung/java8/Java8ExecutorServiceIntegrationTest.java
+19 -13
View File
@@ -1,17 +1,26 @@
package com.baeldung.java8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
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 {
public class Java8ExecutorServiceIntegrationTest {
private Runnable runnableTask;
private Callable<String> callableTask;
@@ -53,9 +62,7 @@ public class Java8ExecutorServiceTest {
@Test
public void creationSubmittingTasksShuttingDownNow_whenShutDownAfterAwating_thenCorrect() {
ExecutorService threadPoolExecutor =
new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>());
ExecutorService threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
for (int i = 0; i < 100; i++) {
threadPoolExecutor.submit(callableTask);
@@ -138,8 +145,7 @@ public class Java8ExecutorServiceTest {
@Test
public void submittingTaskScheduling_whenExecuted_thenCorrect() {
ScheduledExecutorService executorService = Executors
.newSingleThreadScheduledExecutor();
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
Future<String> resultFuture = executorService.schedule(callableTask, 1, TimeUnit.SECONDS);
String result = null;
core-java/src/test/java/com/baeldung/java8/Java8ForkJoinTest.java → core-java/src/test/java/com/baeldung/java8/Java8ForkJoinIntegrationTest.java
+11 -17
View File
@@ -1,18 +1,20 @@
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 static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
public class Java8ForkJoinTest {
import com.baeldung.forkjoin.CustomRecursiveAction;
import com.baeldung.forkjoin.CustomRecursiveTask;
import com.baeldung.forkjoin.util.PoolUtil;
public class Java8ForkJoinIntegrationTest {
private int[] arr;
private CustomRecursiveTask customRecursiveTask;
@@ -27,28 +29,23 @@ public class Java8ForkJoinTest {
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
@@ -63,7 +60,6 @@ public class Java8ForkJoinTest {
@Test
public void executeRecursiveTask_whenExecuted_thenCorrect() {
ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
forkJoinPool.execute(customRecursiveTask);
@@ -73,12 +69,10 @@ public class Java8ForkJoinTest {
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);
@@ -95,6 +89,6 @@ public class Java8ForkJoinTest {
assertTrue(customRecursiveTaskSecond.isDone());
assertTrue(customRecursiveTaskLast.isDone());
assertTrue(result != 0);
}
}
core-java/src/test/java/com/baeldung/java8/Java8FunctionalInteracesLambdasTest.java → core-java/src/test/java/com/baeldung/java8/Java8FunctionalInteracesLambdasUnitTest.java
+1 -1
View File
@@ -11,7 +11,7 @@ import java.util.function.Function;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
public class Java8FunctionalInteracesLambdasTest {
public class Java8FunctionalInteracesLambdasUnitTest {
private UseFoo useFoo;
core-java/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java → core-java/src/test/java/com/baeldung/java8/Java8MethodReferenceUnitTest.java
+1 -1
View File
@@ -12,7 +12,7 @@ import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class Java8MethodReferenceTest {
public class Java8MethodReferenceUnitTest {
private List<String> list;
core-java/src/test/java/com/baeldung/java8/Java8OptionalTest.java → core-java/src/test/java/com/baeldung/java8/Java8OptionalUnitTest.java
+16 -18
View File
@@ -1,16 +1,23 @@
package com.baeldung.java8;
import com.baeldung.java_8_features.*;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
public class Java8OptionalTest {
import com.baeldung.java_8_features.Address;
import com.baeldung.java_8_features.CustomException;
import com.baeldung.java_8_features.OptionalAddress;
import com.baeldung.java_8_features.OptionalUser;
import com.baeldung.java_8_features.User;
public class Java8OptionalUnitTest {
private List<String> list;
@@ -32,7 +39,6 @@ public class Java8OptionalTest {
@Test
public void checkOptional_whenAsExpected_thenCorrect() {
Optional<String> optionalEmpty = Optional.empty();
assertFalse(optionalEmpty.isPresent());
@@ -52,27 +58,19 @@ public class Java8OptionalTest {
assertTrue(listOptNull.isEmpty());
Optional<User> user = Optional.ofNullable(getUser());
String result = user.map(User::getAddress)
.map(Address::getStreet)
.orElse("not specified");
String result = user.map(User::getAddress).map(Address::getStreet).orElse("not specified");
assertEquals(result, "1st Avenue");
Optional<OptionalUser> optionalUser = Optional.ofNullable(getOptionalUser());
String resultOpt = optionalUser.flatMap(OptionalUser::getAddress)
.flatMap(OptionalAddress::getStreet)
.orElse("not specified");
String resultOpt = optionalUser.flatMap(OptionalUser::getAddress).flatMap(OptionalAddress::getStreet).orElse("not specified");
assertEquals(resultOpt, "1st Avenue");
Optional<User> userNull = Optional.ofNullable(getUserNull());
String resultNull = userNull.map(User::getAddress)
.map(Address::getStreet)
.orElse("not specified");
String resultNull = userNull.map(User::getAddress).map(Address::getStreet).orElse("not specified");
assertEquals(resultNull, "not specified");
Optional<OptionalUser> optionalUserNull = Optional.ofNullable(getOptionalUserNull());
String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress)
.flatMap(OptionalAddress::getStreet)
.orElse("not specified");
String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress).flatMap(OptionalAddress::getStreet).orElse("not specified");
assertEquals(resultOptNull, "not specified");
}
core-java/src/test/java/com/baeldung/java8/Java8StreamApiTest.java → core-java/src/test/java/com/baeldung/java8/Java8StreamApiUnitTest.java
+2 -2
View File
@@ -17,11 +17,11 @@ import java.util.stream.*;
import static org.junit.Assert.*;
public class Java8StreamApiTest {
public class Java8StreamApiUnitTest {
private long counter;
private static Logger log = LoggerFactory.getLogger(Java8StreamApiTest.class);
private static Logger log = LoggerFactory.getLogger(Java8StreamApiUnitTest.class);
private List<Product> productList;
core-java/src/test/java/com/baeldung/java8/Java8StreamsTest.java → core-java/src/test/java/com/baeldung/java8/Java8StreamsUnitTest.java
+1 -1
View File
@@ -14,7 +14,7 @@ import java.util.stream.Stream;
import static org.junit.Assert.*;
public class Java8StreamsTest {
public class Java8StreamsUnitTest {
private List<String> list;
core-java/src/test/java/com/baeldung/java8/JavaFolderSizeTest.java → core-java/src/test/java/com/baeldung/java8/JavaFolderSizeUnitTest.java
+21 -29
View File
@@ -1,43 +1,43 @@
package com.baeldung.java8;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import java.io.File;
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
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 {
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Test;
public class JavaFolderSizeUnitTest {
private final long EXPECTED_SIZE = 24;
private String path;
@Before
public void init() {
final String separator = File.separator;
path = String.format("src%stest%sresources", separator, separator);
path = String.format("src%stest%sresources%stestFolder", separator, 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);
assertEquals(EXPECTED_SIZE, size);
}
@Test
public void whenGetFolderSizeUsingJava7_thenCorrect() throws IOException {
final long expectedSize = 136;
final AtomicLong size = new AtomicLong(0);
final Path folder = Paths.get(path);
@@ -49,41 +49,33 @@ public class JavaFolderSizeTest {
}
});
assertEquals(expectedSize, size.longValue());
assertEquals(EXPECTED_SIZE, 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);
assertEquals(EXPECTED_SIZE, 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);
assertEquals(EXPECTED_SIZE, size);
}
@Test
public void whenGetFolderSizeUsingGuava_thenCorrect() {
final long expectedSize = 136;
final File folder = new File(path);
final Iterable<File> files = com.google.common.io.Files.fileTreeTraverser().breadthFirstTraversal(folder);
final long size = StreamSupport.stream(files.spliterator(), false)
.filter(File::isFile)
.mapToLong(File::length).sum();
final long size = StreamSupport.stream(files.spliterator(), false).filter(File::isFile).mapToLong(File::length).sum();
assertEquals(expectedSize, size);
assertEquals(EXPECTED_SIZE, size);
}
@Test
@@ -91,19 +83,19 @@ public class JavaFolderSizeTest {
final File folder = new File(path);
final long size = getFolderSize(folder);
final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"};
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);
assertEquals(EXPECTED_SIZE + " B", readableSize);
}
private long getFolderSize(final File folder) {
long length = 0;
final File[] files = folder.listFiles();
for (File file : files) {
for (final File file : files) {
if (file.isFile()) {
length += file.length();
} else {

Some files were not shown because too many files have changed in this diff Show More