iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanup work

Browse Source
This commit is contained in:
eugenp 2016-10-25 11:09:51 +03:00
parent a44be73deb
commit 2ab201d639
49 changed files with 489 additions and 653 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
core-java/src/main/java/com/baeldung/datetime/UseDuration.java
View File

@ -5,12 +5,12 @@ import java.time.LocalTime;
import java.time.Period;
public class UseDuration {
public LocalTime modifyDates(LocalTime localTime,Duration duration){
public LocalTime modifyDates(LocalTime localTime, Duration duration) {
return localTime.plus(duration);
}
public Duration getDifferenceBetweenDates(LocalTime localTime1,LocalTime localTime2){
public Duration getDifferenceBetweenDates(LocalTime localTime1, LocalTime localTime2) {
return Duration.between(localTime1, localTime2);
}
}

32
core-java/src/main/java/com/baeldung/datetime/UseLocalDate.java
View File

@ -7,39 +7,39 @@ import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
public class UseLocalDate {
public LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth){
public LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth) {
return LocalDate.of(year, month, dayOfMonth);
}
public LocalDate getLocalDateUsingParseMethod(String representation){
public LocalDate getLocalDateUsingParseMethod(String representation) {
return LocalDate.parse(representation);
}
public LocalDate getLocalDateFromClock(){
public LocalDate getLocalDateFromClock() {
LocalDate localDate = LocalDate.now();
return localDate;
}
public LocalDate getNextDay(LocalDate localDate){
public LocalDate getNextDay(LocalDate localDate) {
return localDate.plusDays(1);
}
public LocalDate getPreviousDay(LocalDate localDate){
public LocalDate getPreviousDay(LocalDate localDate) {
return localDate.minus(1, ChronoUnit.DAYS);
}
public DayOfWeek getDayOfWeek(LocalDate localDate){
public DayOfWeek getDayOfWeek(LocalDate localDate) {
DayOfWeek day = localDate.getDayOfWeek();
return day;
}
public LocalDate getFirstDayOfMonth(){
public LocalDate getFirstDayOfMonth() {
LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
return firstDayOfMonth;
}
public LocalDateTime getStartOfDay(LocalDate localDate){
public LocalDateTime getStartOfDay(LocalDate localDate) {
LocalDateTime startofDay = localDate.atStartOfDay();
return startofDay;
}

4
core-java/src/main/java/com/baeldung/datetime/UseLocalDateTime.java
View File

@ -3,8 +3,8 @@ package com.baeldung.datetime;
import java.time.LocalDateTime;
public class UseLocalDateTime {
public LocalDateTime getLocalDateTimeUsingParseMethod(String representation){
public LocalDateTime getLocalDateTimeUsingParseMethod(String representation) {
return LocalDateTime.parse(representation);
}

26
core-java/src/main/java/com/baeldung/datetime/UseLocalTime.java
View File

@ -4,32 +4,32 @@ import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
public class UseLocalTime {
public LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds){
public LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds) {
LocalTime localTime = LocalTime.of(hour, min, seconds);
return localTime;
}
public LocalTime getLocalTimeUsingParseMethod(String timeRepresentation){
public LocalTime getLocalTimeUsingParseMethod(String timeRepresentation) {
LocalTime localTime = LocalTime.parse(timeRepresentation);
return localTime;
}
public LocalTime getLocalTimeFromClock(){
public LocalTime getLocalTimeFromClock() {
LocalTime localTime = LocalTime.now();
return localTime;
}
public LocalTime addAnHour(LocalTime localTime){
LocalTime newTime = localTime.plus(1,ChronoUnit.HOURS);
public LocalTime addAnHour(LocalTime localTime) {
LocalTime newTime = localTime.plus(1, ChronoUnit.HOURS);
return newTime;
}
public int getHourFromLocalTime(LocalTime localTime){
public int getHourFromLocalTime(LocalTime localTime) {
return localTime.getHour();
}
public LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute){
public LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute) {
return localTime.withMinute(minute);
}
}

8
core-java/src/main/java/com/baeldung/datetime/UsePeriod.java
View File

@ -4,12 +4,12 @@ import java.time.LocalDate;
import java.time.Period;
public class UsePeriod {
public LocalDate modifyDates(LocalDate localDate,Period period){
public LocalDate modifyDates(LocalDate localDate, Period period) {
return localDate.plus(period);
}
public Period getDifferenceBetweenDates(LocalDate localDate1,LocalDate localDate2){
public Period getDifferenceBetweenDates(LocalDate localDate1, LocalDate localDate2) {
return Period.between(localDate1, localDate2);
}
}

8
core-java/src/main/java/com/baeldung/datetime/UseToInstant.java
View File

@ -6,13 +6,13 @@ import java.util.Calendar;
import java.util.Date;
public class UseToInstant {
public LocalDateTime convertDateToLocalDate(Date date){
public LocalDateTime convertDateToLocalDate(Date date) {
LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
return localDateTime;
}
public LocalDateTime convertDateToLocalDate(Calendar calendar){
public LocalDateTime convertDateToLocalDate(Calendar calendar) {
LocalDateTime localDateTime = LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault());
return localDateTime;
}

4
core-java/src/main/java/com/baeldung/datetime/UseZonedDateTime.java
View File

@ -5,8 +5,8 @@ import java.time.ZoneId;
import java.time.ZonedDateTime;
public class UseZonedDateTime {
public ZonedDateTime getZonedDateTime(LocalDateTime localDateTime,ZoneId zoneId){
public ZonedDateTime getZonedDateTime(LocalDateTime localDateTime, ZoneId zoneId) {
ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);
return zonedDateTime;
}

7
core-java/src/main/java/com/baeldung/enums/Pizza.java
View File

@ -7,8 +7,7 @@ import java.util.stream.Collectors;
public class Pizza {
private static EnumSet<PizzaStatusEnum> deliveredPizzaStatuses =
EnumSet.of(PizzaStatusEnum.DELIVERED);
private static EnumSet<PizzaStatusEnum> deliveredPizzaStatuses = EnumSet.of(PizzaStatusEnum.DELIVERED);
private PizzaStatusEnum status;
@ -76,9 +75,7 @@ public class Pizza {
}
public static EnumMap<PizzaStatusEnum, List<Pizza>> groupPizzaByStatus(List<Pizza> pzList) {
return pzList.stream().collect(
Collectors.groupingBy(Pizza::getStatus,
() -> new EnumMap<>(PizzaStatusEnum.class), Collectors.toList()));
return pzList.stream().collect(Collectors.groupingBy(Pizza::getStatus, () -> new EnumMap<>(PizzaStatusEnum.class), Collectors.toList()));
}
public void deliver() {

1
core-java/src/main/java/com/baeldung/enums/PizzaDeliverySystemConfiguration.java
View File

@ -1,6 +1,5 @@
package com.baeldung.enums;
public enum PizzaDeliverySystemConfiguration {
INSTANCE;

3
core-java/src/main/java/com/baeldung/forkjoin/CustomRecursiveAction.java
View File

@ -30,8 +30,7 @@ public class CustomRecursiveAction extends RecursiveAction {
private Collection<CustomRecursiveAction> createSubtasks() {
List<CustomRecursiveAction> subtasks =
new ArrayList<>();
List<CustomRecursiveAction> subtasks = new ArrayList<>();
String partOne = workLoad.substring(0, workLoad.length() / 2);
String partTwo = workLoad.substring(workLoad.length() / 2, workLoad.length());

17
core-java/src/main/java/com/baeldung/forkjoin/CustomRecursiveTask.java
View File

@ -1,6 +1,5 @@
package com.baeldung.forkjoin;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@ -23,10 +22,7 @@ public class CustomRecursiveTask extends RecursiveTask<Integer> {
if (arr.length > THRESHOLD) {
return ForkJoinTask.invokeAll(createSubtasks())
.stream()
.mapToInt(ForkJoinTask::join)
.sum();
return ForkJoinTask.invokeAll(createSubtasks()).stream().mapToInt(ForkJoinTask::join).sum();
} else {
return processing(arr);
@ -35,17 +31,12 @@ public class CustomRecursiveTask extends RecursiveTask<Integer> {
private Collection<CustomRecursiveTask> createSubtasks() {
List<CustomRecursiveTask> dividedTasks = new ArrayList<>();
dividedTasks.add(new CustomRecursiveTask(
Arrays.copyOfRange(arr, 0, arr.length / 2)));
dividedTasks.add(new CustomRecursiveTask(
Arrays.copyOfRange(arr, arr.length / 2, arr.length)));
dividedTasks.add(new CustomRecursiveTask(Arrays.copyOfRange(arr, 0, arr.length / 2)));
dividedTasks.add(new CustomRecursiveTask(Arrays.copyOfRange(arr, arr.length / 2, arr.length)));
return dividedTasks;
}
private Integer processing(int[] arr) {
return Arrays.stream(arr)
.filter(a -> a > 10 && a < 27)
.map(a -> a * 10)
.sum();
return Arrays.stream(arr).filter(a -> a > 10 && a < 27).map(a -> a * 10).sum();
}
}

1
core-java/src/main/java/com/baeldung/forkjoin/util/PoolUtil.java
View File

@ -1,6 +1,5 @@
package com.baeldung.forkjoin.util;
import java.util.concurrent.ForkJoinPool;
public class PoolUtil {

2
core-java/src/main/java/com/baeldung/java/nio/selector/EchoServer.java
View File

@ -15,7 +15,7 @@ public class EchoServer {
public static void main(String[] args)
throws IOException {
throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.bind(new InetSocketAddress("localhost", 5454));

2
core-java/src/main/java/com/baeldung/java_8_features/Vehicle.java
View File

@ -9,7 +9,7 @@ public interface Vehicle {
}
default long[] startPosition() {
return new long[]{23, 15};
return new long[] { 23, 15 };
}
default String getOverview() {

4
core-java/src/main/java/com/baeldung/java_8_features/VehicleImpl.java
View File

@ -1,9 +1,9 @@
package com.baeldung.java_8_features;
public class VehicleImpl implements Vehicle {
public class VehicleImpl implements Vehicle {
@Override
public void moveTo(long altitude, long longitude) {
//do nothing
// do nothing
}
}

59
core-java/src/main/java/com/baeldung/socket/EchoClient.java
View File

@ -4,39 +4,38 @@ import java.io.*;
import java.net.*;
public class EchoClient {
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
public void startConnection(String ip, int port) {
try {
clientSocket = new Socket(ip, port);
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
} catch (IOException e) {
System.out.print(e);
}
public void startConnection(String ip, int port) {
try {
clientSocket = new Socket(ip, port);
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
} catch (IOException e) {
System.out.print(e);
}
}
}
public String sendMessage(String msg) {
try {
out.println(msg);
return in.readLine();
} catch (Exception e) {
return null;
}
}
public String sendMessage(String msg) {
try {
out.println(msg);
return in.readLine();
} catch (Exception e) {
return null;
}
}
public void stopConnection() {
try {
in.close();
out.close();
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
public void stopConnection() {
try {
in.close();
out.close();
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

101
core-java/src/main/java/com/baeldung/socket/EchoMultiServer.java
View File

@ -4,68 +4,67 @@ import java.net.*;
import java.io.*;
public class EchoMultiServer {
private ServerSocket serverSocket;
private ServerSocket serverSocket;
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
while (true)
new EchoClientHandler(serverSocket.accept()).run();
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
while (true)
new EchoClientHandler(serverSocket.accept()).run();
} catch (IOException e) {
e.printStackTrace();
} finally {
stop();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
stop();
}
}
}
public void stop() {
try {
public void stop() {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static class EchoClientHandler extends Thread {
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
private static class EchoClientHandler extends Thread {
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
public EchoClientHandler(Socket socket) {
this.clientSocket = socket;
}
public EchoClientHandler(Socket socket) {
this.clientSocket = socket;
}
public void run() {
try {
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
if (".".equals(inputLine)) {
out.println("bye");
break;
}
out.println(inputLine);
}
public void run() {
try {
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
if (".".equals(inputLine)) {
out.println("bye");
break;
}
out.println(inputLine);
}
in.close();
out.close();
clientSocket.close();
in.close();
out.close();
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
EchoMultiServer server = new EchoMultiServer();
server.start(5555);
}
public static void main(String[] args) {
EchoMultiServer server = new EchoMultiServer();
server.start(5555);
}
}

73
core-java/src/main/java/com/baeldung/socket/EchoServer.java
View File

@ -4,47 +4,46 @@ import java.net.*;
import java.io.*;
public class EchoServer {
private ServerSocket serverSocket;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
private ServerSocket serverSocket;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
clientSocket = serverSocket.accept();
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
if (".".equals(inputLine)) {
out.println("good bye");
break;
}
out.println(inputLine);
}
} catch (IOException e) {
e.printStackTrace();
}
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
clientSocket = serverSocket.accept();
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
if (".".equals(inputLine)) {
out.println("good bye");
break;
}
out.println(inputLine);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void stop() {
try {
in.close();
out.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
public void stop() {
try {
in.close();
out.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
EchoServer server = new EchoServer();
server.start(4444);
}
public static void main(String[] args) {
EchoServer server = new EchoServer();
server.start(4444);
}
}

59
core-java/src/main/java/com/baeldung/socket/GreetClient.java
View File

@ -7,39 +7,38 @@ import java.io.PrintWriter;
import java.net.Socket;
public class GreetClient {
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
public void startConnection(String ip, int port) {
try {
clientSocket = new Socket(ip, port);
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
} catch (IOException e) {
}
public void startConnection(String ip, int port) {
try {
clientSocket = new Socket(ip, port);
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
} catch (IOException e) {
}
}
public String sendMessage(String msg) {
try {
out.println(msg);
return in.readLine();
} catch (Exception e) {
return null;
}
}
}
public void stopConnection() {
try {
in.close();
out.close();
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public String sendMessage(String msg) {
try {
out.println(msg);
return in.readLine();
} catch (Exception e) {
return null;
}
}
public void stopConnection() {
try {
in.close();
out.close();
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

67
core-java/src/main/java/com/baeldung/socket/GreetServer.java
View File

@ -4,44 +4,43 @@ import java.net.*;
import java.io.*;
public class GreetServer {
private ServerSocket serverSocket;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
private ServerSocket serverSocket;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
clientSocket = serverSocket.accept();
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String greeting = in.readLine();
if ("hello server".equals(greeting))
out.println("hello client");
else
out.println("unrecognised greeting");
} catch (IOException e) {
e.printStackTrace();
}
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
clientSocket = serverSocket.accept();
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
clientSocket.getInputStream()));
String greeting = in.readLine();
if ("hello server".equals(greeting))
out.println("hello client");
else
out.println("unrecognised greeting");
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void stop() {
try {
in.close();
out.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
public void stop() {
try {
in.close();
out.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
GreetServer server=new GreetServer();
server.start(6666);
}
public static void main(String[] args) {
GreetServer server = new GreetServer();
server.start(6666);
}
}

1
core-java/src/main/java/com/baeldung/streamApi/Product.java
View File

@ -44,7 +44,6 @@ public class Product {
this.name = name;
}
public static Stream<String> streamOf(List<String> list) {
return (list == null || list.isEmpty()) ? Stream.empty() : list.stream();
}

4
core-java/src/main/java/com/baeldung/threadpool/CountingTask.java
View File

@ -14,9 +14,7 @@ public class CountingTask extends RecursiveTask<Integer> {
@Override
protected Integer compute() {
return node.value + node.children.stream()
.map(childNode -> new CountingTask(childNode).fork())
.collect(Collectors.summingInt(ForkJoinTask::join));
return node.value + node.children.stream().map(childNode -> new CountingTask(childNode).fork()).collect(Collectors.summingInt(ForkJoinTask::join));
}
}

6
core-java/src/main/java/org/baeldung/executable/ExecutableMavenJar.java
View File

@ -4,8 +4,8 @@ import javax.swing.JOptionPane;
public class ExecutableMavenJar {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, "It worked!", "Executable Jar with Maven", 1);
}
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, "It worked!", "Executable Jar with Maven", 1);
}
}

10
core-java/src/test/java/com/baeldung/CharToStringTest.java
View File

@ -7,7 +7,7 @@ import static org.assertj.core.api.Assertions.assertThat;
public class CharToStringTest {
@Test
public void givenChar_whenCallingStringValueOf_shouldConvertToString(){
public void givenChar_whenCallingStringValueOf_shouldConvertToString() {
final char givenChar = 'x';
final String result = String.valueOf(givenChar);
@ -16,7 +16,7 @@ public class CharToStringTest {
}
@Test
public void givenChar_whenCallingToStringOnCharacter_shouldConvertToString(){
public void givenChar_whenCallingToStringOnCharacter_shouldConvertToString() {
final char givenChar = 'x';
final String result = Character.toString(givenChar);
@ -25,7 +25,7 @@ public class CharToStringTest {
}
@Test
public void givenChar_whenCallingCharacterConstructor_shouldConvertToString3(){
public void givenChar_whenCallingCharacterConstructor_shouldConvertToString3() {
final char givenChar = 'x';
final String result = new Character(givenChar).toString();
@ -34,7 +34,7 @@ public class CharToStringTest {
}
@Test
public void givenChar_whenConcatenated_shouldConvertToString4(){
public void givenChar_whenConcatenated_shouldConvertToString4() {
final char givenChar = 'x';
final String result = givenChar + "";
@ -43,7 +43,7 @@ public class CharToStringTest {
}
@Test
public void givenChar_whenFormated_shouldConvertToString5(){
public void givenChar_whenFormated_shouldConvertToString5() {
final char givenChar = 'x';
final String result = String.format("%c", givenChar);

4
core-java/src/test/java/com/baeldung/RandomListElementTest.java → core-java/src/test/java/com/baeldung/RandomListElementUnitTest.java
View File

@ -6,7 +6,7 @@ import org.junit.Test;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
public class RandomListElementTest {
public class RandomListElementUnitTest {
@Test
public void givenList_whenRandomIndexChosen_shouldReturnARandomElementUsingRandom() {
@ -20,7 +20,7 @@ public class RandomListElementTest {
public void givenList_whenRandomIndexChosen_shouldReturnARandomElementUsingMathRandom() {
List<Integer> givenList = Lists.newArrayList(1, 2, 3);
givenList.get((int)(Math.random() * givenList.size()));
givenList.get((int) (Math.random() * givenList.size()));
}
@Test

10
core-java/src/test/java/com/baeldung/StringToIntOrIntegerTest.java → core-java/src/test/java/com/baeldung/StringToIntOrIntegerUnitTest.java
View File

@ -1,11 +1,12 @@
package com.baeldung;
import com.google.common.primitives.Ints;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class StringToIntOrIntegerTest {
import org.junit.Test;
import com.google.common.primitives.Ints;
public class StringToIntOrIntegerUnitTest {
@Test
public void givenString_whenParsingInt_shouldConvertToInt() {
@ -16,7 +17,6 @@ public class StringToIntOrIntegerTest {
assertThat(result).isEqualTo(42);
}
@Test
public void givenString_whenCallingIntegerValueOf_shouldConvertToInt() {
String givenString = "42";

139
core-java/src/test/java/com/baeldung/collectors/Java8CollectorsTest.java
View File

@ -42,192 +42,137 @@ public class Java8CollectorsTest {
@Test
public void whenCollectingToList_shouldCollectToList() throws Exception {
final List<String> result = givenList.stream()
.collect(toList());
final List<String> result = givenList.stream().collect(toList());
assertThat(result)
.containsAll(givenList);
assertThat(result).containsAll(givenList);
}
@Test
public void whenCollectingToList_shouldCollectToSet() throws Exception {
final Set<String> result = givenList.stream()
.collect(toSet());
final Set<String> result = givenList.stream().collect(toSet());
assertThat(result)
.containsAll(givenList);
assertThat(result).containsAll(givenList);
}
@Test
public void whenCollectingToCollection_shouldCollectToCollection() throws Exception {
final List<String> result = givenList.stream()
.collect(toCollection(LinkedList::new));
final List<String> result = givenList.stream().collect(toCollection(LinkedList::new));
assertThat(result)
.containsAll(givenList)
.isInstanceOf(LinkedList.class);
assertThat(result).containsAll(givenList).isInstanceOf(LinkedList.class);
}
@Test
public void whenCollectingToImmutableCollection_shouldThrowException() throws Exception {
assertThatThrownBy(() -> {
givenList.stream()
.collect(toCollection(ImmutableList::of));
givenList.stream().collect(toCollection(ImmutableList::of));
}).isInstanceOf(UnsupportedOperationException.class);
}
@Test
public void whenCollectingToMap_shouldCollectToMap() throws Exception {
final Map<String, Integer> result = givenList.stream()
.collect(toMap(Function.identity(), String::length));
final Map<String, Integer> result = givenList.stream().collect(toMap(Function.identity(), String::length));
assertThat(result)
.containsEntry("a", 1)
.containsEntry("bb", 2)
.containsEntry("ccc", 3)
.containsEntry("dd", 2);
assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("ccc", 3).containsEntry("dd", 2);
}
@Test
public void whenCollectingToMap_shouldCollectToMapMerging() throws Exception {
final Map<String, Integer> result = givenList.stream()
.collect(toMap(Function.identity(), String::length, (i1, i2) -> i1));
final Map<String, Integer> result = givenList.stream().collect(toMap(Function.identity(), String::length, (i1, i2) -> i1));
assertThat(result)
.containsEntry("a", 1)
.containsEntry("bb", 2)
.containsEntry("ccc", 3)
.containsEntry("dd", 2);
assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("ccc", 3).containsEntry("dd", 2);
}
@Test
public void whenCollectingAndThen_shouldCollect() throws Exception {
final List<String> result = givenList.stream()
.collect(collectingAndThen(toList(), ImmutableList::copyOf));
final List<String> result = givenList.stream().collect(collectingAndThen(toList(), ImmutableList::copyOf));
assertThat(result)
.containsAll(givenList)
.isInstanceOf(ImmutableList.class);
assertThat(result).containsAll(givenList).isInstanceOf(ImmutableList.class);
}
@Test
public void whenJoining_shouldJoin() throws Exception {
final String result = givenList.stream()
.collect(joining());
final String result = givenList.stream().collect(joining());
assertThat(result)
.isEqualTo("abbcccdd");
assertThat(result).isEqualTo("abbcccdd");
}
@Test
public void whenJoiningWithSeparator_shouldJoinWithSeparator() throws Exception {
final String result = givenList.stream()
.collect(joining(" "));
final String result = givenList.stream().collect(joining(" "));
assertThat(result)
.isEqualTo("a bb ccc dd");
assertThat(result).isEqualTo("a bb ccc dd");
}
@Test
public void whenJoiningWithSeparatorAndPrefixAndPostfix_shouldJoinWithSeparatorPrePost() throws Exception {
final String result = givenList.stream()
.collect(joining(" ", "PRE-", "-POST"));
final String result = givenList.stream().collect(joining(" ", "PRE-", "-POST"));
assertThat(result)
.isEqualTo("PRE-a bb ccc dd-POST");
assertThat(result).isEqualTo("PRE-a bb ccc dd-POST");
}
@Test
public void whenPartitioningBy_shouldPartition() throws Exception {
final Map<Boolean, List<String>> result = givenList.stream()
.collect(partitioningBy(s -> s.length() > 2));
final Map<Boolean, List<String>> result = givenList.stream().collect(partitioningBy(s -> s.length() > 2));
assertThat(result)
.containsKeys(true, false)
.satisfies(booleanListMap -> {
assertThat(booleanListMap.get(true))
.contains("ccc");
assertThat(result).containsKeys(true, false).satisfies(booleanListMap -> {
assertThat(booleanListMap.get(true)).contains("ccc");
assertThat(booleanListMap.get(false))
.contains("a", "bb", "dd");
});
assertThat(booleanListMap.get(false)).contains("a", "bb", "dd");
});
}
@Test
public void whenCounting_shouldCount() throws Exception {
final Long result = givenList.stream()
.collect(counting());
final Long result = givenList.stream().collect(counting());
assertThat(result)
.isEqualTo(4);
assertThat(result).isEqualTo(4);
}
@Test
public void whenSummarizing_shouldSummarize() throws Exception {
final DoubleSummaryStatistics result = givenList.stream()
.collect(summarizingDouble(String::length));
final DoubleSummaryStatistics result = givenList.stream().collect(summarizingDouble(String::length));
assertThat(result.getAverage())
.isEqualTo(2);
assertThat(result.getCount())
.isEqualTo(4);
assertThat(result.getMax())
.isEqualTo(3);
assertThat(result.getMin())
.isEqualTo(1);
assertThat(result.getSum())
.isEqualTo(8);
assertThat(result.getAverage()).isEqualTo(2);
assertThat(result.getCount()).isEqualTo(4);
assertThat(result.getMax()).isEqualTo(3);
assertThat(result.getMin()).isEqualTo(1);
assertThat(result.getSum()).isEqualTo(8);
}
@Test
public void whenAveraging_shouldAverage() throws Exception {
final Double result = givenList.stream()
.collect(averagingDouble(String::length));
final Double result = givenList.stream().collect(averagingDouble(String::length));
assertThat(result)
.isEqualTo(2);
assertThat(result).isEqualTo(2);
}
@Test
public void whenSumming_shouldSum() throws Exception {
final Double result = givenList.stream()
.collect(summingDouble(String::length));
final Double result = givenList.stream().collect(summingDouble(String::length));
assertThat(result)
.isEqualTo(8);
assertThat(result).isEqualTo(8);
}
@Test
public void whenMaxingBy_shouldMaxBy() throws Exception {
final Optional<String> result = givenList.stream()
.collect(maxBy(Comparator.naturalOrder()));
final Optional<String> result = givenList.stream().collect(maxBy(Comparator.naturalOrder()));
assertThat(result)
.isPresent()
.hasValue("dd");
assertThat(result).isPresent().hasValue("dd");
}
@Test
public void whenGroupingBy_shouldGroupBy() throws Exception {
final Map<Integer, Set<String>> result = givenList.stream()
.collect(groupingBy(String::length, toSet()));
final Map<Integer, Set<String>> result = givenList.stream().collect(groupingBy(String::length, toSet()));
assertThat(result)
.containsEntry(1, newHashSet("a"))
.containsEntry(2, newHashSet("bb", "dd"))
.containsEntry(3, newHashSet("ccc"));
assertThat(result).containsEntry(1, newHashSet("a")).containsEntry(2, newHashSet("bb", "dd")).containsEntry(3, newHashSet("ccc"));
}
@Test
public void whenCreatingCustomCollector_shouldCollect() throws Exception {
final ImmutableSet<String> result = givenList.stream()
.collect(toImmutableSet());
final ImmutableSet<String> result = givenList.stream().collect(toImmutableSet());
assertThat(result)
.isInstanceOf(ImmutableSet.class)
.contains("a", "bb", "ccc", "dd");
assertThat(result).isInstanceOf(ImmutableSet.class).contains("a", "bb", "ccc", "dd");
}

17
core-java/src/test/java/com/baeldung/completablefuture/CompletableFutureTest.java
View File

@ -43,7 +43,6 @@ public class CompletableFutureTest {
}
public Future<String> calculateAsyncWithCancellation() throws InterruptedException {
CompletableFuture<String> completableFuture = new CompletableFuture<>();
@ -56,7 +55,6 @@ public class CompletableFutureTest {
return completableFuture;
}
@Test(expected = CancellationException.class)
public void whenCancelingTheFuture_thenThrowsCancellationException() throws ExecutionException, InterruptedException {
@ -110,8 +108,7 @@ public class CompletableFutureTest {
@Test
public void whenUsingThenCompose_thenFuturesExecuteSequentially() throws ExecutionException, InterruptedException {
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello")
.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello").thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));
assertEquals("Hello World", completableFuture.get());
@ -120,9 +117,7 @@ public class CompletableFutureTest {
@Test
public void whenUsingThenCombine_thenWaitForExecutionOfBothFutures() throws ExecutionException, InterruptedException {
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello")
.thenCombine(CompletableFuture.supplyAsync(() -> " World"),
(s1, s2) -> s1 + s2);
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello").thenCombine(CompletableFuture.supplyAsync(() -> " World"), (s1, s2) -> s1 + s2);
assertEquals("Hello World", completableFuture.get());
@ -131,9 +126,7 @@ public class CompletableFutureTest {
@Test
public void whenUsingThenAcceptBoth_thenWaitForExecutionOfBothFutures() throws ExecutionException, InterruptedException {
CompletableFuture.supplyAsync(() -> "Hello")
.thenAcceptBoth(CompletableFuture.supplyAsync(() -> " World"),
(s1, s2) -> System.out.println(s1 + s2));
CompletableFuture.supplyAsync(() -> "Hello").thenAcceptBoth(CompletableFuture.supplyAsync(() -> " World"), (s1, s2) -> System.out.println(s1 + s2));
}
@ -154,9 +147,7 @@ public class CompletableFutureTest {
assertTrue(future2.isDone());
assertTrue(future3.isDone());
String combined = Stream.of(future1, future2, future3)
.map(CompletableFuture::join)
.collect(Collectors.joining(" "));
String combined = Stream.of(future1, future2, future3).map(CompletableFuture::join).collect(Collectors.joining(" "));
assertEquals("Hello Beautiful World", combined);

2
core-java/src/test/java/com/baeldung/dateapi/JavaUtilTimeTest.java → core-java/src/test/java/com/baeldung/dateapi/JavaUtilTimeUnitTest.java
View File

@ -14,7 +14,7 @@ import java.time.temporal.ChronoUnit;
import static org.assertj.core.api.Assertions.assertThat;
public class JavaUtilTimeTest {
public class JavaUtilTimeUnitTest {
@Test
public void currentTime() {

71
core-java/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceTest.java → core-java/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java
View File

@ -1,7 +1,8 @@
package com.baeldung.functionalinterface;
import com.google.common.util.concurrent.Uninterruptibles;
import org.junit.Test;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.HashMap;
@ -13,54 +14,43 @@ import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.Assert.*;
import org.junit.Test;
public class FunctionalInterfaceTest {
import com.google.common.util.concurrent.Uninterruptibles;
public class FunctionalInterfaceUnitTest {
@Test
public void whenPassingLambdaToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() {
Map<String, Integer> nameMap = new HashMap<>();
Integer value = nameMap.computeIfAbsent("John", s -> s.length());
assertEquals(new Integer(4), nameMap.get("John"));
assertEquals(new Integer(4), value);
}
@Test
public void whenPassingMethodReferenceToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() {
Map<String, Integer> nameMap = new HashMap<>();
Integer value = nameMap.computeIfAbsent("John", String::length);
assertEquals(new Integer(4), nameMap.get("John"));
assertEquals(new Integer(4), value);
}
public byte[] transformArray(short[] array, ShortToByteFunction function) {
byte[] transformedArray = new byte[array.length];
for (int i = 0; i < array.length; i++) {
transformedArray[i] = function.applyAsByte(array[i]);
}
return transformedArray;
}
@Test
public void whenUsingCustomFunctionalInterfaceForPrimitives_thenCanUseItAsLambda() {
short[] array = {(short) 1, (short) 2, (short) 3};
short[] array = { (short) 1, (short) 2, (short) 3 };
byte[] transformedArray = transformArray(array, s -> (byte) (s * 2));
byte[] expectedArray = {(byte) 2, (byte) 4, (byte) 6};
byte[] expectedArray = { (byte) 2, (byte) 4, (byte) 6 };
assertArrayEquals(expectedArray, transformedArray);
}
@Test
public void whenUsingBiFunction_thenCanUseItToReplaceMapValues() {
Map<String, Integer> salaries = new HashMap<>();
salaries.put("John", 40000);
salaries.put("Freddy", 30000);
@ -71,22 +61,18 @@ public class FunctionalInterfaceTest {
assertEquals(new Integer(50000), salaries.get("John"));
assertEquals(new Integer(30000), salaries.get("Freddy"));
assertEquals(new Integer(60000), salaries.get("Samuel"));
}
@Test
public void whenPassingLambdaToThreadConstructor_thenLambdaInferredToRunnable() {
Thread thread = new Thread(() -> System.out.println("Hello From Another Thread"));
thread.start();
}
@Test
public void whenUsingSupplierToGenerateNumbers_thenCanUseItInStreamGenerate() {
int[] fibs = {0, 1};
int[] fibs = { 0, 1 };
Stream<Integer> fibonacci = Stream.generate(() -> {
int result = fibs[1];
int fib3 = fibs[0] + fibs[1];
@ -95,55 +81,44 @@ public class FunctionalInterfaceTest {
return result;
});
List<Integer> fibonacci5 = fibonacci.limit(5)
.collect(Collectors.toList());
List<Integer> fibonacci5 = fibonacci.limit(5).collect(Collectors.toList());
assertEquals(new Integer(1), fibonacci5.get(0));
assertEquals(new Integer(1), fibonacci5.get(1));
assertEquals(new Integer(2), fibonacci5.get(2));
assertEquals(new Integer(3), fibonacci5.get(3));
assertEquals(new Integer(5), fibonacci5.get(4));
}
@Test
public void whenUsingConsumerInForEach_thenConsumerExecutesForEachListElement() {
List<String> names = Arrays.asList("John", "Freddy", "Samuel");
names.forEach(name -> System.out.println("Hello, " + name));
}
@Test
public void whenUsingBiConsumerInForEach_thenConsumerExecutesForEachMapElement() {
Map<String, Integer> ages = new HashMap<>();
ages.put("John", 25);
ages.put("Freddy", 24);
ages.put("Samuel", 30);
ages.forEach((name, age) -> System.out.println(name + " is " + age + " years old"));
}
@Test
public void whenUsingPredicateInFilter_thenListValuesAreFilteredOut() {
List<String> names = Arrays.asList("Angela", "Aaron", "Bob", "Claire", "David");
List<String> namesWithA = names.stream()
.filter(name -> name.startsWith("A"))
.collect(Collectors.toList());
List<String> namesWithA = names.stream().filter(name -> name.startsWith("A")).collect(Collectors.toList());
assertEquals(2, namesWithA.size());
assertTrue(namesWithA.contains("Angela"));
assertTrue(namesWithA.contains("Aaron"));
}
@Test
public void whenUsingUnaryOperatorWithReplaceAll_thenAllValuesInTheListAreReplaced() {
List<String> names = Arrays.asList("bob", "josh", "megan");
names.replaceAll(String::toUpperCase);
@ -151,7 +126,6 @@ public class FunctionalInterfaceTest {
assertEquals("BOB", names.get(0));
assertEquals("JOSH", names.get(1));
assertEquals("MEGAN", names.get(2));
}
@Test
@ -159,8 +133,7 @@ public class FunctionalInterfaceTest {
List<Integer> values = Arrays.asList(3, 5, 8, 9, 12);
int sum = values.stream()
.reduce(0, (i1, i2) -> i1 + i2);
int sum = values.stream().reduce(0, (i1, i2) -> i1 + i2);
assertEquals(37, sum);
@ -178,10 +151,6 @@ public class FunctionalInterfaceTest {
}
public double squareLazy(Supplier<Double> lazyValue) {
return Math.pow(lazyValue.get(), 2);
}
@Test
public void whenUsingSupplierToGenerateValue_thenValueIsGeneratedLazily() {
@ -196,4 +165,18 @@ public class FunctionalInterfaceTest {
}
//
public double squareLazy(Supplier<Double> lazyValue) {
return Math.pow(lazyValue.get(), 2);
}
public byte[] transformArray(short[] array, ShortToByteFunction function) {
byte[] transformedArray = new byte[array.length];
for (int i = 0; i < array.length; i++) {
transformedArray[i] = function.applyAsByte(array[i]);
}
return transformedArray;
}
}

111
core-java/src/test/java/com/baeldung/java/reflection/ReflectionTest.java → core-java/src/test/java/com/baeldung/java/reflection/ReflectionUnitTest.java
View File

@ -11,7 +11,7 @@ import java.util.List;
import java.util.ArrayList;
import static org.junit.Assert.*;
public class ReflectionTest {
public class ReflectionUnitTest {
@Test
public void givenObject_whenGetsFieldNamesAtRuntime_thenCorrect() {
@ -20,8 +20,7 @@ public class ReflectionTest {
List<String> actualFieldNames = getFieldNames(fields);
assertTrue(Arrays.asList("name", "age")
.containsAll(actualFieldNames));
assertTrue(Arrays.asList("name", "age").containsAll(actualFieldNames));
}
@Test
@ -35,8 +34,7 @@ public class ReflectionTest {
}
@Test
public void givenClassName_whenCreatesObject_thenCorrect()
throws ClassNotFoundException {
public void givenClassName_whenCreatesObject_thenCorrect() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.baeldung.java.reflection.Goat");
assertEquals("Goat", clazz.getSimpleName());
@ -45,8 +43,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenRecognisesModifiers_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenRecognisesModifiers_thenCorrect() throws ClassNotFoundException {
Class<?> goatClass = Class.forName("com.baeldung.java.reflection.Goat");
Class<?> animalClass = Class.forName("com.baeldung.java.reflection.Animal");
int goatMods = goatClass.getModifiers();
@ -80,8 +77,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsImplementedInterfaces_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsImplementedInterfaces_thenCorrect() throws ClassNotFoundException {
Class<?> goatClass = Class.forName("com.baeldung.java.reflection.Goat");
Class<?> animalClass = Class.forName("com.baeldung.java.reflection.Animal");
Class<?>[] goatInterfaces = goatClass.getInterfaces();
@ -94,8 +90,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsConstructor_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsConstructor_thenCorrect() throws ClassNotFoundException {
Class<?> goatClass = Class.forName("com.baeldung.java.reflection.Goat");
Constructor<?>[] constructors = goatClass.getConstructors();
@ -104,8 +99,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsFields_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsFields_thenCorrect() throws ClassNotFoundException {
Class<?> animalClass = Class.forName("com.baeldung.java.reflection.Animal");
Field[] fields = animalClass.getDeclaredFields();
@ -116,20 +110,17 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsMethods_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsMethods_thenCorrect() throws ClassNotFoundException {
Class<?> animalClass = Class.forName("com.baeldung.java.reflection.Animal");
Method[] methods = animalClass.getDeclaredMethods();
List<String> actualMethods = getMethodNames(methods);
assertEquals(4, actualMethods.size());
assertTrue(actualMethods.containsAll(Arrays.asList("getName",
"setName", "getSound")));
assertTrue(actualMethods.containsAll(Arrays.asList("getName", "setName", "getSound")));
}
@Test
public void givenClass_whenGetsAllConstructors_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsAllConstructors_thenCorrect() throws ClassNotFoundException {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Constructor<?>[] constructors = birdClass.getConstructors();
@ -137,24 +128,20 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsEachConstructorByParamTypes_thenCorrect()
throws Exception {
public void givenClass_whenGetsEachConstructorByParamTypes_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Constructor<?> cons1 = birdClass.getConstructor();
Constructor<?> cons2 = birdClass.getConstructor(String.class);
Constructor<?> cons3 = birdClass.getConstructor(String.class,
boolean.class);
Constructor<?> cons3 = birdClass.getConstructor(String.class, boolean.class);
}
@Test
public void givenClass_whenInstantiatesObjectsAtRuntime_thenCorrect()
throws Exception {
public void givenClass_whenInstantiatesObjectsAtRuntime_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Constructor<?> cons1 = birdClass.getConstructor();
Constructor<?> cons2 = birdClass.getConstructor(String.class);
Constructor<?> cons3 = birdClass.getConstructor(String.class,
boolean.class);
Constructor<?> cons3 = birdClass.getConstructor(String.class, boolean.class);
Bird bird1 = (Bird) cons1.newInstance();
Bird bird2 = (Bird) cons2.newInstance("Weaver bird");
@ -168,8 +155,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsPublicFields_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsPublicFields_thenCorrect() throws ClassNotFoundException {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Field[] fields = birdClass.getFields();
assertEquals(1, fields.length);
@ -178,8 +164,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsPublicFieldByName_thenCorrect()
throws Exception {
public void givenClass_whenGetsPublicFieldByName_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Field field = birdClass.getField("CATEGORY");
assertEquals("CATEGORY", field.getName());
@ -187,8 +172,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsDeclaredFields_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsDeclaredFields_thenCorrect() throws ClassNotFoundException {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Field[] fields = birdClass.getDeclaredFields();
assertEquals(1, fields.length);
@ -196,8 +180,7 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsFieldsByName_thenCorrect()
throws Exception {
public void givenClass_whenGetsFieldsByName_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Field field = birdClass.getDeclaredField("walks");
assertEquals("walks", field.getName());
@ -205,17 +188,14 @@ public class ReflectionTest {
}
@Test
public void givenClassField_whenGetsType_thenCorrect()
throws Exception {
Field field = Class.forName("com.baeldung.java.reflection.Bird")
.getDeclaredField("walks");
public void givenClassField_whenGetsType_thenCorrect() throws Exception {
Field field = Class.forName("com.baeldung.java.reflection.Bird").getDeclaredField("walks");
Class<?> fieldClass = field.getType();
assertEquals("boolean", fieldClass.getSimpleName());
}
@Test
public void givenClassField_whenSetsAndGetsValue_thenCorrect()
throws Exception {
public void givenClassField_whenSetsAndGetsValue_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Bird bird = (Bird) birdClass.newInstance();
Field field = birdClass.getDeclaredField("walks");
@ -232,8 +212,7 @@ public class ReflectionTest {
}
@Test
public void givenClassField_whenGetsAndSetsWithNull_thenCorrect()
throws Exception {
public void givenClassField_whenGetsAndSetsWithNull_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Field field = birdClass.getField("CATEGORY");
field.setAccessible(true);
@ -242,21 +221,17 @@ public class ReflectionTest {
}
@Test
public void givenClass_whenGetsAllPublicMethods_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsAllPublicMethods_thenCorrect() throws ClassNotFoundException {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Method[] methods = birdClass.getMethods();
List<String> methodNames = getMethodNames(methods);
assertTrue(methodNames.containsAll(Arrays
.asList("equals", "notifyAll", "hashCode",
"walks", "eats", "toString")));
assertTrue(methodNames.containsAll(Arrays.asList("equals", "notifyAll", "hashCode", "walks", "eats", "toString")));
}
@Test
public void givenClass_whenGetsOnlyDeclaredMethods_thenCorrect()
throws ClassNotFoundException {
public void givenClass_whenGetsOnlyDeclaredMethods_thenCorrect() throws ClassNotFoundException {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
List<String> actualMethodNames = getMethodNames(birdClass.getDeclaredMethods());
@ -269,12 +244,10 @@ public class ReflectionTest {
}
@Test
public void givenMethodName_whenGetsMethod_thenCorrect()
throws Exception {
public void givenMethodName_whenGetsMethod_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Method walksMethod = birdClass.getDeclaredMethod("walks");
Method setWalksMethod = birdClass.getDeclaredMethod("setWalks",
boolean.class);
Method setWalksMethod = birdClass.getDeclaredMethod("setWalks", boolean.class);
assertFalse(walksMethod.isAccessible());
assertFalse(setWalksMethod.isAccessible());
@ -288,12 +261,10 @@ public class ReflectionTest {
}
@Test
public void givenMethod_whenInvokes_thenCorrect()
throws Exception {
public void givenMethod_whenInvokes_thenCorrect() throws Exception {
Class<?> birdClass = Class.forName("com.baeldung.java.reflection.Bird");
Bird bird = (Bird) birdClass.newInstance();
Method setWalksMethod = birdClass.getDeclaredMethod("setWalks",
boolean.class);
Method setWalksMethod = birdClass.getDeclaredMethod("setWalks", boolean.class);
Method walksMethod = birdClass.getDeclaredMethod("walks");
boolean walks = (boolean) walksMethod.invoke(bird);
@ -308,19 +279,19 @@ public class ReflectionTest {
}
private static List<String> getFieldNames(Field[] fields) {
List<String> fieldNames = new ArrayList<>();
for (Field field : fields)
fieldNames.add(field.getName());
return fieldNames;
private static List<String> getFieldNames(Field[] fields) {
List<String> fieldNames = new ArrayList<>();
for (Field field : fields)
fieldNames.add(field.getName());
return fieldNames;
}
}
private static List<String> getMethodNames(Method[] methods) {
List<String> methodNames = new ArrayList<>();
for (Method method : methods)
methodNames.add(method.getName());
return methodNames;
}
private static List<String> getMethodNames(Method[] methods) {
List<String> methodNames = new ArrayList<>();
for (Method method : methods)
methodNames.add(method.getName());
return methodNames;
}
}

3
core-java/src/test/java/com/baeldung/java/regex/RegexTest.java → core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java
View File

@ -7,7 +7,7 @@ import java.util.regex.Pattern;
import org.junit.Test;
public class RegexTest {
public class RegexUnitTest {
private static Pattern pattern;
private static Matcher matcher;
@ -499,4 +499,3 @@ public class RegexTest {
return matches;
}
}

3
core-java/src/test/java/com/baeldung/printscreen/ScreenshotTest.java → core-java/src/test/java/com/baeldung/printscreen/ScreenshotUnitTest.java
View File

@ -7,8 +7,7 @@ import java.io.File;
import static org.junit.Assert.assertTrue;
public class ScreenshotTest {
public class ScreenshotUnitTest {
private Screenshot screenshot = new Screenshot("Screenshot.jpg");
private File file = new File("Screenshot.jpg");

72
core-java/src/test/java/com/baeldung/socket/EchoMultiTest.java
View File

@ -17,43 +17,43 @@ public class EchoMultiTest {
Thread.sleep(500);
}
@Test
public void givenClient1_whenServerResponds_thenCorrect() {
EchoClient client = new EchoClient();
client.startConnection("127.0.0.1", PORT);
String msg1 = client.sendMessage("hello");
String msg2 = client.sendMessage("world");
String terminate = client.sendMessage(".");
@Test
public void givenClient1_whenServerResponds_thenCorrect() {
EchoClient client = new EchoClient();
client.startConnection("127.0.0.1", PORT);
String msg1 = client.sendMessage("hello");
String msg2 = client.sendMessage("world");
String terminate = client.sendMessage(".");
assertEquals(msg1, "hello");
assertEquals(msg2, "world");
assertEquals(terminate, "bye");
client.stopConnection();
}
assertEquals(msg1, "hello");
assertEquals(msg2, "world");
assertEquals(terminate, "bye");
client.stopConnection();
}
@Test
public void givenClient2_whenServerResponds_thenCorrect() {
EchoClient client = new EchoClient();
client.startConnection("127.0.0.1", PORT);
String msg1 = client.sendMessage("hello");
String msg2 = client.sendMessage("world");
String terminate = client.sendMessage(".");
assertEquals(msg1, "hello");
assertEquals(msg2, "world");
assertEquals(terminate, "bye");
client.stopConnection();
}
@Test
public void givenClient2_whenServerResponds_thenCorrect() {
EchoClient client = new EchoClient();
client.startConnection("127.0.0.1", PORT);
String msg1 = client.sendMessage("hello");
String msg2 = client.sendMessage("world");
String terminate = client.sendMessage(".");
assertEquals(msg1, "hello");
assertEquals(msg2, "world");
assertEquals(terminate, "bye");
client.stopConnection();
}
@Test
public void givenClient3_whenServerResponds_thenCorrect() {
EchoClient client = new EchoClient();
client.startConnection("127.0.0.1", PORT);
String msg1 = client.sendMessage("hello");
String msg2 = client.sendMessage("world");
String terminate = client.sendMessage(".");
assertEquals(msg1, "hello");
assertEquals(msg2, "world");
assertEquals(terminate, "bye");
client.stopConnection();
}
@Test
public void givenClient3_whenServerResponds_thenCorrect() {
EchoClient client = new EchoClient();
client.startConnection("127.0.0.1", PORT);
String msg1 = client.sendMessage("hello");
String msg2 = client.sendMessage("world");
String terminate = client.sendMessage(".");
assertEquals(msg1, "hello");
assertEquals(msg2, "world");
assertEquals(terminate, "bye");
client.stopConnection();
}
}

40
core-java/src/test/java/com/baeldung/socket/EchoTest.java
View File

@ -18,28 +18,28 @@ public class EchoTest {
Thread.sleep(500);
}
private EchoClient client = new EchoClient();
private EchoClient client = new EchoClient();
@Before
public void init() {
client.startConnection("127.0.0.1", PORT);
}
@Before
public void init() {
client.startConnection("127.0.0.1", PORT);
}
@Test
public void givenClient_whenServerEchosMessage_thenCorrect() {
@Test
public void givenClient_whenServerEchosMessage_thenCorrect() {
String resp1 = client.sendMessage("hello");
String resp2 = client.sendMessage("world");
String resp3 = client.sendMessage("!");
String resp4 = client.sendMessage(".");
assertEquals("hello", resp1);
assertEquals("world", resp2);
assertEquals("!", resp3);
assertEquals("good bye", resp4);
}
String resp1 = client.sendMessage("hello");
String resp2 = client.sendMessage("world");
String resp3 = client.sendMessage("!");
String resp4 = client.sendMessage(".");
assertEquals("hello", resp1);
assertEquals("world", resp2);
assertEquals("!", resp3);
assertEquals("good bye", resp4);
}
@After
public void tearDown() {
client.stopConnection();
}
@After
public void tearDown() {
client.stopConnection();
}
}

4
core-java/src/test/java/com/baeldung/socket/GreetServerTest.java → core-java/src/test/java/com/baeldung/socket/GreetServerIntegrationTest.java
View File

@ -9,7 +9,7 @@ import java.util.concurrent.Executors;
import static org.junit.Assert.assertEquals;
public class GreetServerTest {
public class GreetServerIntegrationTest {
private GreetClient client;
@ -24,7 +24,7 @@ public class GreetServerTest {
@Before
public void init() {
client = new GreetClient();
client.startConnection("127.0.0.1", PORT);
client.startConnection("127.0.0.1", PORT);
}

2
core-java/src/test/java/org/baeldung/core/exceptions/FileNotFoundExceptionTest.java
View File

@ -42,7 +42,7 @@ public class FileNotFoundExceptionTest {
LOG.error("Optional file " + fileName + " was not found.", ex);
}
}
private void readFailingFile() throws IOException {
BufferedReader rd = new BufferedReader(new FileReader(new File(fileName)));
rd.readLine();

2
core-java/src/test/java/org/baeldung/equalshashcode/entities/PrimitiveClassTest.java → core-java/src/test/java/org/baeldung/equalshashcode/entities/PrimitiveClassUnitTest.java
View File

@ -3,7 +3,7 @@ package org.baeldung.equalshashcode.entities;
import org.junit.Assert;
import org.junit.Test;
public class PrimitiveClassTest {
public class PrimitiveClassUnitTest {
@Test
public void testTwoEqualsObjects() {

3
core-java/src/test/java/org/baeldung/equalshashcode/entities/SquareClassTest.java → core-java/src/test/java/org/baeldung/equalshashcode/entities/SquareClassUnitTest.java
View File

@ -5,11 +5,10 @@ import java.awt.Color;
import org.junit.Assert;
import org.junit.Test;
public class SquareClassTest {
public class SquareClassUnitTest {
@Test
public void testEqualsAndHashcodes() {
Square aObject = new Square(10, Color.BLUE);
Square bObject = new Square(10, Color.BLUE);

17
core-java/src/test/java/org/baeldung/java/arrays/ArraysJoinAndSplitJUnitTest.java
View File

@ -7,11 +7,11 @@ import org.junit.Test;
public class ArraysJoinAndSplitJUnitTest {
private final String[] sauces = {"Marinara", "Olive Oil"};
private final String[] cheeses = {"Mozzarella", "Feta", "Parmesan"};
private final String[] vegetables = {"Olives", "Spinach", "Green Peppers"};
private final String[] sauces = { "Marinara", "Olive Oil" };
private final String[] cheeses = { "Mozzarella", "Feta", "Parmesan" };
private final String[] vegetables = { "Olives", "Spinach", "Green Peppers" };
private final String[] customers = {"Jay", "Harry", "Ronnie", "Gary", "Ross"};
private final String[] customers = { "Jay", "Harry", "Ronnie", "Gary", "Ross" };
@Test
public void givenThreeStringArrays_whenJoiningIntoOneStringArray_shouldSucceed() {
@ -25,12 +25,9 @@ public class ArraysJoinAndSplitJUnitTest {
System.arraycopy(vegetables, 0, toppings, AddedSoFar, vegetables.length);
Assert.assertArrayEquals(toppings,
new String[]{"Marinara", "Olive Oil", "Mozzarella", "Feta",
"Parmesan", "Olives", "Spinach", "Green Peppers"});
Assert.assertArrayEquals(toppings, new String[] { "Marinara", "Olive Oil", "Mozzarella", "Feta", "Parmesan", "Olives", "Spinach", "Green Peppers" });
}
@Test
public void givenOneStringArray_whenSplittingInHalfTwoStringArrays_shouldSucceed() {
int ordersHalved = (customers.length / 2) + (customers.length % 2);
@ -38,7 +35,7 @@ public class ArraysJoinAndSplitJUnitTest {
String[] driverOne = Arrays.copyOf(customers, ordersHalved);
String[] driverTwo = Arrays.copyOfRange(customers, ordersHalved, customers.length);
Assert.assertArrayEquals(driverOne, new String[]{"Jay", "Harry", "Ronnie"});
Assert.assertArrayEquals(driverTwo, new String[]{"Gary", "Ross"});
Assert.assertArrayEquals(driverOne, new String[] { "Jay", "Harry", "Ronnie" });
Assert.assertArrayEquals(driverTwo, new String[] { "Gary", "Ross" });
}
}

19
core-java/src/test/java/org/baeldung/java/collections/ArrayListTest.java
View File

@ -18,10 +18,7 @@ public class ArrayListTest {
@Before
public void setUp() {
List<String> list = LongStream.range(0, 16)
.boxed()
.map(Long::toHexString)
.collect(toCollection(ArrayList::new));
List<String> list = LongStream.range(0, 16).boxed().map(Long::toHexString).collect(toCollection(ArrayList::new));
stringsToSearch = new ArrayList<>(list);
stringsToSearch.addAll(list);
}
@ -34,8 +31,7 @@ public class ArrayListTest {
@Test
public void givenCollection_whenProvideItToArrayListCtor_thenArrayListIsPopulatedWithItsElements() {
Collection<Integer> numbers =
IntStream.range(0, 10).boxed().collect(toSet());
Collection<Integer> numbers = IntStream.range(0, 10).boxed().collect(toSet());
List<Integer> list = new ArrayList<>(numbers);
assertEquals(10, list.size());
@ -56,8 +52,7 @@ public class ArrayListTest {
@Test
public void givenCollection_whenAddToArrayList_thenIsAdded() {
List<Long> list = new ArrayList<>(Arrays.asList(1L, 2L, 3L));
LongStream.range(4, 10).boxed()
.collect(collectingAndThen(toCollection(ArrayList::new), ys -> list.addAll(0, ys)));
LongStream.range(4, 10).boxed().collect(collectingAndThen(toCollection(ArrayList::new), ys -> list.addAll(0, ys)));
assertThat(Arrays.asList(4L, 5L, 6L, 7L, 8L, 9L, 1L, 2L, 3L), equalTo(list));
}
@ -88,10 +83,7 @@ public class ArrayListTest {
public void givenPredicate_whenIterateArrayList_thenFindAllElementsSatisfyingPredicate() {
Set<String> matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));
List<String> result = stringsToSearch
.stream()
.filter(matchingStrings::contains)
.collect(toCollection(ArrayList::new));
List<String> result = stringsToSearch.stream().filter(matchingStrings::contains).collect(toCollection(ArrayList::new));
assertEquals(6, result.size());
}
@ -131,8 +123,7 @@ public class ArrayListTest {
@Test
public void givenCondition_whenIterateArrayList_thenRemoveAllElementsSatisfyingCondition() {
Set<String> matchingStrings
= Sets.newHashSet("a", "b", "c", "d", "e", "f");
Set<String> matchingStrings = Sets.newHashSet("a", "b", "c", "d", "e", "f");
Iterator<String> it = stringsToSearch.iterator();
while (it.hasNext()) {

41
core-java/src/test/java/org/baeldung/java/enums/PizzaTest.java → core-java/src/test/java/org/baeldung/java/enums/PizzaUnitTest.java
View File

@ -1,21 +1,21 @@
package org.baeldung.java.enums;
import com.baeldung.enums.Pizza;
import org.junit.Test;
import static junit.framework.TestCase.assertTrue;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import static junit.framework.TestCase.assertTrue;
import org.junit.Test;
import com.baeldung.enums.Pizza;
public class PizzaUnitTest {
public class PizzaTest {
@Test
public void givenPizaOrder_whenReady_thenDeliverable() {
Pizza testPz = new Pizza();
testPz.setStatus(Pizza.PizzaStatus.READY);
testPz.setStatus(Pizza.PizzaStatusEnum.READY);
assertTrue(testPz.isDeliverable());
}
@ -23,16 +23,16 @@ public class PizzaTest {
public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
List<Pizza> pzList = new ArrayList<>();
Pizza pz1 = new Pizza();
pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
Pizza pz2 = new Pizza();
pz2.setStatus(Pizza.PizzaStatus.ORDERED);
pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
Pizza pz3 = new Pizza();
pz3.setStatus(Pizza.PizzaStatus.ORDERED);
pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
Pizza pz4 = new Pizza();
pz4.setStatus(Pizza.PizzaStatus.READY);
pz4.setStatus(Pizza.PizzaStatusEnum.READY);
pzList.add(pz1);
pzList.add(pz2);
@ -48,33 +48,34 @@ public class PizzaTest {
List<Pizza> pzList = new ArrayList<>();
Pizza pz1 = new Pizza();
pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
Pizza pz2 = new Pizza();
pz2.setStatus(Pizza.PizzaStatus.ORDERED);
pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
Pizza pz3 = new Pizza();
pz3.setStatus(Pizza.PizzaStatus.ORDERED);
pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
Pizza pz4 = new Pizza();
pz4.setStatus(Pizza.PizzaStatus.READY);
pz4.setStatus(Pizza.PizzaStatusEnum.READY);
pzList.add(pz1);
pzList.add(pz2);
pzList.add(pz3);
pzList.add(pz4);
EnumMap<Pizza.PizzaStatus, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
assertTrue(map.get(Pizza.PizzaStatus.DELIVERED).size() == 1);
assertTrue(map.get(Pizza.PizzaStatus.ORDERED).size() == 2);
assertTrue(map.get(Pizza.PizzaStatus.READY).size() == 1);
EnumMap<Pizza.PizzaStatusEnum, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
assertTrue(map.get(Pizza.PizzaStatusEnum.DELIVERED).size() == 1);
assertTrue(map.get(Pizza.PizzaStatusEnum.ORDERED).size() == 2);
assertTrue(map.get(Pizza.PizzaStatusEnum.READY).size() == 1);
}
@Test
public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
Pizza pz = new Pizza();
pz.setStatus(Pizza.PizzaStatus.READY);
pz.setStatus(Pizza.PizzaStatusEnum.READY);
pz.deliver();
assertTrue(pz.getStatus() == Pizza.PizzaStatus.DELIVERED);
assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED);
}
}

4
core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java → core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileIntegrationTest.java
View File

@ -23,7 +23,7 @@ import java.util.Scanner;
import org.junit.Test;
public class JavaReadFromFileTest {
public class JavaReadFromFileIntegrationTest {
@Test
public void whenReadWithBufferedReader_thenCorrect() throws IOException {
@ -111,7 +111,7 @@ public class JavaReadFromFileTest {
@Test
public void whenReadUTFEncodedFile_thenCorrect() throws IOException {
final String expected_value = "青空";
final String expected_value = "�空";
final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.in"), "UTF-8"));
final String currentLine = reader.readLine();
reader.close();

2
core-java/src/test/java/org/baeldung/java/io/JavaScannerTest.java → core-java/src/test/java/org/baeldung/java/io/JavaScannerIntegrationTest.java
View File

@ -15,7 +15,7 @@ import java.util.Scanner;
import org.junit.Test;
public class JavaScannerTest {
public class JavaScannerIntegrationTest {
@Test
public void whenReadFileWithScanner_thenCorrect() throws IOException {

2
core-java/src/test/java/org/baeldung/java/io/JavaWriteToFileTest.java → core-java/src/test/java/org/baeldung/java/io/JavaWriteToFileIntegrationTest.java
View File

@ -26,7 +26,7 @@ import java.nio.file.Paths;
import org.junit.Test;
public class JavaWriteToFileTest {
public class JavaWriteToFileIntegrationTest {
private String fileName = "src/test/resources/test_write.txt";
private String fileName1 = "src/test/resources/test_write_1.txt";

6
core-java/src/test/java/org/baeldung/java/lists/ListAssertJTest.java → core-java/src/test/java/org/baeldung/java/lists/ListAssertJUnitTest.java
View File

@ -7,7 +7,7 @@ import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class ListAssertJTest {
public class ListAssertJUnitTest {
private final List<String> list1 = Arrays.asList("1", "2", "3", "4");
private final List<String> list2 = Arrays.asList("1", "2", "3", "4");
@ -15,9 +15,7 @@ public class ListAssertJTest {
@Test
public void whenTestingForEquality_ShouldBeEqual() throws Exception {
assertThat(list1)
.isEqualTo(list2)
.isNotEqualTo(list3);
assertThat(list1).isEqualTo(list2).isNotEqualTo(list3);
assertThat(list1.equals(list2)).isTrue();
assertThat(list1.equals(list3)).isFalse();

2
core-java/src/test/java/org/baeldung/java/lists/ListTestNGTest.java → core-java/src/test/java/org/baeldung/java/lists/ListTestNgUnitTest.java
View File

@ -6,7 +6,7 @@ import org.testng.annotations.Test;
import java.util.Arrays;
import java.util.List;
public class ListTestNGTest {
public class ListTestNgUnitTest {
private final List<String> list1 = Arrays.asList("1", "2", "3", "4");
private final List<String> list2 = Arrays.asList("1", "2", "3", "4");

57
core-java/src/test/java/org/baeldung/java/md5/JavaMD5Test.java → core-java/src/test/java/org/baeldung/java/md5/JavaMD5UnitTest.java
View File

@ -1,9 +1,10 @@
package org.baeldung.java.md5;
import static org.junit.Assert.*;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
@ -11,80 +12,64 @@ import java.security.NoSuchAlgorithmException;
import javax.xml.bind.DatatypeConverter;
import org.apache.commons.codec.digest.DigestUtils;
import org.junit.Before;
import org.junit.Test;
import com.google.common.hash.HashCode;
import com.google.common.hash.Hashing;
import java.io.File;
import java.io.IOException;
import java.nio.*;
import static org.assertj.core.api.Assertions.assertThat;
public class JavaMD5UnitTest {
public class JavaMD5Test {
String filename = "src/test/resources/test_md5.txt";
String checksum = "5EB63BBBE01EEED093CB22BB8F5ACDC3";
String hash = "35454B055CC325EA1AF2126E27707052";
String password = "ILoveJava";
@Test
public void givenPassword_whenHashing_thenVerifying() throws NoSuchAlgorithmException {
String hash = "35454B055CC325EA1AF2126E27707052";
String password = "ILoveJava";
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(password.getBytes());
byte[] digest = md.digest();
String myHash = DatatypeConverter.printHexBinary(digest).toUpperCase();
assertThat(myHash.equals(hash)).isTrue();
}
@Test
public void givenFile_generatingChecksum_thenVerifying() throws NoSuchAlgorithmException, IOException {
String filename = "src/test/resources/test_md5.txt";
String checksum = "5EB63BBBE01EEED093CB22BB8F5ACDC3";
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(Files.readAllBytes(Paths.get(filename)));
byte[] digest = md.digest();
String myChecksum = DatatypeConverter
.printHexBinary(digest).toUpperCase();
String myChecksum = DatatypeConverter.printHexBinary(digest).toUpperCase();
assertThat(myChecksum.equals(checksum)).isTrue();
}
@Test
public void givenPassword_whenHashingUsingCommons_thenVerifying() {
public void givenPassword_whenHashingUsingCommons_thenVerifying() {
String hash = "35454B055CC325EA1AF2126E27707052";
String password = "ILoveJava";
String md5Hex = DigestUtils
.md5Hex(password).toUpperCase();
String md5Hex = DigestUtils.md5Hex(password).toUpperCase();
assertThat(md5Hex.equals(hash)).isTrue();
}
@Test
public void givenFile_whenChecksumUsingGuava_thenVerifying() throws IOException {
String filename = "src/test/resources/test_md5.txt";
String checksum = "5EB63BBBE01EEED093CB22BB8F5ACDC3";
HashCode hash = com.google.common.io.Files
.hash(new File(filename), Hashing.md5());
String myChecksum = hash.toString()
.toUpperCase();
HashCode hash = com.google.common.io.Files.hash(new File(filename), Hashing.md5());
String myChecksum = hash.toString().toUpperCase();
assertThat(myChecksum.equals(checksum)).isTrue();
}
}

2
core-java/src/test/java/org/baeldung/java/sandbox/SandboxJavaTest.java → core-java/src/test/java/org/baeldung/java/sandbox/SandboxJavaUnitTest.java
View File

@ -6,7 +6,7 @@ import java.util.TimerTask;
import org.junit.Test;
public class SandboxJavaTest {
public class SandboxJavaUnitTest {
@Test
public void givenUsingTimer_whenSchedulingTimerTaskOnce_thenCorrect() throws InterruptedException {