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

.gitignore

@@ -73,8 +73,6 @@ ninja/devDb.mv.db
 **/out-tsc
 **/nbproject/
 **/nb-configuration.xml
-core-scala/.cache-main
-core-scala/.cache-tests
 
 
 persistence-modules/hibernate5/transaction.log

README.md

@@ -22,10 +22,38 @@ This project is **a collection of small and focused tutorials** - each covering
 A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Security. 
 In additional to Spring, the modules here are covering a number of aspects in Java. 
 
+Profile based segregation
+====================
+
+We are using maven build profiles to segregate the huge list of individual projects we have in our repository.
+
+The projects are broadly divided into 3 list: first, second and heavy. 
+
+Next, they are segregated further on the basis of tests that we want to execute.
+
+Therefore, we have a total of 6 profiles:
+
+| Profile                 | Includes                    | Type of test enabled |
+| ----------------------- | --------------------------- | -------------------- |
+| default-first           | First set of projects       | *UnitTest            |
+| integration-lite-first  | First set of projects       | *IntegrationTest     |
+| default-second          | Second set of projects      | *UnitTest            |
+| integration-lite-second | Second set of projects      | *IntegrationTest     |
+| default-heavy           | Heavy/long running projects | *UnitTest            |
+| integration-heavy       | Heavy/long running projects | *IntegrationTest     |
 
 Building the project
 ====================
-To do the full build, do: `mvn clean install`
+
+Though it should not be needed often to build the entire repository at once because we are usually concerned with a specific module.
+
+But if we want to, we can invoke the below command from the root of the repository if we want to build the entire repository with only Unit Tests enabled:
+
+`mvn clean install -Pdefault-first,default-second,default-heavy`
+
+or if we want to build the entire repository with Integration Tests enabled, we can do:
+
+`mvn clean install -Pintegration-lite-first,integration-lite-second,integration-heavy`
 
 
 Building a single module
@@ -46,8 +74,18 @@ When you're working with an individual module, there's no need to import all of
 
 Running Tests
 =============
-The command `mvn clean install` will run the unit tests in a module.
-To run the integration tests, use the command `mvn clean install -Pintegration-lite-first`
+The command `mvn clean install` from within a module will run the unit tests in that module.
+For Spring modules this will also run the `SpringContextTest` if present.
+
+To run the integration tests, use the command:
+
+`mvn clean install -Pintegration-lite-first` or 
+
+`mvn clean install -Pintegration-lite-second` or 
+
+`mvn clean install -Pintegration-heavy`
+
+depending on the list where our module exists
 
 
 

aws-reactive/pom.xml

@@ -16,12 +16,6 @@
     <name>aws-reactive</name>
     <description>AWS Reactive Sample</description>
 
-    <properties>
-        <java.version>1.8</java.version>
-        <spring.version>2.2.1.RELEASE</spring.version>
-        <awssdk.version>2.10.27</awssdk.version>
-    </properties>
-
     <dependencyManagement>
         <dependencies>
 
@@ -105,4 +99,9 @@
         </plugins>
     </build>
 
+    <properties>
+        <java.version>1.8</java.version>
+        <spring.version>2.2.1.RELEASE</spring.version>
+        <awssdk.version>2.10.27</awssdk.version>
+    </properties>
 </project>

core-java-modules/core-java-concurrency-collections-2/pom.xml

@@ -0,0 +1,47 @@
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung.concurrent.lock</groupId>
+    <artifactId>core-java-concurrency-collections-2</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
+
+    </dependencies>
+    <build>
+        <sourceDirectory>src</sourceDirectory>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.0</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <jmh.version>1.21</jmh.version>
+        <guava.version>28.2-jre</guava.version>
+    </properties>
+
+</project>

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/ConcurrentAccessBenchmark.java

@@ -0,0 +1,54 @@
+package com.baeldung.concurrent.lock;
+
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.Map;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+@State(Scope.Thread)
+@Fork(value = 2)
+@Warmup(iterations = 0)
+public class ConcurrentAccessBenchmark {
+    static final int SLOTS = 4;
+    static final int THREADS = 10000;
+    static final int BUCKETS = Runtime.getRuntime().availableProcessors() * SLOTS;
+    SingleLock singleLock = new SingleLock();
+    StripedLock stripedLock = new StripedLock(BUCKETS);
+
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public Map<String,String> singleLockHashMap() throws InterruptedException {
+        return singleLock.doWork(new HashMap<String,String>(), THREADS, SLOTS);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public Map<String,String> stripedLockHashMap() throws InterruptedException {
+        return stripedLock.doWork(new HashMap<String,String>(), THREADS, SLOTS);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public Map<String,String> singleLockConcurrentHashMap() throws InterruptedException {
+        return singleLock.doWork(new ConcurrentHashMap<String,String>(), THREADS, SLOTS);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.Throughput)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    public Map<String,String> stripedLockConcurrentHashMap() throws InterruptedException {
+        return stripedLock.doWork(new ConcurrentHashMap<String,String>(), THREADS, SLOTS);
+    }
+}

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/ConcurrentAccessExperiment.java

@@ -0,0 +1,26 @@
+package com.baeldung.concurrent.lock;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+import com.google.common.base.Supplier;
+
+public abstract class ConcurrentAccessExperiment {
+
+    public final Map<String,String> doWork(Map<String,String> map, int threads, int slots) {
+        CompletableFuture<?>[] requests = new CompletableFuture<?>[threads * slots];
+
+        for (int i = 0; i < threads; i++) {
+            requests[slots * i + 0] = CompletableFuture.supplyAsync(putSupplier(map, i));
+            requests[slots * i + 1] = CompletableFuture.supplyAsync(getSupplier(map, i));
+            requests[slots * i + 2] = CompletableFuture.supplyAsync(getSupplier(map, i));
+            requests[slots * i + 3] = CompletableFuture.supplyAsync(getSupplier(map, i));
+        }
+        CompletableFuture.allOf(requests).join();
+
+        return map;
+    }
+
+    protected abstract Supplier<?> putSupplier(Map<String,String> map, int key);
+    protected abstract Supplier<?> getSupplier(Map<String,String> map, int key);
+}

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/SingleLock.java

@@ -0,0 +1,36 @@
+package com.baeldung.concurrent.lock;
+
+import java.util.Map;
+import java.util.concurrent.locks.ReentrantLock;
+
+import com.google.common.base.Supplier;
+
+public class SingleLock extends ConcurrentAccessExperiment {
+    ReentrantLock lock;
+
+    public SingleLock() {
+        lock = new ReentrantLock();
+    }
+
+    protected Supplier<?> putSupplier(Map<String,String> map, int key) {
+        return (()-> {
+            lock.lock();
+            try {
+                return map.put("key" + key, "value" + key);
+            } finally {
+                lock.unlock();
+            }
+        });
+    }
+
+    protected Supplier<?> getSupplier(Map<String,String> map, int key) {
+        return (()-> {
+            lock.lock();
+            try {
+                return map.get("key" + key);
+            } finally {
+                lock.unlock();
+            }
+        });
+    }
+}

core-java-modules/core-java-concurrency-collections-2/src/main/java/com/baeldung/concurrent/lock/StripedLock.java

@@ -0,0 +1,41 @@
+package com.baeldung.concurrent.lock;
+
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+
+import com.google.common.base.Supplier;
+import com.google.common.util.concurrent.Striped;
+
+public class StripedLock extends ConcurrentAccessExperiment {
+    Striped<Lock> stripedLock;
+
+    public StripedLock(int buckets) {
+        stripedLock = Striped.lock(buckets);
+    }
+
+    protected Supplier<?> putSupplier(Map<String,String> map, int key) {
+        return (()-> {
+            int bucket = key % stripedLock.size();
+            Lock lock = stripedLock.get(bucket);
+            lock.lock();
+            try {
+                return map.put("key" + key, "value" + key);
+            } finally {
+                lock.unlock();
+            }
+        });
+    }
+
+    protected Supplier<?> getSupplier(Map<String,String> map, int key) {
+        return (()-> {
+            int bucket = key % stripedLock.size();
+            Lock lock = stripedLock.get(bucket);
+            lock.lock();
+            try {
+                return map.get("key" + key);
+            } finally {
+                lock.unlock();
+            }
+        });
+    }
+}

core-java-modules/core-java-string-operations-2/pom.xml

@@ -64,6 +64,11 @@
             <artifactId>jmh-generator-annprocess</artifactId>
             <version>${jmh-generator.version}</version>
         </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
 
         <dependency>
             <groupId>org.assertj</groupId>
@@ -113,6 +118,7 @@
         <hibernate-validator.version>6.0.2.Final</hibernate-validator.version>
         <javax.el-api.version>3.0.0</javax.el-api.version>
         <javax.el.version>2.2.6</javax.el.version>
+        <commons-codec.version>1.14</commons-codec.version>
     </properties>
 
 </project>

core-kotlin-modules/pom.xml

@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.baeldung.core-kotlin-modules</groupId>
     <artifactId>core-kotlin-modules</artifactId>

core-scala/README.md

@@ -1,8 +0,0 @@
-## Core Scala
-
-This module contains articles about Scala's core features
-
-### Relevant Articles: 
-
-- [Introduction to Scala](https://www.baeldung.com/scala-intro)
-- [Regular Expressions in Scala](https://www.baeldung.com/scala/regular-expressions)

core-scala/pom.xml

@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>core-scala</artifactId>
     <version>1.0-SNAPSHOT</version>
@@ -51,5 +53,5 @@
         <scala.version>2.12.7</scala.version>
         <scala.plugin.version>3.3.2</scala.plugin.version>
     </properties>
-</project>
 
+</project>

core-scala/src/main/scala/com/baeldung/scala/ControlStructuresDemo.scala

@@ -1,44 +0,0 @@
-package com.baeldung.scala
-
-/**
- * Sample code demonstrating the various control structured.
- *
- * @author Chandra Prakash
- *
- */
-object ControlStructuresDemo {
-  def gcd(x : Int, y : Int) : Int = {
-    if (y == 0) x else gcd(y, x % y)
-  }
-
-  def gcdIter(x : Int, y : Int) : Int = {
-    var a = x
-    var b = y
-    while (b > 0) {
-      a = a % b
-      val t = a
-      a = b
-      b = t
-    }
-    a
-  }
-
-  def rangeSum(a : Int, b : Int) = {
-    var sum = 0;
-    for (i <- a to b) {
-      sum += i
-    }
-    sum
-  }
-
-  def factorial(a : Int) : Int = {
-    var result = 1;
-    var i = 1;
-    do {
-      result *= i
-      i = i + 1
-    } while (i <= a)
-    result
-  }
-
-}

core-scala/src/main/scala/com/baeldung/scala/Employee.scala

@@ -1,27 +0,0 @@
-package com.baeldung.scala
-
-/**
- * Sample Code demonstrating a class.
- *
- * @author Chandra Prakash
- *
- */
-class Employee(val name : String,
-               var salary : Int,
-               annualIncrement : Int = 20) {
-
-  def incrementSalary() : Unit = {
-    salary += annualIncrement
-  }
-
-  override def toString =
-    s"Employee(name=$name, salary=$salary)"
-}
-
-/**
- * A Trait which will make the toString return upper case value.
- */
-trait UpperCasePrinter {
-  override def toString: String = super.toString toUpperCase
-}
-

core-scala/src/main/scala/com/baeldung/scala/HelloWorld.scala

@@ -1,6 +0,0 @@
-package com.baeldung.scala
-
-object HelloWorld extends App {
-  println("Hello World!")
-  args foreach println
-}

core-scala/src/main/scala/com/baeldung/scala/HigherOrderFunctions.scala

@@ -1,27 +0,0 @@
-package com.baeldung.scala
-
-/**
- * Sample higher order functions.
- *
- * @author Chandra Prakash
- *
- */
-object HigherOrderFunctions {
-
-  def mapReduce(r : (Int, Int) => Int,
-                i : Int,
-                m : Int => Int,
-                a : Int, b : Int): Int = {
-    def iter(a : Int, result : Int) : Int = {
-      if (a > b) result
-      else iter(a + 1, r(m(a), result))
-    }
-    iter(a, i)
-  }
-
-  def whileLoop(condition : => Boolean)(body : => Unit) : Unit =
-    if (condition) {
-      body
-      whileLoop(condition)(body)
-    }
-}

core-scala/src/main/scala/com/baeldung/scala/IntSet.scala

@@ -1,34 +0,0 @@
-package com.baeldung.scala
-
-/**
- * An abstract class for set of integers and its implementation.
- *
- * @author Chandra Prakash
- *
- */
-abstract class IntSet {
-  // add an element to the set
-  def incl(x : Int) : IntSet
-
-  // whether an element belongs to the set
-  def contains(x : Int) : Boolean
-}
-
-class EmptyIntSet extends IntSet {
-
-  def contains(x : Int) : Boolean = false
-
-  def incl(x : Int) =
-    new NonEmptyIntSet(x, this)
-}
-
-class NonEmptyIntSet(val head : Int, val tail : IntSet)
-  extends IntSet {
-
-  def contains(x : Int) : Boolean =
-    head == x || (tail contains x)
-
-  def incl(x : Int) : IntSet =
-    if (this contains x) this
-    else new NonEmptyIntSet(x, this)
-}

core-scala/src/main/scala/com/baeldung/scala/PatternMatching.scala

@@ -1,137 +0,0 @@
-package com.baeldung.scala
-
-// Case Class
-abstract class Animal
-
-case class Mammal(name: String, fromSea: Boolean) extends Animal
-
-case class Bird(name: String) extends Animal
-
-case class Fish(name: String) extends Animal
-
-// Sealed Class
-sealed abstract class CardSuit
-
-case class Spike() extends CardSuit
-
-case class Diamond() extends CardSuit
-
-case class Heart() extends CardSuit
-
-case class Club() extends CardSuit
-
-object Person {
-  def apply(fullName: String) = fullName
-
-  def unapply(fullName: String): Option[String] = {
-    if (!fullName.isEmpty)
-      Some(fullName.replaceAll("(?<=\\w)(\\w+)", "."))
-    else
-      None
-  }
-}
-
-class PatternMatching {
-
-  def caseClassesPatternMatching(animal: Animal): String = {
-    animal match {
-      case Mammal(name, fromSea) => s"I'm a $name, a kind of mammal. Am I from the sea? $fromSea"
-      case Bird(name) => s"I'm a $name, a kind of bird"
-      case _ => "I'm an unknown animal"
-    }
-  }
-
-  def constantsPatternMatching(constant: Any): String = {
-    constant match {
-      case 0 => "I'm equal to zero"
-      case 4.5d => "I'm a double"
-      case false => "I'm the contrary of true"
-      case _ => s"I'm unknown and equal to $constant"
-    }
-  }
-
-  def sequencesPatternMatching(sequence: Any): String = {
-    sequence match {
-      case List(singleElement) => s"I'm a list with one element: $singleElement"
-      case List(_, _*) => s"I'm a list with one or multiple elements: $sequence"
-      case Vector(1, 2, _*) => s"I'm a vector: $sequence"
-      case _ => s"I'm an unrecognized sequence. My value: $sequence"
-    }
-  }
-
-  def tuplesPatternMatching(tuple: Any): String = {
-    tuple match {
-      case (first, second) => s"I'm a tuple with two elements: $first & $second"
-      case (first, second, third) => s"I'm a tuple with three elements: $first & $second & $third"
-      case _ => s"Unrecognized pattern. My value: $tuple"
-    }
-  }
-
-  def typedPatternMatching(any: Any): String = {
-    any match {
-      case string: String => s"I'm a string. My value: $string"
-      case integer: Int => s"I'm an integer. My value: $integer"
-      case _ => s"I'm from an unknown type. My value: $any"
-    }
-  }
-
-  def regexPatterns(toMatch: String): String = {
-    val numeric = """([0-9]+)""".r
-    val alphabetic = """([a-zA-Z]+)""".r
-    val alphanumeric = """([a-zA-Z0-9]+)""".r
-
-    toMatch match {
-      case numeric(value) => s"I'm a numeric with value $value"
-      case alphabetic(value) => s"I'm an alphabetic with value $value"
-      case alphanumeric(value) => s"I'm an alphanumeric with value $value"
-      case _ => s"I contain other characters than alphanumerics. My value $toMatch"
-    }
-  }
-
-  def optionsPatternMatching(option: Option[String]): String = {
-    option match {
-      case Some(value) => s"I'm not an empty option. Value $value"
-      case None => "I'm an empty option"
-    }
-  }
-
-  def patternGuards(toMatch: Any, maxLength: Int): String = {
-    toMatch match {
-      case list: List[Any] if (list.size <= maxLength) => "List is of acceptable size"
-      case list: List[Any] => "List has not an acceptable size"
-      case string: String if (string.length <= maxLength) => "String is of acceptable size"
-      case string: String => "String has not an acceptable size"
-      case _ => "Input is neither a List or a String"
-    }
-  }
-
-  def sealedClass(cardSuit: CardSuit): String = {
-    cardSuit match {
-      case Spike() => "Card is spike"
-      case Club() => "Card is club"
-      case Heart() => "Card is heart"
-      case Diamond() => "Card is diamond"
-    }
-  }
-
-  def extractors(person: Any): String = {
-    person match {
-      case Person(initials) => s"My initials are $initials"
-      case _ => "Could not extract initials"
-    }
-  }
-
-  def closuresPatternMatching(list: List[Any]): List[Any] = {
-    list.collect { case i: Int if (i < 10) => i }
-  }
-
-  def catchBlocksPatternMatching(exception: Exception): String = {
-    try {
-      throw exception
-    } catch {
-      case ex: IllegalArgumentException => "It's an IllegalArgumentException"
-      case ex: RuntimeException => "It's a RuntimeException"
-      case _ => "It's an unknown kind of exception"
-    }
-  }
-}

core-scala/src/main/scala/com/baeldung/scala/Utils.scala

@@ -1,33 +0,0 @@
-package com.baeldung.scala
-
-/**
- * Some utility methods.
- *
- * @author Chandra Prakash
- *
- */
-object Utils {
-  def average(x : Double, y : Double): Double = (x + y) / 2
-
-  def randomLessThan(d : Double): Double = {
-    var random = 0d
-    do {
-      random = Math.random()
-    } while (random >= d)
-    random
-  }
-
-  def power(x : Int, y : Int) : Int = {
-    def powNested(i : Int, accumulator : Int) : Int = {
-      if (i <= 0) accumulator
-      else powNested(i - 1, x * accumulator)
-    }
-    powNested(y, 1)
-  }
-
-  def fibonacci(n : Int) : Int = n match {
-    case 0 | 1 => 1
-    case x if x > 1 =>
-      fibonacci(x - 1) + fibonacci(x - 2)
-  }
-}

core-scala/src/test/scala/com/baeldung/scala/ControlStructuresDemoUnitTest.scala

@@ -1,33 +0,0 @@
-package com.baeldung.scala
-
-import com.baeldung.scala.ControlStructuresDemo._
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class ControlStructuresDemoUnitTest {
-  @Test
-  def givenTwoIntegers_whenGcdCalled_thenCorrectValueReturned() = {
-    assertEquals(3, gcd(15, 27))
-  }
-
-  @Test
-  def givenTwoIntegers_whenGcdIterCalled_thenCorrectValueReturned() = {
-    assertEquals(3, gcdIter(15, 27))
-  }
-
-  @Test
-  def givenTwoIntegers_whenRangeSumcalled_thenCorrectValueReturned() = {
-    assertEquals(55, rangeSum(1, 10))
-  }
-
-  @Test
-  def givenPositiveInteger_whenFactorialInvoked_thenCorrectValueReturned() = {
-    assertEquals(720, factorial(6))
-  }
-
-  @Test
-  def whenFactorialOf0Invoked_then1Returned() = {
-    assertEquals(1, factorial(0))
-  }
-
-}

core-scala/src/test/scala/com/baeldung/scala/EmployeeUnitTest.scala

@@ -1,30 +0,0 @@
-package com.baeldung.scala
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class EmployeeUnitTest {
-
-  @Test
-  def whenEmployeeSalaryIncremented_thenCorrectSalary() = {
-    val employee = new Employee("John Doe", 1000)
-    employee.incrementSalary()
-    assertEquals(1020, employee.salary)
-  }
-
-  @Test
-  def givenEmployee_whenToStringCalled_thenCorrectStringReturned() = {
-    val employee = new Employee("John Doe", 1000)
-    assertEquals("Employee(name=John Doe, salary=1000)", employee.toString)
-  }
-
-  @Test
-  def givenEmployeeWithTrait_whenToStringCalled_thenCorrectStringReturned() = {
-    val employee =
-      new Employee("John Doe", 1000) with UpperCasePrinter
-    assertEquals("EMPLOYEE(NAME=JOHN DOE, SALARY=1000)", employee.toString)
-  }
-
-}
-
-

core-scala/src/test/scala/com/baeldung/scala/HigherOrderFunctionsExamplesUnitTest.scala

@@ -1,82 +0,0 @@
-package com.baeldung.scala
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-
-class HigherOrderFunctionsExamplesUnitTest {
-
-  @Test
-  def whenCallingMapWithAnonymousFunction_thenTransformationIsApplied() = {
-    val expected = Seq("sir Alex Ferguson", "sir Bobby Charlton", "sir Frank Lampard")
-
-    val names = Seq("Alex Ferguson", "Bobby Charlton", "Frank Lampard")
-    val sirNames = names.map(name => "sir " + name)
-
-    assertEquals(expected, sirNames)
-  }
-
-  @Test
-  def whenCallingMapWithDefined_thenTransformationIsApplied() = {
-    val expected = Seq("sir Alex Ferguson", "sir Bobby Charlton", "sir Frank Lampard")
-
-    val names = Seq("Alex Ferguson", "Bobby Charlton", "Frank Lampard")
-
-    def prefixWithSir(name: String) = "sir " + name
-    val sirNames = names.map(prefixWithSir)
-
-    assertEquals(expected, sirNames)
-  }
-
-  @Test
-  def whenCallingFilter_thenUnecessaryElementsAreRemoved() = {
-    val expected = Seq("John O'Shea", "John Hartson")
-
-    val names = Seq("John O'Shea", "Aiden McGeady", "John Hartson")
-    val johns = names.filter(name => name.matches("^John .*"))
-
-    assertEquals(expected, johns)
-  }
-
-  @Test
-  def whenCallingReduce_thenProperSumIsCalculated() = {
-    val expected = 2750
-
-    val earnings = Seq(1000, 1300, 450)
-    val sumEarnings = earnings.reduce((acc, x) => acc + x)
-
-    assertEquals(expected, sumEarnings)
-  }
-
-  @Test
-  def whenCallingFold_thenNumberOfWordsShouldBeCalculated() = {
-    val expected = 6
-
-    val strings = Seq("bunch of words", "just me", "it")
-    val sumEarnings = strings.foldLeft(0)((acc, x) => acc + x.split(" ").size)
-
-    assertEquals(expected, sumEarnings)
-  }
-
-  @Test
-  def whenCallingOwnHigherOrderFunction_thenProperFunctionIsReturned() = {
-    def mathOperation(name: String): (Int, Int) => Int = (x: Int, y: Int) => {
-      name match {
-        case "addition" => x + y
-        case "multiplication" => x * y
-        case "division" => x/y
-        case "subtraction" => x - y
-      }
-    }
-
-    def add: (Int, Int) => Int = mathOperation("addition")
-    def mul: (Int, Int) => Int = mathOperation("multiplication")
-    def div: (Int, Int) => Int = mathOperation("division")
-    def sub: (Int, Int) => Int = mathOperation("subtraction")
-
-    assertEquals(15, add(10, 5))
-    assertEquals(50, mul(10, 5))
-    assertEquals(2, div(10, 5))
-    assertEquals(5, sub(10, 5))
-  }
-}

core-scala/src/test/scala/com/baeldung/scala/HigherOrderFunctionsUnitTest.scala

@@ -1,48 +0,0 @@
-package com.baeldung.scala
-
-import com.baeldung.scala.HigherOrderFunctions.mapReduce
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class HigherOrderFunctionsUnitTest {
-
-  @Test
-  def whenCalledWithSumAndSquareFunctions_thenCorrectValueReturned() = {
-    def square(x : Int) = x * x
-
-    def sum(x : Int, y : Int) = x + y
-
-    def sumSquares(a : Int, b : Int) =
-      mapReduce(sum, 0, square, a, b)
-
-    assertEquals(385, sumSquares(1, 10))
-  }
-
-  @Test
-  def whenComputingSumOfSquaresWithAnonymousFunctions_thenCorrectValueReturned() = {
-    def sumSquares(a : Int, b : Int) =
-      mapReduce((x, y) => x + y, 0, x => x * x, a, b)
-
-    assertEquals(385, sumSquares(1, 10))
-  }
-
-  @Test
-  def givenCurriedFunctions_whenInvoked_thenCorrectValueReturned() = {
-    // a curried function
-    def sum(f : Int => Int)(a : Int,
-                            b : Int) : Int =
-      if (a > b) 0 else f(a) + sum(f)(a + 1, b)
-
-    // another curried function
-    def mod(n : Int)(x : Int) = x % n
-
-    // application of a curried function
-    assertEquals(1, mod(5)(6))
-
-    // partial application of curried function
-    // trailing underscore is required to make function type explicit
-    val sumMod5 = sum(mod(5)) _
-
-    assertEquals(10, sumMod5(6, 10))
-  }
-}

core-scala/src/test/scala/com/baeldung/scala/IntSetUnitTest.scala

@@ -1,21 +0,0 @@
-package com.baeldung.scala
-
-import org.junit.Assert.assertFalse
-import org.junit.Test
-
-class IntSetUnitTest {
-
-  @Test
-  def givenSetof1To10_whenContains11Called_thenFalse() = {
-
-    // Set up a set containing integers 1 to 10.
-    val set1To10 =
-      Range(1, 10)
-        .foldLeft(new EmptyIntSet() : IntSet) {
-          (x, y) => x incl y
-        }
-
-    assertFalse(set1To10 contains 11)
-  }
-
-}

core-scala/src/test/scala/com/baeldung/scala/PatternMatchingUnitTest.scala

@@ -1,208 +0,0 @@
-package com.baeldung.scala
-
-import java.io.FileNotFoundException
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class PatternMatchingUnitTest {
-  @Test
-  def whenAMammalIsGivenToTheMatchExpression_ThenItsRecognizedAsMammal(): Unit = {
-    val result = new PatternMatching().caseClassesPatternMatching(Mammal("Lion", fromSea = false))
-    assertEquals("I'm a Lion, a kind of mammal. Am I from the sea? false", result)
-  }
-
-  @Test
-  def whenABirdIsGivenToTheMatchExpression_ThenItsRecognizedAsBird(): Unit = {
-    val result = new PatternMatching().caseClassesPatternMatching(Bird("Pigeon"))
-    assertEquals("I'm a Pigeon, a kind of bird", result)
-  }
-
-  @Test
-  def whenAnUnkownAnimalIsGivenToTheMatchExpression_TheDefaultClauseIsUsed(): Unit = {
-    val result = new PatternMatching().caseClassesPatternMatching(Fish("Tuna"))
-    assertEquals("I'm an unknown animal", result)
-  }
-
-  @Test
-  def whenTheConstantZeroIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().constantsPatternMatching(0)
-    assertEquals("I'm equal to zero", result)
-  }
-
-  @Test
-  def whenFourAndAHalfIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().constantsPatternMatching(4.5d)
-    assertEquals("I'm a double", result)
-  }
-
-  @Test
-  def whenTheBooleanFalseIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().constantsPatternMatching(false)
-    assertEquals("I'm the contrary of true", result)
-  }
-
-  @Test
-  def whenAnUnkownConstantIsPassed_ThenTheDefaultPatternIsUsed(): Unit = {
-    val result = new PatternMatching().constantsPatternMatching(true)
-    assertEquals("I'm unknown and equal to true", result)
-  }
-
-  @Test
-  def whenASingleElementListIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().sequencesPatternMatching(List("String"))
-    assertEquals("I'm a list with one element: String", result)
-  }
-
-  @Test
-  def whenAMultipleElementsListIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().sequencesPatternMatching(List("Multiple", "Elements"))
-    assertEquals("I'm a list with one or multiple elements: List(Multiple, Elements)", result)
-  }
-
-  @Test
-  def whenAVectorBeginningWithOneAndTwoIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().sequencesPatternMatching(Vector(1, 2, 3))
-    assertEquals("I'm a vector: Vector(1, 2, 3)", result)
-  }
-
-  @Test
-  def whenANotMatchingVectorIsPassed_ThenItShouldntMatchAndEnterTheDefaultClause(): Unit = {
-    val result = new PatternMatching().sequencesPatternMatching(Vector(2, 1))
-    assertEquals("I'm an unrecognized sequence. My value: Vector(2, 1)", result)
-  }
-
-  @Test
-  def whenAnEmptyListIsPassed_ThenItShouldntMatchAndEnterTheDefaultClause(): Unit = {
-    val result = new PatternMatching().sequencesPatternMatching(List())
-    assertEquals("I'm an unrecognized sequence. My value: List()", result)
-  }
-
-  @Test
-  def whenATwoElementsTupleIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().tuplesPatternMatching(("First", "Second"))
-    assertEquals("I'm a tuple with two elements: First & Second", result)
-  }
-
-  @Test
-  def whenAThreeElementsTupleIsPassed_ThenItMatchesTheCorrespondingPattern(): Unit = {
-    val result = new PatternMatching().tuplesPatternMatching(("First", "Second", "Third"))
-    assertEquals("I'm a tuple with three elements: First & Second & Third", result)
-  }
-
-  @Test
-  def whenAnoterKindOfTupleIsPassed_ThenItShouldntMatchAndReturnTheDefaultPattern(): Unit = {
-    val result = new PatternMatching().tuplesPatternMatching(("First"))
-    assertEquals("Unrecognized pattern. My value: First", result)
-  }
-
-  @Test
-  def whenAStringConsistingOfNumericsOnlyIsPassed_ThenItShouldMatchTheNumericRegex(): Unit = {
-    val result = new PatternMatching().regexPatterns("123")
-    assertEquals("I'm a numeric with value 123", result)
-  }
-
-  @Test
-  def whenAStringConsistignOfAlphabeticsOnlyIsPassed_ThenItShouldMatchTheAlphabeticRegex(): Unit = {
-    val result = new PatternMatching().regexPatterns("abc")
-    assertEquals("I'm an alphabetic with value abc", result)
-  }
-
-  @Test
-  def whenAStringConsistignOfAlphanumericsOnlyIsPassed_ThenItShouldMatchTheAlphanumericRegex(): Unit = {
-    val result = new PatternMatching().regexPatterns("abc123")
-    assertEquals("I'm an alphanumeric with value abc123", result)
-  }
-
-  @Test
-  def whenAnotherTypeOfStringIsPassed_ThenItShouldntMatchAndReturnTheDefaultPattern(): Unit = {
-    val result = new PatternMatching().regexPatterns("abc_123")
-    assertEquals("I contain other characters than alphanumerics. My value abc_123", result)
-  }
-
-  @Test
-  def whenAFilledOptionIsPassed_ThenItShouldMatchTheSomeClause(): Unit = {
-    val result = new PatternMatching().optionsPatternMatching(Option.apply("something"))
-    assertEquals("I'm not an empty option. Value something", result)
-  }
-
-  @Test
-  def whenAnEmptyOptionIsPassed_ThenItShouldMatchTheNoneClause(): Unit = {
-    val result = new PatternMatching().optionsPatternMatching(Option.empty)
-    assertEquals("I'm an empty option", result)
-  }
-
-  @Test
-  def whenAListWithAcceptedSizeIsPassed_ThenThePositiveMessageIsSent(): Unit = {
-    val result = new PatternMatching().patternGuards(List(1, 2), 3)
-    assertEquals("List is of acceptable size", result)
-  }
-
-  @Test
-  def whenAListWithAnUnacceptedSizeIsPassed_ThenTheNegativeMessageIsSent(): Unit = {
-    val result = new PatternMatching().patternGuards(List(1, 2, 3, 4), 3)
-    assertEquals("List has not an acceptable size", result)
-  }
-
-  @Test
-  def whenAStringWithAcceptedSizeIsPassed_ThenThePositiveMessageIsSent(): Unit = {
-    val result = new PatternMatching().patternGuards("OK", 3)
-    assertEquals("String is of acceptable size", result)
-  }
-
-  @Test
-  def whenAStringWithAnUnacceptedSizeIsPassed_ThenTheNegativeMessageIsSent(): Unit = {
-    val result = new PatternMatching().patternGuards("Not OK", 3)
-    assertEquals("String has not an acceptable size", result)
-  }
-
-  @Test
-  def whenAnObjectWhichIsNotAListOrAStringIsPassed_thenTheDefaultClauseIsUsed(): Unit = {
-    val result = new PatternMatching().patternGuards(1, 1)
-    assertEquals("Input is neither a List or a String", result)
-  }
-
-  @Test
-  def whenACardSuitIsPassed_ThenTheCorrespondingMatchCaseClauseIsUsed(): Unit = {
-    assertEquals("Card is spike", new PatternMatching().sealedClass(Spike()))
-    assertEquals("Card is club", new PatternMatching().sealedClass(Club()))
-    assertEquals("Card is heart", new PatternMatching().sealedClass(Heart()))
-    assertEquals("Card is diamond", new PatternMatching().sealedClass(Diamond()))
-  }
-
-  @Test
-  def whenAnObjectWithExtractorIsPassed_ThenTheExtractedValueIsUsedInTheCaseClause(): Unit = {
-    val person = Person("John Smith")
-    val result = new PatternMatching().extractors(person)
-    assertEquals("My initials are J. S.", result)
-  }
-
-  @Test
-  def whenAnObjectWithExtractorIsPassed_AndTheValueIsEmpty_ThenTheDefaultCaseClauseIsUsed(): Unit = {
-    val person = Person("")
-    val result = new PatternMatching().extractors(person)
-    assertEquals("Could not extract initials", result)
-  }
-
-  @Test
-  def whenAListOfRandomElementsIsPassed_ThenOnlyTheIntegersBelowTenAreReturned(): Unit = {
-    val input = List(1, 2, "5", 11, true)
-    val result = new PatternMatching().closuresPatternMatching(input)
-    assertEquals(List(1, 2), result)
-  }
-
-  @Test
-  def whenAnExceptionIsPassed_ThenTheCorrespondingMessageIsReturned(): Unit = {
-    val pm = new PatternMatching()
-
-    val iae = new IllegalArgumentException()
-    val re = new RuntimeException()
-    val fnfe = new FileNotFoundException()
-
-    assertEquals("It's an IllegalArgumentException", pm.catchBlocksPatternMatching(iae))
-    assertEquals("It's a RuntimeException", pm.catchBlocksPatternMatching(re))
-    assertEquals("It's an unknown kind of exception", pm.catchBlocksPatternMatching(fnfe))
-  }
-}
-
-

core-scala/src/test/scala/com/baeldung/scala/UtilsUnitTest.scala

@@ -1,32 +0,0 @@
-package com.baeldung.scala
-
-import com.baeldung.scala.Utils.{average, fibonacci, power, randomLessThan}
-import org.junit.Assert.{assertEquals, assertTrue}
-import org.junit.Test
-
-class UtilsUnitTest {
-
-  @Test
-  def whenAverageCalled_thenCorrectValueReturned(): Unit = {
-    assertEquals(15.0, average(10, 20), 1e-5)
-  }
-
-  @Test
-  def whenRandomLessThanInvokedWithANumber_thenARandomLessThanItReturned: Unit = {
-    val d = 0.1
-    assertTrue(randomLessThan(d) < d)
-  }
-
-  @Test
-  def whenPowerInvokedWith2And3_then8Returned: Unit = {
-    assertEquals(8, power(2, 3))
-  }
-
-  @Test
-  def whenFibonacciCalled_thenCorrectValueReturned: Unit = {
-    assertEquals(1, fibonacci(0))
-    assertEquals(1, fibonacci(1))
-    assertEquals(fibonacci(6),
-      fibonacci(4) + fibonacci(5))
-  }
-}

core-scala/src/test/scala/com/baeldung/scala/regex/RegexUnitTest.scala

@@ -1,73 +0,0 @@
-package com.baeldung.scala.regex
-
-import org.junit.Test
-import org.junit.Assert.assertEquals
-
-class RegexUnitTest {
-  private val polishPostalCode = "([0-9]{2})\\-([0-9]{3})".r
-  private val timestamp = "([0-9]{2}):([0-9]{2}):([0-9]{2}).([0-9]{3})".r
-  private val timestampUnanchored = timestamp.unanchored
-
-  @Test
-  def givenRegularExpression_whenCallingFindFirstIn_thenShouldFindCorrectMatches(): Unit = {
-    val postCode = polishPostalCode.findFirstIn("Warsaw 01-011, Jerusalem Avenue")
-    assertEquals(Some("01-011"), postCode)
-  }
-
-  @Test
-  def givenRegularExpression_whenCallingFindFirstMatchIn_thenShouldFindCorrectMatches(): Unit = {
-    val postCodes = polishPostalCode.findFirstMatchIn("Warsaw 01-011, Jerusalem Avenue")
-    assertEquals(Some("011"), for (m <- postCodes) yield m.group(2))
-  }
-
-  @Test
-  def givenRegularExpression_whenCallingFindAllIn_thenShouldFindCorrectMatches(): Unit = {
-    val postCodes = polishPostalCode.findAllIn("Warsaw 01-011, Jerusalem Avenue, Cracow 30-059, Mickiewicza Avenue")
-      .toList
-    assertEquals(List("01-011", "30-059"), postCodes)
-
-    polishPostalCode.findAllIn("Warsaw 01-011, Jerusalem Avenue, Cracow 30-059, Mickiewicza Avenue")
-  }
-
-  @Test
-  def givenRegularExpression_whenCallingFindAlMatchlIn_thenShouldFindCorrectMatches(): Unit = {
-    val postCodes = polishPostalCode.findAllMatchIn("Warsaw 01-011, Jerusalem Avenue, Cracow 30-059, Mickiewicza Avenue")
-      .toList
-    val postalDistricts = for (m <- postCodes) yield m.group(1)
-    assertEquals(List("01", "30"), postalDistricts)
-  }
-
-  @Test
-  def givenRegularExpression_whenExtractingValues_thenShouldExtractCorrectValues(): Unit = {
-    val description = "11:34:01.411" match {
-      case timestamp(hour, minutes, _, _) => s"It's $minutes minutes after $hour"
-    }
-
-    assertEquals("It's 34 minutes after 11", description)
-  }
-
-  @Test
-  def givenUnanchoredRegularExpression_whenExtractingValues_thenShouldExtractCorrectValues(): Unit = {
-    val description = "Timestamp: 11:34:01.411 error appeared" match {
-      case timestampUnanchored(hour, minutes, _, _) => s"It's $minutes minutes after $hour"
-    }
-
-    assertEquals("It's 34 minutes after 11", description)
-  }
-
-  @Test
-  def givenRegularExpression_whenCallingReplaceAllIn_thenShouldReplaceText(): Unit = {
-    val minutes = timestamp.replaceAllIn("11:34:01.311", m => m.group(2))
-
-    assertEquals("34", minutes)
-  }
-
-  @Test
-  def givenRegularExpression_whenCallingReplaceAllInWithMatcher_thenShouldReplaceText(): Unit = {
-    val secondsThatDayInTotal = timestamp.replaceAllIn("11:34:01.311", _ match {
-      case timestamp(hours, minutes, seconds, _) => s"$hours-$minutes"
-    })
-
-    assertEquals("11-34", secondsThatDayInTotal)
-  }
-}

couchbase/pom.xml

@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>couchbase</artifactId>
     <version>0.1-SNAPSHOT</version>