Merge remote-tracking branch 'Baeldung/master' into active_mq

# Conflicts: # .gitignore # LICENSE # README.md # core-java-modules/README.md # core-java-modules/core-java-11/README.md # core-java-modules/core-java-11/pom.xml # core-java-modules/core-java-8/README.md # core-java-modules/core-java-8/pom.xml # core-java-modules/core-java-8/src/main/resources/logback.xml # core-java-modules/core-java-annotations/README.md # core-java-modules/core-java-annotations/pom.xml # core-java-modules/core-java-collections-2/README.md # core-java-modules/core-java-collections-2/pom.xml # core-java-modules/core-java-collections-3/README.md # core-java-modules/core-java-collections-3/pom.xml # core-java-modules/core-java-collections-conversions-2/README.md # core-java-modules/core-java-collections-conversions-2/pom.xml # core-java-modules/core-java-collections-conversions/README.md # core-java-modules/core-java-collections-conversions/pom.xml # core-java-modules/core-java-collections-list/README.md # core-java-modules/core-java-collections-list/pom.xml # core-java-modules/core-java-collections/pom.xml # core-java-modules/core-java-datetime-conversion/README.md # core-java-modules/core-java-datetime-conversion/pom.xml # core-java-modules/core-java-datetime-conversion/src/test/java/com/baeldung/datetime/ConvertInstantToTimestampUnitTest.java # core-java-modules/core-java-io-2/pom.xml # core-java-modules/core-java-io/README.md # core-java-modules/core-java-io/pom.xml # core-java-modules/core-java-io/src/test/resources/fileTest.txt # core-java-modules/core-java-io/src/test/resources/sampleTextFile.txt # core-java-modules/core-java-lambdas/README.md # core-java-modules/core-java-lambdas/pom.xml # core-java-modules/core-java-serialization/pom.xml # core-java-modules/core-java-streams/README.md # core-java-modules/core-java-streams/pom.xml # core-java-modules/core-java-strings/README.md # core-java-modules/core-java-strings/pom.xml # core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt # core-java-modules/core-java-uuid/README.md # core-java-modules/core-java-uuid/pom.xml # core-java-modules/pom.xml # image-processing/README.md # image-processing/pom.xml # image-processing/src/main/java/com/baeldung/imageprocessing/addingtext/AddText.java # image-processing/src/main/java/com/baeldung/imageprocessing/opencv/CameraStream.java # jackson-modules/jackson-annotations/README.md # jackson-modules/jackson-annotations/pom.xml # jackson-modules/jackson-conversions-2/README.md # jackson-modules/jackson-conversions-2/pom.xml # jackson-modules/jackson-conversions/README.md # jackson-modules/jackson-conversions/pom.xml # jackson-modules/jackson-custom-conversions/README.md # jackson-modules/jackson-custom-conversions/pom.xml # jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/defaultserializercustomserializer/CallingDefaultSerializerUnitTest.java # jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/deserialization/CustomDeserializationUnitTest.java # jackson-modules/jackson-exceptions/README.md # jackson-modules/jackson-exceptions/pom.xml # jackson-modules/jackson-exceptions/src/test/java/com/baeldung/exceptions/JacksonExceptionsUnitTest.java # jackson-modules/jackson-exceptions/src/test/java/com/baeldung/mappingexception/JacksonMappingExceptionUnitTest.java # jackson-modules/pom.xml # parent-boot-1/pom.xml # parent-boot-2/pom.xml # parent-boot-3/pom.xml # patterns-modules/design-patterns-architectural/pom.xml # patterns-modules/design-patterns-architectural/src/main/java/com/baeldung/repositoryvsdaopattern/UserDaoImpl.java # patterns-modules/design-patterns-behavioral-2/README.md # patterns-modules/design-patterns-behavioral-2/pom.xml # patterns-modules/design-patterns-creational-2/README.md # patterns-modules/design-patterns-creational-2/pom.xml # patterns-modules/design-patterns-singleton/README.md # patterns-modules/design-patterns-structural/src/main/resources/log4jstructuraldp.properties # patterns-modules/enterprise-patterns/pom.xml # patterns-modules/intercepting-filter/pom.xml # patterns-modules/pom.xml # persistence-modules/activejdbc/pom.xml # persistence-modules/hibernate5/README.md # persistence-modules/hibernate5/pom.xml # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptor.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/entity/User.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/namingstrategy/CustomPhysicalNamingStrategy.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/Customer.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/HashMapConverter.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryIdClass.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryPK.java # persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/IdentifiersIntegrationTest.java # persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/bootstrap/BootstrapAPIIntegrationTest.java # persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/proxy/HibernateProxyUnitTest.java # persistence-modules/hibernate5/src/test/resources/hibernate-interceptors.properties # persistence-modules/hibernate5/src/test/resources/hibernate-lifecycle.properties # persistence-modules/hibernate5/src/test/resources/hibernate-namingstrategy.properties # persistence-modules/hibernate5/src/test/resources/hibernate-persistjson.properties # persistence-modules/hibernate5/src/test/resources/hibernate.properties # persistence-modules/pom.xml # persistence-modules/spring-data-jpa-crud/pom.xml # persistence-modules/spring-data-jpa-crud/src/main/java/com/baeldung/repository/FruitRepository.java # persistence-modules/spring-data-jpa-repo-2/README.md # persistence-modules/spring-data-jpa-repo-2/pom.xml # persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/model/User.java # persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/repository/CustomUserRepositoryImpl.java # persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/saveperformance/Book.java # persistence-modules/spring-data-jpa-repo-2/src/main/resources/application.properties # persistence-modules/spring-data-mongodb-reactive/pom.xml # persistence-modules/spring-data-redis/README.md # persistence-modules/spring-data-redis/pom.xml # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/config/RedisConfig.java # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/config/RedisConfig.java # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/model/Student.java # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessageSubscriber.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisKeyCommandsManualTest.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateListOpsManualTest.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateValueOpsManualTest.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/repo/StudentRepositoryManualTest.java # pom.xml # testing-modules/assertion-libraries/README.md # testing-modules/assertion-libraries/pom.xml # testing-modules/junit-5-basics/README.md # testing-modules/junit-5-basics/pom.xml # testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Helper.java # testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Main.java # testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Helper.java # testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Main.java # testing-modules/mockito-2/src/test/java/com/baeldung/nullmatcher/MainUnitTest.java # testing-modules/mockito-2/src/test/java/com/baeldung/wantedbutnotinvocked/MainUnitTest.java # testing-modules/pom.xml # testing-modules/spring-mockito/pom.xml # web-modules/dropwizard/pom.xml # web-modules/jakarta-ee/README.md # web-modules/jakarta-ee/pom.xml # web-modules/jakarta-ee/src/test/java/com/baeldung/eclipse/krazo/UserControllerUnitTest.java # web-modules/java-lite/pom.xml # web-modules/javax-servlets-2/README.md # web-modules/javax-servlets-2/pom.xml # web-modules/javax-servlets/pom.xml # web-modules/jee-7/pom.xml # web-modules/jooby/pom.xml # web-modules/ninja/pom.xml # web-modules/pom.xml # web-modules/ratpack/pom.xml # web-modules/resteasy/pom.xml # web-modules/restx/pom.xml # web-modules/spark-java/pom.xml # web-modules/vraptor/pom.xml # xml/README.md # xml/pom.xml # xml/src/main/resources/customer-binding.xml # xml/src/main/resources/sax/baeldung.xml # xml/src/test/resources/example_default_parser.xml # xml/src/test/resources/example_dom4j.xml # xml/src/test/resources/example_jaxb.xml # xml/src/test/resources/example_jaxen.xml # xml/src/test/resources/example_jdom.xml # xml/src/test/resources/example_stax.xml # xml/src/test/resources/sax/baeldung.xml # xml/src/test/resources/xml/websites.xml # xml/src/test/resources/xml/xee_attribute.xml
2024-04-30 12:23:19 -04:00
parent c18eb6d2ed 8cabe509a5
commit a51b7b55d9
27985 changed files with 1584039 additions and 0 deletions
@@ -0,0 +1,23 @@
+package com.baeldung.extension;
+
+import com.google.common.io.Files;
+import org.apache.commons.io.FilenameUtils;
+
+import java.util.Optional;
+
+public class Extension {
+    //Instead of file name we can also specify full path of a file eg. /baeldung/com/demo/abc.java
+    public String getExtensionByApacheCommonLib(String filename) {
+        return FilenameUtils.getExtension(filename);
+    }
+
+    public Optional<String> getExtensionByStringHandling(String filename) {
+        return Optional.ofNullable(filename)
+                       .filter(f -> f.contains("."))
+                      .map(f -> f.substring(filename.lastIndexOf(".") + 1));
+    }
+
+    public String getExtensionByGuava(String filename) {
+        return Files.getFileExtension(filename);
+    }
+}
@@ -0,0 +1,24 @@
+package com.baeldung.fileparser;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class BufferedReaderExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+
+        ArrayList<String> result = new ArrayList<>();
+
+        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
+
+            while (br.ready()) {
+                result.add(br.readLine());
+            }
+            return result;
+        }
+
+    }
+
+}
@@ -0,0 +1,31 @@
+package com.baeldung.fileparser;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class FileReaderExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+
+        ArrayList<String> result = new ArrayList<>();
+
+        try (FileReader f = new FileReader(filename)) {
+            StringBuffer sb = new StringBuffer();
+            while (f.ready()) {
+                char c = (char) f.read();
+                if (c == '\n') {
+                    result.add(sb.toString());
+                    sb = new StringBuffer();
+                } else {
+                    sb.append(c);
+                }
+            }
+            if (sb.length() > 0) {
+                result.add(sb.toString());
+            }
+        }
+        
+        return result;
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.fileparser;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class FilesReadLinesExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+        
+        List<String> result = Files.readAllLines(Paths.get(filename));
+        
+        return (ArrayList<String>) result;
+    }
+
+}
@@ -0,0 +1,24 @@
+package com.baeldung.fileparser;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class ScannerIntExample {
+
+    protected static ArrayList<Integer> generateArrayListFromFile(String filename) throws IOException {
+        
+        ArrayList<Integer> result = new ArrayList<>();
+
+        try (Scanner s = new Scanner(new FileReader(filename))) {
+
+            while (s.hasNext()) {
+                result.add(s.nextInt());
+            }
+            return result;
+        }
+
+    }
+
+}
@@ -0,0 +1,24 @@
+package com.baeldung.fileparser;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class ScannerStringExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+        
+        ArrayList<String> result = new ArrayList<>();
+
+        try (Scanner s = new Scanner(new FileReader(filename))) {
+
+            while (s.hasNext()) {
+                result.add(s.nextLine());
+            }
+            return result;
+        }
+
+    }
+
+}
@@ -0,0 +1,42 @@
+package com.baeldung.filesystem.jndi;
+
+import java.io.File;
+import java.util.Hashtable;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+
+public class LookupFSJNDI {
+    private InitialContext ctx = null;
+
+    public LookupFSJNDI() throws NamingException {
+        super();
+        init();
+    }
+
+    private void init() throws NamingException {
+        Hashtable<String, String> env = new Hashtable<String, String>();
+
+        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
+        // URI to namespace (actual directory)
+        env.put(Context.PROVIDER_URL, "file:./src/test/resources");
+
+        ctx = new InitialContext(env);
+    }
+
+    public InitialContext getCtx() {
+        return ctx;
+    }
+
+    public File getFile(String fileName) {
+        File file;
+        try {
+            file = (File) getCtx().lookup(fileName);
+        } catch (NamingException e) {
+            file = null;
+        }
+        return file;
+    }
+
+}
@@ -0,0 +1,42 @@
+package com.baeldung.resource;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.stream.Collectors;
+
+public class MyResourceLoader {
+
+    private void loadFileWithReader() throws IOException {
+
+        try (FileReader fileReader = new FileReader("src/main/resources/input.txt");
+             BufferedReader reader = new BufferedReader(fileReader)) {
+            String contents = reader.lines()
+                .collect(Collectors.joining(System.lineSeparator()));
+            System.out.println(contents);
+        }
+
+    }
+
+    private void loadFileAsResource() throws IOException {
+
+        try (InputStream inputStream = getClass().getResourceAsStream("/input.txt");
+             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
+            String contents = reader.lines()
+                .collect(Collectors.joining(System.lineSeparator()));
+            System.out.println(contents);
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+
+        MyResourceLoader resourceLoader = new MyResourceLoader();
+
+        resourceLoader.loadFileAsResource();
+        resourceLoader.loadFileWithReader();
+
+    }
+
+}
@@ -0,0 +1,28 @@
+package com.baeldung.size;
+
+import java.io.File;
+
+public class FileSizeUtils {
+    public static long getFileSizeInBytes(File file) {
+        if (file.exists()) {
+            return file.length();
+        } else {
+            throw new IllegalArgumentException("File not found.");
+        }
+    }
+
+    public static double getFileSizeInKilobytes(File file) {
+        long bytes = getFileSizeInBytes(file);
+        return (double) bytes / 1024;
+    }
+
+    public static double getFileSizeInMegabytes(File file) {
+        double kilobytes = getFileSizeInKilobytes(file);
+        return kilobytes / 1024;
+    }
+
+    public static double getFileSizeInGigabytes(File file) {
+        double megabytes = getFileSizeInMegabytes(file);
+        return megabytes / 1024;
+    }
+}
@@ -0,0 +1,67 @@
+package com.baeldung.sizebenchmark;
+
+import org.apache.commons.io.FileUtils;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.channels.FileChannel;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.SingleShotTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 3, time = 10, timeUnit = TimeUnit.NANOSECONDS)
+@Measurement(iterations = 3, time = 10, timeUnit = TimeUnit.NANOSECONDS)
+public class FileSizeBenchmark {
+    
+    public static void main(String[] args) throws Exception {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+    @Benchmark
+    public void getFileSizeUsingLengthMethod(Blackhole blackhole) throws Exception {
+        File file = new File("src/test/resources/size/sample_file_1.in");
+        blackhole.consume(file.length());
+    }
+
+    @Benchmark
+    public void getFileSizeUsingFileInputStream(Blackhole blackhole) throws Exception {
+        try (FileInputStream fis = new FileInputStream("src/test/resources/size/sample_file_1.in")) {
+            long result = fis.getChannel().size();
+            blackhole.consume(result);
+        }
+
+    }
+
+    @Benchmark
+    public void getFileSizeUsingInputStreamAndUrl(Blackhole blackhole) throws Exception {
+        File me = new File("src/test/resources/size/sample_file_1.in");
+        URL url = me.toURI().toURL();
+
+        try (InputStream stream = url.openStream()) {
+            blackhole.consume(stream.available());
+        }
+    }
+
+    @Benchmark
+    public void getFileSizeUsingApacheCommon(Blackhole blackhole) {
+        File imageFile = new File("src/test/resources/size/sample_file_1.in");
+        long size = FileUtils.sizeOf(imageFile);
+        blackhole.consume(size);
+    }
+
+    @Benchmark
+    public void getFileSizeUsingFileChannel(Blackhole blackhole) throws IOException {
+        Path imageFilePath = Paths.get("src/test/resources/size/sample_file_1.in");
+        try (FileChannel imageFileChannel = FileChannel.open(imageFilePath)) {
+            long imageFileSize = imageFileChannel.size();
+            blackhole.consume(imageFileSize);
+        }
+    }
+}
@@ -0,0 +1,57 @@
+package com.baeldung.unzip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class UnzipFile {
+    public static void main(final String[] args) throws IOException {
+        final String fileZip = "src/main/resources/unzipTest/compressed.zip";
+        final File destDir = new File("src/main/resources/unzipTest");
+        final byte[] buffer = new byte[1024];
+        final ZipInputStream zis = new ZipInputStream(new FileInputStream(fileZip));
+        ZipEntry zipEntry = zis.getNextEntry();
+        while (zipEntry != null) {
+            final File newFile = newFile(destDir, zipEntry);
+            if (zipEntry.isDirectory()) {
+                if (!newFile.isDirectory() && !newFile.mkdirs()) {
+                    throw new IOException("Failed to create directory " + newFile);
+                }
+            } else {
+                File parent = newFile.getParentFile();
+                if (!parent.isDirectory() && !parent.mkdirs()) {
+                    throw new IOException("Failed to create directory " + parent);
+                }
+
+                final FileOutputStream fos = new FileOutputStream(newFile);
+                int len;
+                while ((len = zis.read(buffer)) > 0) {
+                    fos.write(buffer, 0, len);
+                }
+                fos.close();
+            }
+            zipEntry = zis.getNextEntry();
+        }
+        zis.closeEntry();
+        zis.close();
+    }
+
+    /**
+     * @see https://snyk.io/research/zip-slip-vulnerability
+     */
+    public static File newFile(File destinationDir, ZipEntry zipEntry) throws IOException {
+        File destFile = new File(destinationDir, zipEntry.getName());
+
+        String destDirPath = destinationDir.getCanonicalPath();
+        String destFilePath = destFile.getCanonicalPath();
+
+        if (!destFilePath.startsWith(destDirPath + File.separator)) {
+            throw new IOException("Entry is outside of the target dir: " + zipEntry.getName());
+        }
+
+        return destFile;
+    }
+}
@@ -0,0 +1,29 @@
+package com.baeldung.zip;
+
+import java.io.*;
+import java.net.URI;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import static java.util.stream.Collectors.toList;
+
+public class ZipAppendFile {
+    public static void main(final String[] args) throws IOException {
+        ZipMultipleFiles.main(args);
+        String file3 = ZipAppendFile.class.getClassLoader().getResource("zipTest/file3.txt").getPath();
+        Map<String, String> env = new HashMap<>();
+        env.put("create", "true");
+        Path path = Paths.get(Paths.get(file3).getParent() + "/compressed.zip");
+        URI uri = URI.create("jar:" + path.toUri());
+        try (FileSystem fs = FileSystems.newFileSystem(uri, env)) {
+            Path nf = fs.getPath("newFile3.txt");
+            Files.write(nf, Files.readAllBytes(Paths.get(file3)), StandardOpenOption.CREATE);
+        }
+    }
+}
@@ -0,0 +1,50 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipDirectory {
+    public static void main(final String[] args) throws IOException {
+        final String sourceFile = "src/main/resources/zipTest";
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/dirCompressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        final File fileToZip = new File(sourceFile);
+
+        zipFile(fileToZip, fileToZip.getName(), zipOut);
+        zipOut.close();
+        fos.close();
+    }
+
+    private static void zipFile(final File fileToZip, final String fileName, final ZipOutputStream zipOut) throws IOException {
+        if (fileToZip.isHidden()) {
+            return;
+        }
+        if (fileToZip.isDirectory()) {
+            if (fileName.endsWith("/")) {
+                zipOut.putNextEntry(new ZipEntry(fileName));
+                zipOut.closeEntry();
+            } else {
+                zipOut.putNextEntry(new ZipEntry(fileName + "/"));
+                zipOut.closeEntry();
+            }
+            final File[] children = fileToZip.listFiles();
+            for (final File childFile : children) {
+                zipFile(childFile, fileName + "/" + childFile.getName(), zipOut);
+            }
+            return;
+        }
+        final FileInputStream fis = new FileInputStream(fileToZip);
+        final ZipEntry zipEntry = new ZipEntry(fileName);
+        zipOut.putNextEntry(zipEntry);
+        final byte[] bytes = new byte[1024];
+        int length;
+        while ((length = fis.read(bytes)) >= 0) {
+            zipOut.write(bytes, 0, length);
+        }
+        fis.close();
+    }
+}
@@ -0,0 +1,28 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipFile {
+    public static void main(final String[] args) throws IOException {
+        final String sourceFile = "src/main/resources/zipTest/test1.txt";
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/compressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        final File fileToZip = new File(sourceFile);
+        final FileInputStream fis = new FileInputStream(fileToZip);
+        final ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
+        zipOut.putNextEntry(zipEntry);
+        final byte[] bytes = new byte[1024];
+        int length;
+        while ((length = fis.read(bytes)) >= 0) {
+            zipOut.write(bytes, 0, length);
+        }
+        zipOut.close();
+        fis.close();
+        fos.close();
+    }
+}
@@ -0,0 +1,37 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipMultipleFiles {
+    public static void main(final String[] args) throws IOException {
+        String file1 = ZipAppendFile.class.getClassLoader().getResource("zipTest/test1.txt").getPath();
+        String file2 = ZipAppendFile.class.getClassLoader().getResource("zipTest/test2.txt").getPath();
+        final List<String> srcFiles = Arrays.asList(file1, file2);
+        final FileOutputStream fos =
+                new FileOutputStream(Paths.get(file1).getParent().toAbsolutePath() + "/compressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        for (final String srcFile : srcFiles) {
+            final File fileToZip = new File(srcFile);
+            final FileInputStream fis = new FileInputStream(fileToZip);
+            final ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
+            zipOut.putNextEntry(zipEntry);
+
+            final byte[] bytes = new byte[1024];
+            int length;
+            while ((length = fis.read(bytes)) >= 0) {
+                zipOut.write(bytes, 0, length);
+            }
+            fis.close();
+        }
+        zipOut.close();
+        fos.close();
+    }
+}
@@ -0,0 +1,118 @@
+package com.baeldung.close;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.*;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.input.AutoCloseInputStream;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@RunWith(MockitoJUnitRunner.class)
+public class StreamCloseUnitTest {
+
+    private static final Logger log = LoggerFactory.getLogger(StreamCloseUnitTest.class);
+
+    @Mock
+    private OutputStream wrappedOutputStream;
+
+    @Mock
+    private InputStream wrappedInputStream;
+
+    @Test
+    public void whenStreamClosedByFinally_thenIOStreamsCloseCalled() throws IOException {
+
+        InputStream inputStream = null;
+        OutputStream outputStream = null;
+
+        try {
+            inputStream = new BufferedInputStream(wrappedInputStream);
+            outputStream = new BufferedOutputStream(wrappedOutputStream);
+        }
+        finally {
+            try {
+                if (inputStream != null)
+                    inputStream.close();
+            }
+            catch (IOException ioe1) {
+                log.error("Cannot close InputStream");
+            }
+            try {
+                if (outputStream != null)
+                    outputStream.close();
+            }
+            catch (IOException ioe2) {
+                log.error("Cannot close OutputStream");
+            }
+        }
+
+        verify(wrappedInputStream).close();
+        verify(wrappedOutputStream).close();
+    }
+
+    @Test
+    public void whenStreamClosedByCloseQuietly_thenIOStreamsCloseCalled() throws IOException {
+
+        InputStream inputStream = null;
+        OutputStream outputStream = null;
+
+        try {
+            inputStream = new BufferedInputStream(wrappedInputStream);
+            outputStream = new BufferedOutputStream(wrappedOutputStream);
+        }
+        finally {
+            IOUtils.closeQuietly(inputStream);
+            IOUtils.closeQuietly(outputStream);
+        }
+
+        verify(wrappedInputStream).close();
+        verify(wrappedOutputStream).close();
+    }
+
+    @Test
+    public void whenFinishReadOnAutoCloseInputStream_thenInputStreamsCloseCalled() throws IOException {
+
+        // Mimic no more data in the InputStream
+        when(wrappedInputStream.read(any(byte[].class))).thenReturn(-1);
+
+        InputStream inputStream = AutoCloseInputStream.builder().setInputStream(wrappedInputStream).get();
+
+        byte[] buffer = new byte[256];
+        while (inputStream.read(buffer) != -1) {
+        }
+
+        verify(wrappedInputStream).close();
+    }
+
+    @Test
+    public void whenStreamClosedByWithResources_thenIOStreamsCloseCalled() throws IOException {
+
+        try (BufferedInputStream inputStream = new BufferedInputStream(wrappedInputStream);
+            BufferedOutputStream outputStream = new BufferedOutputStream(wrappedOutputStream)) {
+        }
+
+        verify(wrappedInputStream).close();
+        verify(wrappedOutputStream).close();
+    }
+
+    @Test
+    public void whenStreamClosedByWithResourcesJava9_thenIOStreamsCloseCalled() throws IOException {
+
+        InputStream inputStream = new BufferedInputStream(wrappedInputStream);
+        OutputStream outputStream = new BufferedOutputStream(wrappedOutputStream);
+
+        try (inputStream; outputStream) {
+        }
+
+        verify(wrappedInputStream).close();
+        verify(wrappedOutputStream).close();
+    }
+
+}
@@ -0,0 +1,31 @@
+package com.baeldung.extension;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Optional;
+
+public class ExtensionUnitTest {
+    private Extension extension = new Extension();
+
+    @Test
+    public void getExtension_whenApacheCommonIO_thenExtensionIsTrue() {
+        String expectedExtension = "txt";
+        String actualExtension = extension.getExtensionByApacheCommonLib("jarvis.txt");
+        Assert.assertEquals(expectedExtension, actualExtension);
+    }
+
+    @Test
+    public void getExtension_whenStringHandle_thenExtensionIsTrue() {
+        String expectedExtension = "java";
+        Optional<String> actualExtension = extension.getExtensionByStringHandling("Demo.java");
+        Assert.assertEquals(expectedExtension, actualExtension.get());
+    }
+
+    @Test
+    public void getExtension_whenGuava_thenExtensionIsTrue() {
+        String expectedExtension = "class";
+        String actualExtension = extension.getExtensionByGuava("baeldung/Demo.class");
+        Assert.assertEquals(expectedExtension, actualExtension);
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.fileparser;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Test;
+
+public class BufferedReaderUnitTest {
+
+    protected static final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+    
+    @Test
+    public void whenParsingExistingTextFile_thenGetArrayList() throws IOException {
+        List<String> lines = BufferedReaderExample.generateArrayListFromFile(TEXT_FILENAME);
+        assertTrue("File does not has 2 lines", lines.size() == 2);
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.fileparser;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Test;
+
+public class FileReaderUnitTest {
+
+    protected static final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+    
+    @Test
+    public void whenParsingExistingTextFile_thenGetArrayList() throws IOException {
+        List<String> lines = FileReaderExample.generateArrayListFromFile(TEXT_FILENAME);
+        assertTrue("File does not has 2 lines", lines.size() == 2);
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.fileparser;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Test;
+
+public class FilesReadAllLinesUnitTest {
+
+    protected static final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+
+    @Test
+    public void whenParsingExistingTextFile_thenGetArrayList() throws IOException {
+        List<String> lines = FilesReadLinesExample.generateArrayListFromFile(TEXT_FILENAME);
+        assertTrue("File does not has 2 lines", lines.size() == 2);
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.fileparser;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Test;
+
+public class ScannerIntUnitTest {
+
+    protected static final String NUMBER_FILENAME = "src/test/resources/sampleNumberFile.txt";
+    
+    @Test
+    public void whenParsingExistingTextFile_thenGetIntArrayList() throws IOException {
+        List<Integer> numbers = ScannerIntExample.generateArrayListFromFile(NUMBER_FILENAME);
+        assertTrue("File does not has 2 lines", numbers.size() == 2);
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.fileparser;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.Test;
+
+public class ScannerStringUnitTest {
+
+    protected static final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+    
+    @Test
+    public void whenParsingExistingTextFile_thenGetArrayList() throws IOException {
+        List<String> lines = ScannerStringExample.generateArrayListFromFile(TEXT_FILENAME);
+        assertTrue("File does not has 2 lines", lines.size() == 2);
+    }
+}
@@ -0,0 +1,41 @@
+package com.baeldung.filesystem.jndi;
+
+import com.baeldung.filesystem.jndi.LookupFSJNDI;
+import org.junit.Test;
+
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import java.io.File;
+
+import static org.junit.Assert.assertNotNull;
+
+public class LookupFSJNDIIntegrationTest {
+    LookupFSJNDI fsjndi;
+    InitialContext ctx = null;
+    final String FILENAME = "test.find";
+
+    public LookupFSJNDIIntegrationTest() {
+        try {
+            fsjndi = new LookupFSJNDI();
+        } catch (NamingException e) {
+            fsjndi = null;
+        }
+    }
+
+    @Test
+    public void whenInitializationLookupFSJNDIIsNotNull_thenSuccess() {
+        assertNotNull("Class LookupFSJNDI has instance", fsjndi);
+    }
+
+    @Test
+    public void givenLookupFSJNDI_whengetInitialContextIsNotNull_thenSuccess() {
+        ctx = fsjndi.getCtx();
+        assertNotNull("Context exists", ctx);
+    }
+
+    @Test
+    public void givenInitialContext_whenLokupFileExists_thenSuccess() {
+        File file = fsjndi.getFile(FILENAME);
+        assertNotNull("File exists", file);
+    }
+}
@@ -0,0 +1,131 @@
+package com.baeldung.mimetype;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.FileNameMap;
+import java.net.MalformedURLException;
+import java.net.URLConnection;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import jakarta.activation.MimetypesFileTypeMap;
+
+import org.apache.tika.Tika;
+import org.junit.Test;
+
+import net.sf.jmimemagic.Magic;
+import net.sf.jmimemagic.MagicException;
+import net.sf.jmimemagic.MagicMatch;
+import net.sf.jmimemagic.MagicMatchNotFoundException;
+import net.sf.jmimemagic.MagicParseException;
+
+/**
+ * Test class demonstrating various strategies to resolve MIME type of a file.
+ * @author tritty
+ *
+ */
+public class MimeTypeUnitTest {
+    /**
+     * Expected Ouput.
+     */
+    public static final String PNG_EXT = "image/png";
+
+    /**
+     * The location of the file.
+     */
+    public static final String FILE_LOC = "src/test/resources/product.png";
+
+    /**
+     * Test method, demonstrating usage in Java 7.
+     * 
+     * @throws IOException
+     */
+    @Test
+    public void whenUsingJava7_thenSuccess() throws IOException {
+        final Path path = new File(FILE_LOC).toPath();
+        final String mimeType = Files.probeContentType(path);
+        assertEquals(mimeType, PNG_EXT);
+    }
+
+    /**
+     * Test method demonstrating the usage of URLConnection to resolve MIME type.
+     * 
+     * @throws MalformedURLException
+     * @throws IOException
+     */
+    @Test
+    public void whenUsingGetContentType_thenSuccess() throws MalformedURLException, IOException {
+        final File file = new File(FILE_LOC);
+        final URLConnection connection = file.toURL()
+            .openConnection();
+        final String mimeType = connection.getContentType();
+        assertEquals(mimeType, PNG_EXT);
+    }
+
+    /**
+     * Test method demonstrating the usage of URLConnection to resolve MIME type.
+     * 
+     */
+    @Test
+    public void whenUsingGuessContentTypeFromName_thenSuccess() {
+        final File file = new File(FILE_LOC);
+        final String mimeType = URLConnection.guessContentTypeFromName(file.getName());
+        assertEquals(mimeType, PNG_EXT);
+    }
+
+    /**
+     * Test method demonstrating the usage of FileNameMap from URLConnection
+     * to resolve MIME type of a file.
+     * 
+     */
+    @Test
+    public void whenUsingGetFileNameMap_thenSuccess() {
+        final File file = new File(FILE_LOC);
+        final FileNameMap fileNameMap = URLConnection.getFileNameMap();
+        final String mimeType = fileNameMap.getContentTypeFor(file.getName());
+        assertEquals(mimeType, PNG_EXT);
+    }
+
+    /**
+     * Test method demonstrating the usage of MimeTypesFileTypeMap for resolution of 
+     * MIME type.
+     * 
+     */
+    @Test
+    public void whenUsingMimeTypesFileTypeMap_thenSuccess() {
+        final File file = new File(FILE_LOC);
+        final MimetypesFileTypeMap fileTypeMap = new MimetypesFileTypeMap();
+        final String mimeType = fileTypeMap.getContentType(file.getName());
+        assertEquals(mimeType, PNG_EXT);
+    }
+
+    /**
+     * Test method demonstrating usage of jMimeMagic.
+     * 
+     * @throws MagicParseException
+     * @throws MagicMatchNotFoundException
+     * @throws MagicException
+     */
+    @Test
+    public void whenUsingJmimeMagic_thenSuccess() throws MagicParseException, MagicMatchNotFoundException, MagicException {
+        final File file = new File(FILE_LOC);
+        final Magic magic = new Magic();
+        final MagicMatch match = magic.getMagicMatch(file, false);
+        assertEquals(match.getMimeType(), PNG_EXT);
+    }
+
+    /**
+     * Test method demonstrating usage of Apache Tika.
+     * 
+     * @throws IOException
+     */
+    @Test
+    public void whenUsingTika_thenSuccess() throws IOException {
+        final File file = new File(FILE_LOC);
+        final Tika tika = new Tika();
+        final String mimeType = tika.detect(file);
+        assertEquals(mimeType, PNG_EXT);
+    }
+}
@@ -0,0 +1,270 @@
+package com.baeldung.readfile;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matchers;
+import org.junit.Test;
+
+import java.io.*;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class JavaReadFromFileUnitTest {
+
+    @Test
+    public void whenReadWithBufferedReader_thenCorrect() throws IOException {
+        final String expected_value = "Hello, world!";
+
+        final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/fileTest.txt"));
+        final String currentLine = reader.readLine();
+        reader.close();
+
+        assertEquals(expected_value, currentLine);
+    }
+
+    @Test
+    public void givenFileName_whenUsingClassloader_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        File file = new File(classLoader.getResource("fileTest.txt").getFile());
+        InputStream inputStream = new FileInputStream(file);
+        String data = readFromInputStream(inputStream);
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFileNameAsAbsolutePath_whenUsingClasspath_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        Class clazz = JavaReadFromFileUnitTest.class;
+        InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt");
+        String data = readFromInputStream(inputStream);
+
+        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);
+
+        assertThat(data.trim(), CoreMatchers.containsString(expectedData));
+    }
+
+    @Test
+    public void givenURLName_whenUsingURL_thenFileData() throws IOException {
+        String expectedData = "Example Domain";
+
+        URL urlObject = new URL("http://www.example.com/");
+
+        URLConnection urlConnection = urlObject.openConnection();
+
+        InputStream inputStream = urlConnection.getInputStream();
+        String data = readFromInputStream(inputStream);
+
+        assertThat(data.trim(), CoreMatchers.containsString(expectedData));
+    }
+
+    @Test
+    public void givenFileName_whenUsingFileUtils_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        File file = new File(classLoader.getResource("fileTest.txt").getFile());
+        String data = FileUtils.readFileToString(file, "UTF-8");
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFilePath_whenUsingFilesReadAllBytes_thenFileData() throws IOException, URISyntaxException {
+        String expectedData = "Hello, world!";
+
+        Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI());
+
+        byte[] fileBytes = Files.readAllBytes(path);
+        String data = new String(fileBytes);
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFilePath_whenUsingFilesLines_thenFileData() throws IOException, URISyntaxException {
+        String expectedData = "Hello, world!";
+
+        Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI());
+
+        Stream<String> lines = Files.lines(path);
+        String data = lines.collect(Collectors.joining("\n"));
+        lines.close();
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFileName_whenUsingIOUtils_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        FileInputStream fis = new FileInputStream("src/test/resources/fileTest.txt");
+        String data = IOUtils.toString(fis, "UTF-8");
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void whenReadWithScanner_thenCorrect() throws IOException {
+        final Scanner scanner = new Scanner(new File("src/test/resources/fileTest.txt"));
+        scanner.useDelimiter(" ");
+
+        assertTrue(scanner.hasNext());
+        assertEquals("Hello,", scanner.next());
+        assertEquals("world!", scanner.next());
+
+        scanner.close();
+    }
+
+    @Test
+    public void whenReadWithScannerTwoDelimiters_thenCorrect() throws IOException {
+        final Scanner scanner = new Scanner(new File("src/test/resources/fileTest.txt"));
+        scanner.useDelimiter("\\s|,");
+
+        assertTrue(scanner.hasNext());
+        assertEquals("Hello", scanner.next());
+        assertEquals("", scanner.next());
+        assertEquals("world!", scanner.next());
+
+        scanner.close();
+    }
+
+    @Test
+    public void whenReadWithStreamTokenizer_thenCorrectTokens() throws IOException {
+        final FileReader reader = new FileReader("src/test/resources/fileTestTokenizer.txt");
+        final StreamTokenizer tokenizer = new StreamTokenizer(reader);
+
+        tokenizer.nextToken();
+        assertEquals(StreamTokenizer.TT_WORD, tokenizer.ttype);
+        assertEquals("Hello", tokenizer.sval);
+        tokenizer.nextToken();
+        assertEquals(StreamTokenizer.TT_NUMBER, tokenizer.ttype);
+        assertEquals(1, tokenizer.nval, 0.0000001);
+
+        tokenizer.nextToken();
+        assertEquals(StreamTokenizer.TT_EOF, tokenizer.ttype);
+        reader.close();
+    }
+
+    @Test
+    public void whenReadWithDataInputStream_thenCorrect() throws IOException {
+        String expectedValue = "Hello, world!";
+        String file ="src/test/resources/fileTest.txt";
+
+        String result = null;
+
+        DataInputStream reader = new DataInputStream(new FileInputStream(file));
+        int nBytesToRead = reader.available();
+        if(nBytesToRead > 0) {
+            byte[] bytes = new byte[nBytesToRead];
+            reader.read(bytes);
+            result = new String(bytes);
+        }
+
+        assertEquals(expectedValue, result);
+    }
+
+    @Test
+    public void whenReadUTFEncodedFile_thenCorrect() throws IOException {
+        final String expected_value = "青空";
+        final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/fileTestUtf8.txt"), "UTF-8"));
+        final String currentLine = reader.readLine();
+        reader.close();
+
+        assertEquals(expected_value, currentLine);
+    }
+
+    @Test
+    public void whenReadFileContentsIntoString_thenCorrect() throws IOException {
+        final String expected_value = "Hello, world!\n";
+        final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/fileTest.txt"));
+        final StringBuilder builder = new StringBuilder();
+        String currentLine = reader.readLine();
+        while (currentLine != null) {
+            builder.append(currentLine);
+            builder.append("\n");
+            currentLine = reader.readLine();
+        }
+
+        reader.close();
+
+        assertEquals(expected_value, builder.toString());
+    }
+
+    @Test
+    public void whenReadWithFileChannel_thenCorrect() throws IOException {
+        final String expected_value = "Hello, world!";
+        final RandomAccessFile reader = new RandomAccessFile("src/test/resources/fileTest.txt", "r");
+        final FileChannel channel = reader.getChannel();
+
+        int bufferSize = 1024;
+        if (bufferSize > channel.size()) {
+            bufferSize = (int) channel.size();
+        }
+        final ByteBuffer buff = ByteBuffer.allocate(bufferSize);
+        channel.read(buff);
+        buff.flip();
+        assertEquals(expected_value, new String(buff.array()));
+        channel.close();
+        reader.close();
+    }
+
+    @Test
+    public void whenReadSmallFileJava7_thenCorrect() throws IOException {
+        final String expected_value = "Hello, world!";
+        final Path path = Paths.get("src/test/resources/fileTest.txt");
+
+        final String read = Files.readAllLines(path, Charset.defaultCharset()).get(0);
+        assertEquals(expected_value, read);
+    }
+
+    @Test
+    public void whenReadLargeFileJava7_thenCorrect() throws IOException {
+        final String expected_value = "Hello, world!";
+
+        final Path path = Paths.get("src/test/resources/fileTest.txt");
+        final BufferedReader reader = Files.newBufferedReader(path, Charset.defaultCharset());
+        final String line = reader.readLine();
+        assertEquals(expected_value, line);
+    }
+
+    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();
+    }
+
+}
@@ -0,0 +1,64 @@
+package com.baeldung.rename;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileSystemException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class RenameFileUnitTest {
+
+    private final String FILE_TO_MOVE = "src/test/resources/originalFileToMove.txt";
+    private final String TARGET_FILE = "src/test/resources/targetFileToMove.txt";
+
+    @BeforeEach
+    public void createFileToMove() throws IOException {
+        File fileToMove = new File(FILE_TO_MOVE);
+        fileToMove.createNewFile();
+    }
+
+    @AfterEach
+    public void cleanUpFiles() {
+        File targetFile = new File(TARGET_FILE);
+        targetFile.delete();
+    }
+
+    @Test
+    public void givenUsingNio_whenMovingFile_thenCorrect() throws IOException {
+        Path fileToMovePath = Paths.get(FILE_TO_MOVE);
+        Path targetPath = Paths.get(TARGET_FILE);
+        Files.move(fileToMovePath, targetPath);
+    }
+
+    @Test
+    public void givenUsingFileClass_whenMovingFile_thenCorrect() throws IOException {
+        File fileToMove = new File(FILE_TO_MOVE);
+        boolean isMoved = fileToMove.renameTo(new File(TARGET_FILE));
+        if (!isMoved) {
+            throw new FileSystemException(TARGET_FILE);
+        }
+    }
+
+    @Test
+    public void givenUsingGuava_whenMovingFile_thenCorrect()
+            throws IOException {
+        File fileToMove = new File(FILE_TO_MOVE);
+        File targetFile = new File(TARGET_FILE);
+
+        com.google.common.io.Files.move(fileToMove, targetFile);
+    }
+
+    @Test
+    public void givenUsingApache_whenMovingFile_thenCorrect() throws IOException {
+        FileUtils.moveFile(
+                FileUtils.getFile(FILE_TO_MOVE),
+                FileUtils.getFile(TARGET_FILE));
+    }
+
+}
@@ -0,0 +1,109 @@
+package com.baeldung.size;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.channels.FileChannel;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class JavaFileSizeUnitTest {
+    private static final long EXPECTED_FILE_SIZE_IN_BYTES = 11;
+    private String filePath;
+
+    @Before
+    public void init() {
+        final String separator = File.separator;
+        filePath = String.join(separator, new String[] { "src", "test", "resources", "size", "sample_file_1.in" });
+    }
+
+    @Test
+    public void whenGetFileSize_thenCorrect() {
+        final File file = new File(filePath);
+
+        final long size = getFileSize(file);
+
+        assertEquals(EXPECTED_FILE_SIZE_IN_BYTES, size);
+    }
+
+    @Test
+    public void whenGetFileSizeUsingNioApi_thenCorrect() throws IOException {
+        final Path path = Paths.get(this.filePath);
+        final FileChannel fileChannel = FileChannel.open(path);
+
+        final long fileSize = fileChannel.size();
+
+        assertEquals(EXPECTED_FILE_SIZE_IN_BYTES, fileSize);
+    }
+
+    @Test
+    public void whenGetFileSizeUsingApacheCommonsIO_thenCorrect() {
+        final File file = new File(filePath);
+
+        final long size = FileUtils.sizeOf(file);
+
+        assertEquals(EXPECTED_FILE_SIZE_IN_BYTES, size);
+    }
+
+    @Test
+    public void whenGetReadableFileSize_thenCorrect() {
+        final File file = new File(filePath);
+
+        final long size = getFileSize(file);
+
+        assertEquals(EXPECTED_FILE_SIZE_IN_BYTES + " bytes", FileUtils.byteCountToDisplaySize(size));
+    }
+
+    private long getFileSize(final File file) {
+        final long length = file.length();
+        return length;
+    }
+
+    @Test
+    public void whenGetFileSizeUsingFileInputStream_thenCorrect() throws IOException {
+
+        try (FileInputStream fis = new FileInputStream(filePath)) {
+            long result = fis.getChannel().size();
+            assertEquals(EXPECTED_FILE_SIZE_IN_BYTES, result);
+        }
+    }
+
+    @Test
+    public void whenGetFileSizeUsingUrlAndInputStream_thenCorrect() throws IOException {
+
+        File file = new File(filePath);
+        URL url = file.toURI().toURL();
+
+        try (InputStream stream = url.openStream()) {
+            assertEquals(EXPECTED_FILE_SIZE_IN_BYTES, stream.available());
+        }
+    }
+
+    @Test
+    public void whenGetFileSizeInDifferentUnits_thenCorrect(){
+        filePath = String.join(File.separator, new String[] { "src", "test", "resources", "size", "sample_file_1.in" });
+        File file = new File(filePath);
+        if (file.exists()) {
+            long expectedBytes = file.length();
+            double expectedKilobytes = (double) expectedBytes / 1024;
+            double expectedMegabytes = expectedKilobytes / 1024;
+            double expectedGigabytes = expectedMegabytes / 1024;
+
+            assertEquals(expectedBytes, FileSizeUtils.getFileSizeInBytes(file));
+            assertEquals(expectedKilobytes, FileSizeUtils.getFileSizeInKilobytes(file), 0.01);
+            assertEquals(expectedMegabytes, FileSizeUtils.getFileSizeInMegabytes(file), 0.01);
+            assertEquals(expectedGigabytes, FileSizeUtils.getFileSizeInGigabytes(file), 0.01);
+        } else {
+            fail("File not found.");
+        }
+    }
+}
@@ -0,0 +1,107 @@
+package com.baeldung.size;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+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 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%ssize", separator, separator, separator);
+    }
+
+    @Test
+    public void whenGetFolderSizeRecursive_thenCorrect() {
+        final File folder = new File(path);
+        final long size = getFolderSize(folder);
+
+        assertEquals(EXPECTED_SIZE, size);
+    }
+
+    @Test
+    public void whenGetFolderSizeUsingJava7_thenCorrect() throws IOException {
+        final AtomicLong size = new AtomicLong(0);
+        final Path folder = Paths.get(path);
+
+        Files.walkFileTree(folder, new SimpleFileVisitor<Path>() {
+            @Override
+            public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+                size.addAndGet(attrs.size());
+                return FileVisitResult.CONTINUE;
+            }
+        });
+
+        assertEquals(EXPECTED_SIZE, size.longValue());
+    }
+
+    @Test
+    public void whenGetFolderSizeUsingJava8_thenCorrect() throws IOException {
+        final Path folder = Paths.get(path);
+        final long size = Files.walk(folder).filter(p -> p.toFile().isFile()).mapToLong(p -> p.toFile().length()).sum();
+
+        assertEquals(EXPECTED_SIZE, size);
+    }
+
+    @Test
+    public void whenGetFolderSizeUsingApacheCommonsIO_thenCorrect() {
+        final File folder = new File(path);
+        final long size = FileUtils.sizeOfDirectory(folder);
+
+        assertEquals(EXPECTED_SIZE, size);
+    }
+
+    @Test
+    public void whenGetFolderSizeUsingGuava_thenCorrect() {
+        final File folder = new File(path);
+
+        final Iterable<File> files = com.google.common.io.Files.fileTraverser().breadthFirst(folder);
+        final long size = StreamSupport.stream(files.spliterator(), false).filter(File::isFile).mapToLong(File::length).sum();
+
+        assertEquals(EXPECTED_SIZE, 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(EXPECTED_SIZE + " B", readableSize);
+    }
+
+    private long getFolderSize(final File folder) {
+        long length = 0;
+        final File[] files = folder.listFiles();
+
+        for (final File file : files) {
+            if (file.isFile()) {
+                length += file.length();
+            } else {
+                length += getFolderSize(file);
+            }
+        }
+        return length;
+    }
+}
@@ -0,0 +1 @@
+Hello 1
@@ -0,0 +1 @@
+青空
@@ -0,0 +1 @@
+Hello world
@@ -0,0 +1 @@
+Hello world !