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

Merge branch 'master' into BAEL-1689

Browse Source
This commit is contained in:
Loredana Crusoveanu
2018-06-14 11:43:08 +03:00
committed by GitHub
parent 9fd6025127 ff9d4d48f3
commit 6e2feb7f9b
285 changed files with 4675 additions and 732 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
-2
View File
@@ -40,5 +40,3 @@ This tutorials project is being built **[>> HERE](https://rest-security.ci.cloud
- [Apache Maven Standard Directory Layout](http://www.baeldung.com/maven-directory-structure)
- [Apache Maven Tutorial](http://www.baeldung.com/maven)
- [Designing a User Friendly Java Library](http://www.baeldung.com/design-a-user-friendly-java-library)
- [Java Service Provider Interface](http://www.baeldung.com/java-spi)
- [Java Streams vs Vavr Streams](http://www.baeldung.com/vavr-java-streams)
algorithms/src/main/java/com/baeldung/algorithms/mcts/tictactoe/Board.java
+1 -1
View File
@@ -148,7 +148,7 @@ public class Board {
System.out.println("Game Draw");
break;
case IN_PROGRESS:
System.out.println("Game In rogress");
System.out.println("Game In Progress");
break;
}
}
algorithms/src/test/java/com/baeldung/algorithms/analysis/AnalysisRunnerLiveTest.java
+139
View File
@@ -0,0 +1,139 @@
package com.baeldung.algorithms.analysis;
import org.junit.Test;
public class AnalysisRunnerLiveTest {
int n = 10;
int total = 0;
@Test
public void whenConstantComplexity_thenConstantRuntime() {
System.out.println("**** n = " + n + " ****");
System.out.println();
// Constant Time
System.out.println("**** Constant time ****");
System.out.println("Hey - your input is: " + n);
System.out.println("Running time not dependent on input size!");
System.out.println();
}
@Test
public void whenLogarithmicComplexity_thenLogarithmicRuntime() {
// Logarithmic Time
System.out.println("**** Logarithmic Time ****");
for (int i = 1; i < n; i = i * 2) {
// System.out.println("Hey - I'm busy looking at: " + i);
total++;
}
System.out.println("Total amount of times run: " + total);
System.out.println();
}
@Test
public void whenLinearComplexity_thenLinearRuntime() {
// Linear Time
System.out.println("**** Linear Time ****");
for (int i = 0; i < n; i++) {
// System.out.println("Hey - I'm busy looking at: " + i);
total++;
}
System.out.println("Total amount of times run: " + total);
System.out.println();
}
@Test
public void whenNLogNComplexity_thenNLogNRuntime() {
// N Log N Time
System.out.println("**** nlogn Time ****");
total = 0;
for (
int i = 1; i <= n; i++) {
for (int j = 1; j < n; j = j * 2) {
// System.out.println("Hey - I'm busy looking at: " + i + " and " + j);
total++;
}
}
System.out.println("Total amount of times run: " + total);
System.out.println();
}
@Test
public void whenQuadraticComplexity_thenQuadraticRuntime() {
// Quadratic Time
System.out.println("**** Quadratic Time ****");
total = 0;
for (
int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
// System.out.println("Hey - I'm busy looking at: " + i + " and " + j);
total++;
}
}
System.out.println("Total amount of times run: " + total);
System.out.println();
}
@Test
public void whenCubicComplexity_thenCubicRuntime() {
// Cubic Time
System.out.println("**** Cubic Time ****");
total = 0;
for (
int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
// System.out.println("Hey - I'm busy looking at: " + i + " and " + j + " and " + k);
total++;
}
}
}
System.out.println("Total amount of times run: " + total);
System.out.println();
}
@Test
public void whenExponentialComplexity_thenExponentialRuntime() {
// Exponential Time
System.out.println("**** Exponential Time ****");
total = 0;
for (
int i = 1; i <= Math.pow(2, n); i++) {
// System.out.println("Hey - I'm busy looking at: " + i);
total++;
}
System.out.println("Total amount of times run: " + total);
System.out.println();
}
@Test
public void whenFactorialComplexity_thenFactorialRuntime() {
// Factorial Time
System.out.println("**** Factorial Time ****");
total = 0;
for (
int i = 1; i <=
factorial(n); i++) {
// System.out.println("Hey - I'm busy looking at: " + i);
total++;
}
System.out.println("Total amount of times run: " + total);
}
static int factorial(int n) {
if (n == 0 || n == 1)
return 1;
else
return n * factorial(n - 1);
}
}
animal-sniffer-mvn-plugin/pom.xml
+1 -1
View File
@@ -5,7 +5,7 @@
<artifactId>animal-sniffer-mvn-plugin</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>example-animal-sniffer-mvn-plugin</name>
<name>animal-sniffer-mvn-plugin</name>
<url>http://maven.apache.org</url>
<parent>
apache-poi/src/test/java/com/baeldung/poi/powerpoint/PowerPointIntegrationTest.java
+9 -4
View File
@@ -1,25 +1,30 @@
package com.baeldung.poi.powerpoint;
import java.io.File;
import java.util.List;
import org.apache.poi.xslf.usermodel.XMLSlideShow;
import org.apache.poi.xslf.usermodel.XSLFShape;
import org.apache.poi.xslf.usermodel.XSLFSlide;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import java.io.File;
import java.util.List;
import org.junit.rules.TemporaryFolder;
public class PowerPointIntegrationTest {
private PowerPointHelper pph;
private String fileLocation;
private static final String FILE_NAME = "presentation.pptx";
@Rule
public TemporaryFolder tempFolder = new TemporaryFolder();
@Before
public void setUp() throws Exception {
File currDir = new File(".");
File currDir = tempFolder.newFolder();
String path = currDir.getAbsolutePath();
fileLocation = path.substring(0, path.length() - 1) + FILE_NAME;
camel-api/pom.xml
-1
View File
@@ -5,7 +5,6 @@
<groupId>com.example</groupId>
<artifactId>spring-boot-camel</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Spring-Boot - Camel API</name>
<parent>
<groupId>com.baeldung</groupId>
core-java-8/README.md
+1 -1
View File
@@ -52,4 +52,4 @@
- [Measure Elapsed Time in Java](http://www.baeldung.com/java-measure-elapsed-time)
- [Java Optional – orElse() vs orElseGet()](http://www.baeldung.com/java-optional-or-else-vs-or-else-get)
- [An Introduction to Java.util.Hashtable Class](http://www.baeldung.com/java-hash-table)
- [Method Parameter Reflection in Java](http://www.baeldung.com/java-parameter-reflection)
core-java-8/src/test/java/com/baeldung/java8/UnsignedArithmeticUnitTest.java
+60
View File
@@ -0,0 +1,60 @@
package com.baeldung.java8;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;
import static org.junit.Assert.assertEquals;
public class UnsignedArithmeticUnitTest {
@Test
public void whenDoublingALargeByteNumber_thenOverflow() {
byte b1 = 100;
byte b2 = (byte) (b1 << 1);
assertEquals(-56, b2);
}
@Test
public void whenComparingNumbers_thenNegativeIsInterpretedAsUnsigned() {
int positive = Integer.MAX_VALUE;
int negative = Integer.MIN_VALUE;
int signedComparison = Integer.compare(positive, negative);
assertEquals(1, signedComparison);
int unsignedComparison = Integer.compareUnsigned(positive, negative);
assertEquals(-1, unsignedComparison);
assertEquals(negative, positive + 1);
}
@Test
public void whenDividingNumbers_thenNegativeIsInterpretedAsUnsigned() {
int positive = Integer.MAX_VALUE;
int negative = Integer.MIN_VALUE;
assertEquals(-1, negative / positive);
assertEquals(1, Integer.divideUnsigned(negative, positive));
assertEquals(-1, negative % positive);
assertEquals(1, Integer.divideUnsigned(negative, positive));
}
@Test
public void whenParsingNumbers_thenNegativeIsInterpretedAsUnsigned() {
Throwable thrown = catchThrowable(() -> Integer.parseInt("2147483648"));
assertThat(thrown).isInstanceOf(NumberFormatException.class);
assertEquals(Integer.MAX_VALUE + 1, Integer.parseUnsignedInt("2147483648"));
}
@Test
public void whenFormattingNumbers_thenNegativeIsInterpretedAsUnsigned() {
String signedString = Integer.toString(Integer.MIN_VALUE);
assertEquals("-2147483648", signedString);
String unsignedString = Integer.toUnsignedString(Integer.MIN_VALUE);
assertEquals("2147483648", unsignedString);
}
}
core-java-8/src/test/java/com/baeldung/typeinference/TypeInferenceUnitTest.java
+87
View File
@@ -0,0 +1,87 @@
package com.baeldung.typeinference;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
public class TypeInferenceUnitTest {
@Test
public void givenNoTypeInference_whenInvokingGenericMethodsWithTypeParameters_ObjectsAreCreated() {
// Without type inference. code is verbose.
Map<String, Map<String, String>> mapOfMaps = new HashMap<String, Map<String, String>>();
List<String> strList = Collections.<String> emptyList();
List<Integer> intList = Collections.<Integer> emptyList();
assertTrue(mapOfMaps.isEmpty());
assertTrue(strList.isEmpty());
assertTrue(intList.isEmpty());
}
@Test
public void givenTypeInference_whenInvokingGenericMethodsWithoutTypeParameters_ObjectsAreCreated() {
// With type inference. code is concise.
List<String> strListInferred = Collections.emptyList();
List<Integer> intListInferred = Collections.emptyList();
assertTrue(strListInferred.isEmpty());
assertTrue(intListInferred.isEmpty());
}
@Test
public void givenJava7_whenInvokingCostructorWithoutTypeParameters_ObjectsAreCreated() {
// Type Inference for constructor using diamond operator.
Map<String, Map<String, String>> mapOfMapsInferred = new HashMap<>();
assertTrue(mapOfMapsInferred.isEmpty());
assertEquals("public class java.util.HashMap<K,V>", mapOfMapsInferred.getClass()
.toGenericString());
}
static <T> List<T> add(List<T> list, T a, T b) {
list.add(a);
list.add(b);
return list;
}
@Test
public void givenGenericMethod_WhenInvokedWithoutExplicitTypes_TypesAreInferred() {
// Generalized target-type inference
List<String> strListGeneralized = add(new ArrayList<>(), "abc", "def");
List<Integer> intListGeneralized = add(new ArrayList<>(), 1, 2);
List<Number> numListGeneralized = add(new ArrayList<>(), 1, 2.0);
assertEquals("public class java.util.ArrayList<E>", strListGeneralized.getClass()
.toGenericString());
assertFalse(intListGeneralized.isEmpty());
assertEquals(2, numListGeneralized.size());
}
@Test
public void givenLambdaExpressions_whenParameterTypesNotSpecified_ParameterTypesAreInferred() {
// Type Inference and Lambda Expressions.
List<Integer> intList = Arrays.asList(5, 3, 4, 2, 1);
Collections.sort(intList, (a, b) -> {
assertEquals("java.lang.Integer", a.getClass().getName());
return a.compareTo(b);
});
assertEquals("[1, 2, 3, 4, 5]", Arrays.toString(intList.toArray()));
List<String> strList = Arrays.asList("Red", "Blue", "Green");
Collections.sort(strList, (a, b) -> {
assertEquals("java.lang.String", a.getClass().getName());
return a.compareTo(b);
});
assertEquals("[Blue, Green, Red]", Arrays.toString(strList.toArray()));
}
}
core-java-9/README.md
+1
View File
@@ -25,3 +25,4 @@
- [Introduction to Chronicle Queue](http://www.baeldung.com/java-chronicle-queue)
- [A Guide to Java 9 Modularity](http://www.baeldung.com/java-9-modularity)
- [Optional orElse Optional](http://www.baeldung.com/java-optional-or-else-optional)
- [Java 9 java.lang.Module API](http://www.baeldung.com/java-9-module-api)
core-java-io/src/test/java/org/baeldung/java/io/JavaReadFromFileUnitTest.java
+2
View File
@@ -1,6 +1,7 @@
package org.baeldung.java.io;
import org.junit.Test;
import org.junit.Ignore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -105,6 +106,7 @@ public class JavaReadFromFileUnitTest {
}
@Test
@Ignore // TODO
public void whenReadUTFEncodedFile_thenCorrect() throws IOException {
final String expected_value = "青空";
final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.in"), "UTF-8"));
core-java/README.md
+11 -2
View File
@@ -141,6 +141,7 @@
- [Java KeyStore API](http://www.baeldung.com/java-keystore)
- [Double-Checked Locking with Singleton](http://www.baeldung.com/java-singleton-double-checked-locking)
- [Guide to Java Clock Class](http://www.baeldung.com/java-clock)
- [Infinite Loops in Java](http://www.baeldung.com/infinite-loops-java)
- [Using Java Assertions](http://www.baeldung.com/java-assert)
- [Pass-By-Value as a Parameter Passing Mechanism in Java](http://www.baeldung.com/java-pass-by-value-or-pass-by-reference)
- [Check If a String Is Numeric in Java](http://www.baeldung.com/java-check-string-number)
@@ -149,5 +150,13 @@
- [NaN in Java](http://www.baeldung.com/java-not-a-number)
- [Infinite Loops in Java](http://www.baeldung.com/infinite-loops-java)
- [Why Use char[] Array Over a String for Storing Passwords in Java?](http://www.baeldung.com/java-storing-passwords)
- [Introduction to Creational Design Patterns](http://www.baeldung.com/creational-design-patterns)
- [Proxy, Decorator, Adapter and Bridge Patterns](http://www.baeldung.com/java-structural-design-patterns)
- [Singletons in Java](http://www.baeldung.com/java-singleton)
- [Flyweight Pattern in Java](http://www.baeldung.com/java-flyweight)
- [The Observer Pattern in Java](http://www.baeldung.com/java-observer-pattern)
- [Service Locator Pattern](http://www.baeldung.com/java-service-locator-pattern)
- [The Thread.join() Method in Java](http://www.baeldung.com/java-thread-join)
- [Guide to the super Java Keyword](http://www.baeldung.com/java-super)
- [Guide to the this Java Keyword](http://www.baeldung.com/java-this)
- [Jagged Arrays In Java](http://www.baeldung.com/java-jagged-arrays)
core-java/src/main/java/com/baeldung/linkedlist/LinkedList.java
-58
View File
@@ -1,58 +0,0 @@
package com.baeldung.linkedlist;
/**
* Implementation of a singly linked list.
*/
public class LinkedList {
private Node head;
private Node tail;
public Node head() {
return head;
}
public void add(String data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
tail = newNode;
}
}
public static class Node {
private Node next;
private String data;
public Node(String data) {
this.data = data;
}
public String data() {
return data;
}
public void setData(String data) {
this.data = data;
}
public boolean hasNext() {
return next != null;
}
public Node next() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public String toString() {
return this.data;
}
}
}
core-java/src/main/java/com/baeldung/linkedlist/MiddleElementLookup.java
+21 -10
View File
@@ -1,12 +1,23 @@
package com.baeldung.linkedlist;
import com.baeldung.linkedlist.LinkedList.Node;
import java.util.LinkedList;
import java.util.Optional;
import com.baeldung.linkedlist.Node;
public class MiddleElementLookup {
public static String findMiddleElement(Node head) {
public static Optional<String> findMiddleElementLinkedList(LinkedList<String> linkedList) {
if (linkedList == null || linkedList.isEmpty()) {
return Optional.empty();
}
return Optional.ofNullable(linkedList.get((linkedList.size() - 1) / 2));
}
public static Optional<String> findMiddleElementFromHead(Node head) {
if (head == null) {
return null;
return Optional.empty();
}
// calculate the size of the list
@@ -23,17 +34,17 @@ public class MiddleElementLookup {
current = current.next();
}
return current.data();
return Optional.ofNullable(current.data());
}
public static String findMiddleElement1PassRecursively(Node head) {
public static Optional<String> findMiddleElementFromHead1PassRecursively(Node head) {
if (head == null) {
return null;
return Optional.empty();
}
MiddleAuxRecursion middleAux = new MiddleAuxRecursion();
findMiddleRecursively(head, middleAux);
return middleAux.middle.data();
return Optional.ofNullable(middleAux.middle.data());
}
private static void findMiddleRecursively(Node node, MiddleAuxRecursion middleAux) {
@@ -53,9 +64,9 @@ public class MiddleElementLookup {
middleAux.length--;
}
public static String findMiddleElement1PassIteratively(Node head) {
public static Optional<String> findMiddleElementFromHead1PassIteratively(Node head) {
if (head == null) {
return null;
return Optional.empty();
}
Node slowPointer = head;
@@ -68,7 +79,7 @@ public class MiddleElementLookup {
slowPointer = slowPointer.next();
}
return slowPointer.data();
return Optional.ofNullable(slowPointer.data());
}
private static class MiddleAuxRecursion {
core-java/src/main/java/com/baeldung/linkedlist/Node.java
+34
View File
@@ -0,0 +1,34 @@
package com.baeldung.linkedlist;
public class Node {
private Node next;
private String data;
public Node(String data) {
this.data = data;
}
public String data() {
return data;
}
public void setData(String data) {
this.data = data;
}
public boolean hasNext() {
return next != null;
}
public Node next() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public String toString() {
return this.data;
}
}
core-java/src/test/java/com/baeldung/array/JaggedArrayUnitTest.java
+1 -1
View File
@@ -46,7 +46,7 @@ public class JaggedArrayUnitTest {
ByteArrayOutputStream outContent = new ByteArrayOutputStream();
System.setOut(new PrintStream(outContent));
obj.printElements(jaggedArr);
assertEquals("[1, 2]\n[3, 4, 5]\n[6, 7, 8, 9]\n", outContent.toString());
assertEquals("[1, 2][3, 4, 5][6, 7, 8, 9]", outContent.toString().replace("\r", "").replace("\n", ""));
System.setOut(System.out);
}
core-java/src/test/java/com/baeldung/arrays/ArraysUnitTest.java
+153
View File
@@ -0,0 +1,153 @@
package com.baeldung.arrays;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class ArraysUnitTest {
private String[] intro;
@Rule
public final ExpectedException exception = ExpectedException.none();
@Before
public void setup() {
intro = new String[] { "once", "upon", "a", "time" };
}
@Test
public void whenCopyOfRange_thenAbridgedArray() {
String[] abridgement = Arrays.copyOfRange(intro, 0, 3);
assertArrayEquals(new String[] { "once", "upon", "a" }, abridgement);
assertFalse(Arrays.equals(intro, abridgement));
}
@Test
public void whenCopyOf_thenNullElement() {
String[] revised = Arrays.copyOf(intro, 3);
String[] expanded = Arrays.copyOf(intro, 5);
assertArrayEquals(Arrays.copyOfRange(intro, 0, 3), revised);
assertNull(expanded[4]);
}
@Test
public void whenFill_thenAllMatch() {
String[] stutter = new String[3];
Arrays.fill(stutter, "once");
assertTrue(Stream.of(stutter).allMatch(el -> "once".equals(el)));
}
@Test
public void whenEqualsContent_thenMatch() {
assertTrue(Arrays.equals(new String[] { "once", "upon", "a", "time" }, intro));
assertFalse(Arrays.equals(new String[] { "once", "upon", "a", null }, intro));
}
@Test
public void whenNestedArrays_thenDeepEqualsPass() {
String[] end = { "the", "end" };
Object[] story = new Object[] { intro, new String[] { "chapter one", "chapter two" }, end };
Object[] copy = new Object[] { intro, new String[] { "chapter one", "chapter two" }, end };
assertTrue(Arrays.deepEquals(story, copy));
assertFalse(Arrays.equals(story, copy));
}
@Test
public void whenSort_thenArraySorted() {
String[] sorted = Arrays.copyOf(intro, 4);
Arrays.sort(sorted);
assertArrayEquals(new String[] { "a", "once", "time", "upon" }, sorted);
}
@Test
public void whenBinarySearch_thenFindElements() {
String[] sorted = Arrays.copyOf(intro, 4);
Arrays.sort(sorted);
int exact = Arrays.binarySearch(sorted, "time");
int caseInsensitive = Arrays.binarySearch(sorted, "TiMe", String::compareToIgnoreCase);
assertEquals("time", sorted[exact]);
assertEquals(2, exact);
assertEquals(exact, caseInsensitive);
}
@Test
public void whenNullElement_thenArraysHashCodeNotEqual() {
int beforeChange = Arrays.hashCode(intro);
int before = intro.hashCode();
intro[3] = null;
int after = intro.hashCode();
int afterChange = Arrays.hashCode(intro);
assertNotEquals(beforeChange, afterChange);
assertEquals(before, after);
}
@Test
public void whenNestedArrayNullElement_thenEqualsFailDeepHashPass() {
Object[] looping = new Object[] { intro, intro };
int deepHashBefore = Arrays.deepHashCode(looping);
int hashBefore = Arrays.hashCode(looping);
intro[3] = null;
int hashAfter = Arrays.hashCode(looping);
int deepHashAfter = Arrays.deepHashCode(looping);
assertEquals(hashAfter, hashBefore);
assertNotEquals(deepHashAfter, deepHashBefore);
}
@Test
public void whenStreamBadIndex_thenException() {
assertEquals(Arrays.stream(intro).count(), 4);
exception.expect(ArrayIndexOutOfBoundsException.class);
Arrays.stream(intro, 2, 1).count();
}
@Test
public void whenSetAllToUpper_thenAppliedToAllElements() {
String[] longAgo = new String[4];
Arrays.setAll(longAgo, i -> intro[i].toUpperCase());
assertArrayEquals(longAgo, new String[] { "ONCE", "UPON", "A", "TIME" });
}
@Test
public void whenToString_thenFormattedArrayString() {
assertEquals("[once, upon, a, time]", Arrays.toString(intro));
}
@Test
public void whenNestedArrayDeepString_thenFormattedArraysString() {
String[] end = { "the", "end" };
Object[] story = new Object[] { intro, new String[] { "chapter one", "chapter two" }, end };
assertEquals("[[once, upon, a, time], [chapter one, chapter two], [the, end]]", Arrays.deepToString(story));
}
@Test
public void whenAsList_thenImmutableArray() {
List<String> rets = Arrays.asList(intro);
assertTrue(rets.contains("upon"));
assertTrue(rets.contains("time"));
assertEquals(rets.size(), 4);
exception.expect(UnsupportedOperationException.class);
rets.add("the");
}
}
core-java/src/test/java/com/baeldung/linkedlist/MiddleElementLookupUnitTest.java
+87 -29
View File
@@ -1,52 +1,97 @@
package com.baeldung.linkedlist;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import java.util.LinkedList;
import org.junit.Test;
public class MiddleElementLookupUnitTest {
@Test
public void whenFindingMiddle_thenMiddleFound() {
String middle = MiddleElementLookup.findMiddleElement(createList(5).head());
assertEquals("3", middle);
middle = MiddleElementLookup.findMiddleElement(createList(4).head());
assertEquals("2", middle);
public void whenFindingMiddleLinkedList_thenMiddleFound() {
assertEquals("3", MiddleElementLookup
.findMiddleElementLinkedList(createLinkedList(5))
.get());
assertEquals("2", MiddleElementLookup
.findMiddleElementLinkedList(createLinkedList(4))
.get());
}
@Test
public void whenFindingMiddle1PassRecursively_thenMiddleFound() {
String middle = MiddleElementLookup.findMiddleElement1PassRecursively(createList(5).head());
assertEquals("3", middle);
middle = MiddleElementLookup.findMiddleElement1PassRecursively(createList(4).head());
assertEquals("2", middle);
public void whenFindingMiddleFromHead_thenMiddleFound() {
assertEquals("3", MiddleElementLookup
.findMiddleElementFromHead(createNodesList(5))
.get());
assertEquals("2", MiddleElementLookup
.findMiddleElementFromHead(createNodesList(4))
.get());
}
@Test
public void whenFindingMiddle1PassIteratively_thenMiddleFound() {
String middle = MiddleElementLookup.findMiddleElement1PassIteratively(createList(5).head());
assertEquals("3", middle);
middle = MiddleElementLookup.findMiddleElement1PassIteratively(createList(4).head());
assertEquals("2", middle);
public void whenFindingMiddleFromHead1PassRecursively_thenMiddleFound() {
assertEquals("3", MiddleElementLookup
.findMiddleElementFromHead1PassRecursively(createNodesList(5))
.get());
assertEquals("2", MiddleElementLookup
.findMiddleElementFromHead1PassRecursively(createNodesList(4))
.get());
}
@Test
public void whenListEmptyOrNull_thenMiddleNull() {
String middle = MiddleElementLookup.findMiddleElement(null);
assertEquals(null, middle);
middle = MiddleElementLookup.findMiddleElement1PassIteratively(null);
assertEquals(null, middle);
middle = MiddleElementLookup.findMiddleElement1PassRecursively(null);
assertEquals(null, middle);
public void whenFindingMiddleFromHead1PassIteratively_thenMiddleFound() {
assertEquals("3", MiddleElementLookup
.findMiddleElementFromHead1PassIteratively(createNodesList(5))
.get());
assertEquals("2", MiddleElementLookup
.findMiddleElementFromHead1PassIteratively(createNodesList(4))
.get());
}
private static LinkedList createList(int n) {
LinkedList list = new LinkedList();
@Test
public void whenListEmptyOrNull_thenMiddleNotFound() {
// null list
assertFalse(MiddleElementLookup
.findMiddleElementLinkedList(null)
.isPresent());
assertFalse(MiddleElementLookup
.findMiddleElementFromHead(null)
.isPresent());
assertFalse(MiddleElementLookup
.findMiddleElementFromHead1PassIteratively(null)
.isPresent());
assertFalse(MiddleElementLookup
.findMiddleElementFromHead1PassRecursively(null)
.isPresent());
// empty LinkedList
assertFalse(MiddleElementLookup
.findMiddleElementLinkedList(new LinkedList<>())
.isPresent());
// LinkedList with nulls
LinkedList<String> nullsList = new LinkedList<>();
nullsList.add(null);
nullsList.add(null);
assertFalse(MiddleElementLookup
.findMiddleElementLinkedList(nullsList)
.isPresent());
// nodes with null values
assertFalse(MiddleElementLookup
.findMiddleElementFromHead(new Node(null))
.isPresent());
assertFalse(MiddleElementLookup
.findMiddleElementFromHead1PassIteratively(new Node(null))
.isPresent());
assertFalse(MiddleElementLookup
.findMiddleElementFromHead1PassRecursively(new Node(null))
.isPresent());
}
private static LinkedList<String> createLinkedList(int n) {
LinkedList<String> list = new LinkedList<>();
for (int i = 1; i <= n; i++) {
list.add(String.valueOf(i));
@@ -55,4 +100,17 @@ public class MiddleElementLookupUnitTest {
return list;
}
private static Node createNodesList(int n) {
Node head = new Node("1");
Node current = head;
for (int i = 2; i <= n; i++) {
Node newNode = new Node(String.valueOf(i));
current.setNext(newNode);
current = newNode;
}
return head;
}
}
core-java/src/test/java/com/baeldung/money/JavaMoneyUnitManualTest.java
+1 -1
View File
@@ -179,7 +179,7 @@ public class JavaMoneyUnitManualTest {
MonetaryAmountFormat customFormat = MonetaryFormats.getAmountFormat(AmountFormatQueryBuilder
.of(Locale.US)
.set(CurrencyStyle.NAME)
.set("pattern", "00000.00 �")
.set("pattern", "00000.00 US Dollar")
.build());
String customFormatted = customFormat.format(oneDollar);
core-java/src/test/java/com/baeldung/scripting/NashornUnitTest.java
+1 -1
View File
@@ -104,7 +104,7 @@ public class NashornUnitTest {
public void loadExamples() throws ScriptException {
Object loadResult = engine.eval("load('classpath:js/script.js');" + "increment(5)");
Assert.assertEquals(6.0, loadResult);
Assert.assertEquals(6, ((Double) loadResult).intValue());
Object math = engine.eval("var math = loadWithNewGlobal('classpath:js/math_module.js');" + "math.increment(5);");
core-kotlin/src/main/kotlin/com/baeldung/enums/CardType.kt
+11 -21
View File
@@ -2,32 +2,22 @@ package com.baeldung.enums
enum class CardType(val color: String) : ICardLimit {
SILVER("gray") {
override fun getCreditLimit(): Int {
return 100000
}
override fun calculateCashbackPercent(): Float {
return 0.25f
}
override fun getCreditLimit() = 100000
override fun calculateCashbackPercent() = 0.25f
},
GOLD("yellow") {
override fun getCreditLimit(): Int {
return 200000
}
override fun calculateCashbackPercent(): Float {
return 0.5f
}
override fun getCreditLimit() = 200000
override fun calculateCashbackPercent(): Float = 0.5f
},
PLATINUM("black") {
override fun getCreditLimit(): Int {
return 300000
}
override fun calculateCashbackPercent(): Float {
return 0.75f
}
override fun getCreditLimit() = 300000
override fun calculateCashbackPercent() = 0.75f
};
companion object {
fun getCardTypeByColor(color: String) = values().firstOrNull { it.color == color }
fun getCardTypeByName(name: String) = valueOf(name.toUpperCase())
}
abstract fun calculateCashbackPercent(): Float
}
core-kotlin/src/main/kotlin/com/baeldung/enums/CardTypeHelper.kt
-16
View File
@@ -1,16 +0,0 @@
package com.baeldung.enums
class CardTypeHelper {
fun getCardTypeByColor(color: String): CardType? {
for (cardType in CardType.values()) {
if (cardType.color.equals(color)) {
return cardType;
}
}
return null
}
fun getCardTypeByName(name: String): CardType {
return CardType.valueOf(name.toUpperCase())
}
}
core-kotlin/src/test/kotlin/com/baeldung/enums/CardTypeHelperUnitTest.kt
-43
View File
@@ -1,43 +0,0 @@
package com.baeldung.enums
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
internal class CardTypeHelperUnitTest {
@Test
fun whenGetCardTypeByColor_thenSilverCardType() {
val cardTypeHelper = CardTypeHelper()
Assertions.assertEquals(CardType.SILVER, cardTypeHelper.getCardTypeByColor("gray"))
}
@Test
fun whenGetCardTypeByColor_thenGoldCardType() {
val cardTypeHelper = CardTypeHelper()
Assertions.assertEquals(CardType.GOLD, cardTypeHelper.getCardTypeByColor("yellow"))
}
@Test
fun whenGetCardTypeByColor_thenPlatinumCardType() {
val cardTypeHelper = CardTypeHelper()
Assertions.assertEquals(CardType.PLATINUM, cardTypeHelper.getCardTypeByColor("black"))
}
@Test
fun whenGetCardTypeByName_thenSilverCardType() {
val cardTypeHelper = CardTypeHelper()
Assertions.assertEquals(CardType.SILVER, cardTypeHelper.getCardTypeByName("silver"))
}
@Test
fun whenGetCardTypeByName_thenGoldCardType() {
val cardTypeHelper = CardTypeHelper()
Assertions.assertEquals(CardType.GOLD, cardTypeHelper.getCardTypeByName("gold"))
}
@Test
fun whenGetCardTypeByName_thenPlatinumCardType() {
val cardTypeHelper = CardTypeHelper()
Assertions.assertEquals(CardType.PLATINUM, cardTypeHelper.getCardTypeByName("platinum"))
}
}
core-kotlin/src/test/kotlin/com/baeldung/enums/CardTypeUnitTest.kt
+32
View File
@@ -1,5 +1,6 @@
package com.baeldung.enums
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
@@ -49,4 +50,35 @@ internal class CardTypeUnitTest {
fun givenPlatinumCardType_whenCheckColor_thenReturnColor() {
assertEquals("black", CardType.PLATINUM.color)
}
@Test
fun whenGetCardTypeByColor_thenSilverCardType() {
Assertions.assertEquals(CardType.SILVER, CardType.getCardTypeByColor("gray"))
}
@Test
fun whenGetCardTypeByColor_thenGoldCardType() {
Assertions.assertEquals(CardType.GOLD, CardType.getCardTypeByColor("yellow"))
}
@Test
fun whenGetCardTypeByColor_thenPlatinumCardType() {
Assertions.assertEquals(CardType.PLATINUM, CardType.getCardTypeByColor("black"))
}
@Test
fun whenGetCardTypeByName_thenSilverCardType() {
Assertions.assertEquals(CardType.SILVER, CardType.getCardTypeByName("silver"))
}
@Test
fun whenGetCardTypeByName_thenGoldCardType() {
Assertions.assertEquals(CardType.GOLD, CardType.getCardTypeByName("gold"))
}
@Test
fun whenGetCardTypeByName_thenPlatinumCardType() {
Assertions.assertEquals(CardType.PLATINUM, CardType.getCardTypeByName("platinum"))
}
}
couchbase/src/main/java/com/baeldung/couchbase/async/service/ClusterServiceImpl.java
+6
View File
@@ -5,6 +5,7 @@ import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.couchbase.client.java.Bucket;
@@ -18,6 +19,11 @@ public class ClusterServiceImpl implements ClusterService {
private Cluster cluster;
private Map<String, Bucket> buckets = new ConcurrentHashMap<>();
@Autowired
public ClusterServiceImpl(Cluster cluster) {
this.cluster = cluster;
}
@PostConstruct
private void init() {
couchbase/src/main/java/com/baeldung/couchbase/async/service/TutorialBucketService.java
+1
View File
@@ -18,6 +18,7 @@ public class TutorialBucketService extends AbstractBucketService {
@Autowired
public TutorialBucketService(ClusterService clusterService) {
super(clusterService);
openBucket();
}
@Override
couchbase/src/test/java/com/baeldung/couchbase/async/person/PersonCrudServiceIntegrationTestConfig.java
+24
View File
@@ -0,0 +1,24 @@
package com.baeldung.couchbase.async.person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import com.couchbase.client.java.Cluster;
import com.couchbase.client.java.CouchbaseCluster;
import com.couchbase.client.java.env.CouchbaseEnvironment;
import com.couchbase.client.java.env.DefaultCouchbaseEnvironment;
@Configuration
@ComponentScan(basePackages = {"com.baeldung.couchbase.async.service", "com.baeldung.couchbase.n1ql"})
public class PersonCrudServiceIntegrationTestConfig {
@Bean
public Cluster cluster() {
CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder()
.connectTimeout(60000)
.build();
return CouchbaseCluster.create(env, "127.0.0.1");
}
}
couchbase/src/test/java/com/baeldung/couchbase/async/person/PersonCrudServiceIntegrationTest.java → couchbase/src/test/java/com/baeldung/couchbase/async/person/PersonCrudServiceLiveTest.java
+13 -9
View File
@@ -1,27 +1,31 @@
package com.baeldung.couchbase.async.person;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.annotation.PostConstruct;
import org.apache.commons.lang3.RandomStringUtils;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.baeldung.couchbase.async.AsyncIntegrationTest;
import com.baeldung.couchbase.async.person.Person;
import com.baeldung.couchbase.async.person.PersonCrudService;
import com.baeldung.couchbase.async.person.PersonDocumentConverter;
import com.baeldung.couchbase.async.service.BucketService;
import com.couchbase.client.java.Bucket;
import com.couchbase.client.java.document.JsonDocument;
public class PersonCrudServiceIntegrationTest extends AsyncIntegrationTest {
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {PersonCrudServiceIntegrationTestConfig.class})
public class PersonCrudServiceLiveTest extends AsyncIntegrationTest {
@Autowired
private PersonCrudService personService;
@@ -35,8 +39,8 @@ public class PersonCrudServiceIntegrationTest extends AsyncIntegrationTest {
private Bucket bucket;
@PostConstruct
private void init() {
@Before
public void init() {
bucket = bucketService.getBucket();
}
couchbase/src/test/java/com/baeldung/couchbase/async/service/ClusterServiceIntegrationTest.java → couchbase/src/test/java/com/baeldung/couchbase/async/service/ClusterServiceLiveTest.java
+1 -1
View File
@@ -18,7 +18,7 @@ import com.couchbase.client.java.Bucket;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { AsyncIntegrationTestConfig.class })
@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class })
public class ClusterServiceIntegrationTest extends AsyncIntegrationTest {
public class ClusterServiceLiveTest extends AsyncIntegrationTest {
@Autowired
private ClusterService couchbaseService;
couchbase/src/test/java/com/baeldung/couchbase/mapreduce/StudentGradeServiceIntegrationTest.java → couchbase/src/test/java/com/baeldung/couchbase/mapreduce/StudentGradeServiceLiveTest.java
+2 -2
View File
@@ -14,8 +14,8 @@ import com.couchbase.client.java.document.JsonDocument;
import com.couchbase.client.java.view.ViewResult;
import com.couchbase.client.java.view.ViewRow;
public class StudentGradeServiceIntegrationTest {
private static final Logger logger = LoggerFactory.getLogger(StudentGradeServiceIntegrationTest.class);
public class StudentGradeServiceLiveTest {
private static final Logger logger = LoggerFactory.getLogger(StudentGradeServiceLiveTest.class);
static StudentGradeService studentGradeService;
static Set<String> gradeIds = new HashSet<>();

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