Update javaxval/src/test/java/org/baeldung/javaxval/messageinterpolator/ParameterMessageInterpolaterIntegrationTest.java

update to use the givenX_whenY_thenZ naming convention for tests

Co-Authored-By: KevinGilmore <kpg102@gmail.com>

patterns/README.md

@@ -0,0 +1,3 @@
+## Patterns
+
+This module contains articles about design patterns.

patterns/design-patterns-architectural/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+- [Service Locator Pattern](https://www.baeldung.com/java-service-locator-pattern)
+- [The DAO Pattern in Java](https://www.baeldung.com/java-dao-pattern)

patterns/design-patterns-architectural/pom.xml

@@ -0,0 +1,54 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>design-patterns-architectural</artifactId>
+    <version>1.0</version>
+    <name>design-patterns-architectural</name>
+	<packaging>jar</packaging>
+	
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>patterns</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        
+    	<dependency>
+            <groupId>javax</groupId>
+            <artifactId>javaee-api</artifactId>
+            <version>${javaee.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>${hibernate-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql-connector.version}</version>
+            <type>jar</type>
+        </dependency>
+    </dependencies>
+	
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        
+        <assertj-core.version>3.9.1</assertj-core.version>
+        
+        <javaee.version>8.0</javaee.version>
+        <hibernate-core.version>5.2.16.Final</hibernate-core.version>
+        <mysql-connector.version>6.0.6</mysql-connector.version>
+    </properties>
+</project>

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/application/UserApplication.java

@@ -0,0 +1,53 @@
+package com.baeldung.daopattern.application;
+
+import com.baeldung.daopattern.config.JpaEntityManagerFactory;
+import com.baeldung.daopattern.daos.Dao;
+import com.baeldung.daopattern.daos.JpaUserDao;
+import com.baeldung.daopattern.entities.User;
+import java.util.List;
+import java.util.Optional;
+import javax.persistence.EntityManager;
+import javax.persistence.Persistence;
+
+public class UserApplication {
+    
+    private static JpaUserDao jpaUserDao;
+    
+    public static void main(String[] args) {
+        User user1 = getUser(1);
+        System.out.println(user1);
+        updateUser(user1, new String[]{"John", "john@domain.com"});
+        saveUser(new User("Monica", "monica@domain.com"));
+        deleteUser(getUser(2));
+        getAllUsers().forEach(user -> System.out.println(user.getName()));
+    }
+    
+    private static class JpaUserDaoHolder {
+        private static final JpaUserDao jpaUserDao = new JpaUserDao(new JpaEntityManagerFactory().getEntityManager());
+    }
+    
+    public static Dao getJpaUserDao() {
+        return JpaUserDaoHolder.jpaUserDao;
+    }
+    
+    public static User getUser(long id) {
+        Optional<User> user = getJpaUserDao().get(id);
+        return user.orElseGet(()-> {return new User("non-existing user", "no-email");});
+    }
+    
+    public static List<User> getAllUsers() {
+        return getJpaUserDao().getAll();
+    }
+    
+    public static void updateUser(User user, String[] params){
+        getJpaUserDao().update(user, params);
+    }
+    
+    public static void saveUser(User user) {
+        getJpaUserDao().save(user);
+    }
+    
+    public static void deleteUser(User user) {
+        getJpaUserDao().delete(user);
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/config/JpaEntityManagerFactory.java

@@ -0,0 +1,65 @@
+package com.baeldung.daopattern.config;
+
+import com.baeldung.daopattern.entities.User;
+import com.mysql.cj.jdbc.MysqlDataSource;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+import javax.persistence.EntityManager;
+import javax.sql.DataSource;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.spi.PersistenceUnitInfo;
+import org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl;
+import org.hibernate.jpa.boot.internal.PersistenceUnitInfoDescriptor;
+
+public class JpaEntityManagerFactory {
+    
+    private final String DB_URL = "jdbc:mysql://databaseurl";
+    private final String DB_USER_NAME = "username";
+    private final String DB_PASSWORD = "password";
+    
+    public EntityManager getEntityManager() {
+        return getEntityManagerFactory().createEntityManager();
+    }
+    
+    protected EntityManagerFactory getEntityManagerFactory() {
+        PersistenceUnitInfo persistenceUnitInfo = getPersistenceUnitInfo(getClass().getSimpleName());
+        Map<String, Object> configuration = new HashMap<>();
+        return new EntityManagerFactoryBuilderImpl(new PersistenceUnitInfoDescriptor(persistenceUnitInfo), configuration)
+          .build();
+    }
+    
+    protected PersistenceUnitInfoImpl getPersistenceUnitInfo(String name) {
+        return new PersistenceUnitInfoImpl(name, getEntityClassNames(), getProperties());
+    }
+    
+    protected List<String> getEntityClassNames() {
+        return Arrays.asList(getEntities())
+          .stream()
+          .map(Class::getName)
+          .collect(Collectors.toList());
+    }
+    
+    protected Properties getProperties() {
+        Properties properties = new Properties();
+        properties.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
+        properties.put("hibernate.id.new_generator_mappings", false);
+        properties.put("hibernate.connection.datasource", getMysqlDataSource());
+        return properties;
+    }
+    
+    protected Class[] getEntities() {
+        return new Class[]{User.class};
+    }
+    
+    protected DataSource getMysqlDataSource() {
+	MysqlDataSource mysqlDataSource = new MysqlDataSource();
+        mysqlDataSource.setURL(DB_URL);
+	mysqlDataSource.setUser(DB_USER_NAME);
+        mysqlDataSource.setPassword(DB_PASSWORD);
+	return mysqlDataSource;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/config/PersistenceUnitInfoImpl.java

@@ -0,0 +1,130 @@
+package com.baeldung.daopattern.config;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+import javax.sql.DataSource;
+import javax.persistence.SharedCacheMode;
+import javax.persistence.ValidationMode;
+import javax.persistence.spi.ClassTransformer;
+import javax.persistence.spi.PersistenceUnitInfo;
+import javax.persistence.spi.PersistenceUnitTransactionType;
+import org.hibernate.jpa.HibernatePersistenceProvider;
+
+public class PersistenceUnitInfoImpl implements PersistenceUnitInfo {
+    
+    public static final String JPA_VERSION = "2.1";
+    private final String persistenceUnitName;
+    private PersistenceUnitTransactionType transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
+    private final List<String> managedClassNames;
+    private final List<String> mappingFileNames = new ArrayList<>();
+    private final Properties properties;
+    private DataSource jtaDataSource;
+    private DataSource nonJtaDataSource;
+    
+    public PersistenceUnitInfoImpl(String persistenceUnitName, List<String> managedClassNames, Properties properties) {
+        this.persistenceUnitName = persistenceUnitName;
+        this.managedClassNames = managedClassNames;
+        this.properties = properties;
+    }
+    
+    @Override
+    public String getPersistenceUnitName() {
+        return persistenceUnitName;
+    }
+ 
+    @Override
+    public String getPersistenceProviderClassName() {
+        return HibernatePersistenceProvider.class.getName();
+    }
+ 
+    @Override
+    public PersistenceUnitTransactionType getTransactionType() {
+        return transactionType;
+    }
+ 
+    @Override
+    public DataSource getJtaDataSource() {
+        return jtaDataSource;
+    }
+ 
+    public PersistenceUnitInfoImpl setJtaDataSource(DataSource jtaDataSource) {
+        this.jtaDataSource = jtaDataSource;
+        this.nonJtaDataSource = null;
+        transactionType = PersistenceUnitTransactionType.JTA;
+        return this;
+    }
+ 
+    @Override
+    public DataSource getNonJtaDataSource() {
+        return nonJtaDataSource;
+    }
+ 
+    public PersistenceUnitInfoImpl setNonJtaDataSource(DataSource nonJtaDataSource) {
+        this.nonJtaDataSource = nonJtaDataSource;
+        this.jtaDataSource = null;
+        transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
+        return this;
+    }
+ 
+    @Override
+    public List<String> getMappingFileNames() {
+        return mappingFileNames;
+    }
+ 
+    @Override
+    public List<URL> getJarFileUrls() {
+        return Collections.emptyList();
+    }
+ 
+    @Override
+    public URL getPersistenceUnitRootUrl() {
+        return null;
+    }
+ 
+    @Override
+    public List<String> getManagedClassNames() {
+        return managedClassNames;
+    }
+ 
+    @Override
+    public boolean excludeUnlistedClasses() {
+        return false;
+    }
+ 
+    @Override
+    public SharedCacheMode getSharedCacheMode() {
+        return SharedCacheMode.UNSPECIFIED;
+    }
+ 
+    @Override
+    public ValidationMode getValidationMode() {
+        return ValidationMode.AUTO;
+    }
+ 
+    public Properties getProperties() {
+        return properties;
+    }
+ 
+    @Override
+    public String getPersistenceXMLSchemaVersion() {
+        return JPA_VERSION;
+    }
+ 
+    @Override
+    public ClassLoader getClassLoader() {
+        return Thread.currentThread().getContextClassLoader();
+    }
+ 
+    @Override
+    public void addTransformer(ClassTransformer transformer) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+    
+    @Override
+    public ClassLoader getNewTempClassLoader() {
+        return null;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/daos/Dao.java

@@ -0,0 +1,17 @@
+package com.baeldung.daopattern.daos;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface Dao<T> {
+    
+    Optional<T> get(long id);
+    
+    List<T> getAll();
+    
+    void save(T t);
+    
+    void update(T t, String[] params);
+    
+    void delete(T t);   
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/daos/JpaUserDao.java

@@ -0,0 +1,60 @@
+package com.baeldung.daopattern.daos;
+
+import com.baeldung.daopattern.entities.User;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Consumer;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Query;
+
+public class JpaUserDao implements Dao<User> {
+    
+    private final EntityManager entityManager;
+    
+    public JpaUserDao(EntityManager entityManager) {
+        this.entityManager = entityManager;
+    }
+    
+    @Override
+    public Optional<User> get(long id) {
+        return Optional.ofNullable(entityManager.find(User.class, id));
+    }
+    
+    @Override
+    public List<User> getAll() {
+        Query query = entityManager.createQuery("SELECT e FROM User e");
+        return query.getResultList();
+    }
+    
+    @Override
+    public void save(User user) {
+        executeInsideTransaction(entityManager -> entityManager.persist(user));
+    }
+    
+    @Override
+    public void update(User user, String[] params) {
+        user.setName(Objects.requireNonNull(params[0], "Name cannot be null"));
+        user.setEmail(Objects.requireNonNull(params[1], "Email cannot be null"));
+        executeInsideTransaction(entityManager -> entityManager.merge(user));
+    }
+    
+    @Override 
+    public void delete(User user) {
+        executeInsideTransaction(entityManager -> entityManager.remove(user));
+    }
+    
+    private void executeInsideTransaction(Consumer<EntityManager> action) {
+        final EntityTransaction tx = entityManager.getTransaction();
+        try {
+            tx.begin();
+            action.accept(entityManager);
+            tx.commit(); 
+        }
+        catch (RuntimeException e) {
+            tx.rollback();
+            throw e;
+        }
+    }    
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/daos/UserDao.java

@@ -0,0 +1,44 @@
+package com.baeldung.daopattern.daos;
+
+import com.baeldung.daopattern.entities.User;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+public class UserDao implements Dao<User> {
+    
+    private List<User> users = new ArrayList<>();
+    
+    public UserDao() {
+        users.add(new User("John", "john@domain.com"));
+        users.add(new User("Susan", "susan@domain.com"));
+    }
+    
+    @Override
+    public Optional<User> get(long id) {
+        return Optional.ofNullable(users.get((int) id));
+    }
+    
+    @Override
+    public List<User> getAll() {
+        return users;
+    }
+    
+    @Override
+    public void save(User user) {
+        users.add(user);
+    }
+    
+    @Override
+    public void update(User user, String[] params) {
+        user.setName(Objects.requireNonNull(params[0], "Name cannot be null"));
+        user.setEmail(Objects.requireNonNull(params[1], "Email cannot be null"));
+        users.add(user);
+    }
+    
+    @Override
+    public void delete(User user) {
+        users.remove(user);
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/entities/User.java

@@ -0,0 +1,45 @@
+package com.baeldung.daopattern.entities;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "users")
+public class User {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private long id;
+    private String name;
+    private String email;
+    
+    public User(){}
+    
+    public User(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+    
+    public long getId() {
+        return id;
+    }
+    
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/Cache.java

@@ -0,0 +1,39 @@
+package com.baeldung.service.locator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class Cache {
+    private List<MessagingService> services;
+
+    public Cache(){
+        services = new ArrayList<MessagingService>();
+    }
+
+    public MessagingService getService(String serviceName){
+
+        for (MessagingService service : services) {
+            if(service.getServiceName().equalsIgnoreCase(serviceName)){
+                System.out.println("Returning cached  " + serviceName + " object");
+                return service;
+            }
+        }
+        return null;
+    }
+
+    public void addService(MessagingService newService){
+        boolean exists = false;
+
+        for (MessagingService service : services) {
+            if(service.getServiceName().equalsIgnoreCase(newService.getServiceName())){
+                exists = true;
+            }
+        }
+        if(!exists){
+            services.add(newService);
+        }
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/EmailService.java

@@ -0,0 +1,15 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class EmailService implements MessagingService {
+
+    public String getMessageBody() {
+        return "email message";
+    }
+
+    public String getServiceName() {
+        return "EmailService";
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/InitialContext.java

@@ -0,0 +1,17 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class InitialContext {
+
+    public Object lookup(String serviceName) {
+
+        if (serviceName.equalsIgnoreCase("EmailService")) {
+            return new EmailService();
+        } else if (serviceName.equalsIgnoreCase("SMSService")) {
+            return new SMSService();
+        }
+        return null;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/Main.java

@@ -0,0 +1,22 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class Main {
+
+    public static void main(String[] args) {
+
+        MessagingService service = ServiceLocator.getService("EmailService");
+        String email = service.getMessageBody();
+        System.out.println(email);
+
+        service = ServiceLocator.getService("SMSService");
+        String sms = service.getMessageBody();
+        System.out.println(sms);
+
+        service = ServiceLocator.getService("EmailService");
+        String newEmail = service.getMessageBody();
+        System.out.println(newEmail);
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/MessagingService.java

@@ -0,0 +1,8 @@
+package com.baeldung.service.locator;
+
+public interface MessagingService {
+
+    String getMessageBody();
+
+    String getServiceName();
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/SMSService.java

@@ -0,0 +1,15 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class SMSService implements MessagingService {
+
+    public String getMessageBody() {
+        return "sms message";
+    }
+
+    public String getServiceName() {
+        return "SMSService";
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/ServiceLocator.java

@@ -0,0 +1,27 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class ServiceLocator {
+
+    private static Cache cache;
+
+    static {
+        cache = new Cache();
+    }
+
+    public static MessagingService getService(String serviceName){
+
+        MessagingService service = cache.getService(serviceName);
+
+        if(service != null){
+            return service;
+        }
+
+        InitialContext context = new InitialContext();
+        MessagingService service1 = (MessagingService)context.lookup(serviceName);
+        cache.addService(service1);
+        return service1;
+    }
+}

patterns/design-patterns-architectural/src/main/resources/META-INF/persistence.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence        http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
+  <persistence-unit name="user-unit">
+    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+    <class>com.baeldung.pattern.daopattern.entities.User</class>
+    <properties>
+      <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
+      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://databaseurl"/>
+      <property name="javax.persistence.jdbc.user" value="username"/>
+      <property name="javax.persistence.jdbc.password" value="password"/>
+      <!-- Hibernate Properties -->
+      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
+      <property name="hibernate.show_sql" value="true"/>
+      <property name="hibernate.format_sql" value="true"/>
+    </properties>
+  </persistence-unit>
+</persistence>

patterns/design-patterns-architectural/src/test/java/com/baeldung/daopattern/test/UserDaoUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.daopattern.test;
+
+import com.baeldung.daopattern.daos.UserDao;
+import com.baeldung.daopattern.entities.User;
+import java.util.List;
+import java.util.Optional;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class UserDaoUnitTest {
+  
+    private static UserDao userDao;
+    
+    
+    @BeforeClass
+    public static void setUpUserDaoInstance() {
+        userDao = new UserDao();
+    }
+    
+    @Test
+    public void givenUserDaoInstance_whenCalledget_thenOneAssertion() {
+        assertThat(userDao.get(0)).isInstanceOf(Optional.class);
+    }
+    
+    @Test
+    public void givenUserDaoInstance_whenCalledgetAll_thenOneAssertion() {
+        assertThat(userDao.getAll()).isInstanceOf(List.class);
+    }
+    
+    @Test
+    public void givenUserDaoInstance_whenCalledupdate_thenTwoAssertions() {
+        User user = new User("Julie", "julie@domain.com");
+        userDao.update(user, new String[] {"Julie", "julie@domain.com"});
+        assertThat(userDao.get(2).get().getName()).isEqualTo("Julie");
+        assertThat(userDao.get(2).get().getEmail()).isEqualTo("julie@domain.com");
+    }
+    
+    @Test
+    public void givenUserDaoInstance_whenCalledsave_thenTwoAssertions() {
+        User user = new User("Julie", "julie@domain.com");
+        userDao.save(user);
+        assertThat(userDao.get(2).get().getName()).isEqualTo("Julie");
+        assertThat(userDao.get(2).get().getEmail()).isEqualTo("julie@domain.com");
+    }
+    
+    @Test
+    public void givenUserDaoInstance_whenCalleddelete_thenOneAssertion() {
+        User user = new User("Julie", "julie@domain.com");
+        userDao.delete(user);
+        assertThat(userDao.getAll().size()).isEqualTo(2);
+    }
+}

patterns/design-patterns-behavioral-2/README.md

@@ -0,0 +1,2 @@
+### Relevant Articles:
+- [Memento Design Pattern in Java](https://www.baeldung.com/java-memento-design-pattern)

patterns/design-patterns-behavioral-2/pom.xml

@@ -0,0 +1,33 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>design-patterns-behavioral-2</artifactId>
+    <version>1.0</version>
+    <name>design-patterns-behavioral-2</name>
+	<packaging>jar</packaging>
+	
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>patterns</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+	
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        
+        <assertj.version>3.12.2</assertj.version>
+    </properties>
+</project>

patterns/design-patterns-behavioral-2/src/main/java/com/baeldung/memento/TextEditor.java

@@ -0,0 +1,27 @@
+package com.baeldung.memento;
+
+public class TextEditor {
+
+    private TextWindow textWindow;
+    private TextWindowState savedTextWindow;
+
+    public TextEditor(TextWindow textWindow) {
+        this.textWindow = textWindow;
+    }
+
+    public void write(String text) {
+        textWindow.addText(text);
+    }
+
+    public String print() {
+        return textWindow.getCurrentText();
+    }
+
+    public void hitSave() {
+        savedTextWindow = textWindow.save();
+    }
+
+    public void hitUndo() {
+        textWindow.restore(savedTextWindow);
+    }
+}

patterns/design-patterns-behavioral-2/src/main/java/com/baeldung/memento/TextWindow.java

@@ -0,0 +1,26 @@
+package com.baeldung.memento;
+
+public class TextWindow {
+
+    private StringBuilder currentText;
+
+    public TextWindow() {
+        this.currentText = new StringBuilder();
+    }
+
+    public String getCurrentText() {
+        return currentText.toString();
+    }
+
+    public void addText(String text) {
+        currentText.append(text);
+    }
+
+    public TextWindowState save() {
+        return new TextWindowState(currentText.toString());
+    }
+
+    public void restore(TextWindowState save) {
+        currentText = new StringBuilder(save.getText());
+    }
+}

patterns/design-patterns-behavioral-2/src/main/java/com/baeldung/memento/TextWindowState.java

@@ -0,0 +1,14 @@
+package com.baeldung.memento;
+
+public class TextWindowState {
+
+    private String text;
+
+    public TextWindowState(String text) {
+        this.text = text;
+    }
+
+    public String getText() {
+        return text;
+    }
+}

patterns/design-patterns-behavioral-2/src/test/java/com/baeldung/memento/TextEditorUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.memento;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class TextEditorUnitTest {
+
+    @Test
+    void givenTextEditor_whenAddTextSaveAddMoreAndUndo_thenSavecStateRestored() {
+        TextEditor textEditor = new TextEditor(new TextWindow());
+        textEditor.write("The Memento Design Pattern\n");
+        textEditor.write("How to implement it in Java?\n");
+        textEditor.hitSave();
+        textEditor.write("Buy milk and eggs before coming home\n");
+        textEditor.hitUndo();
+
+        assertThat(textEditor.print()).isEqualTo("The Memento Design Pattern\nHow to implement it in Java?\n");
+    }
+}

patterns/design-patterns-behavioral/README.md

@@ -0,0 +1,11 @@
+### Relevant Articles:
+- [The Observer Pattern in Java](https://www.baeldung.com/java-observer-pattern)
+- [Visitor Design Pattern in Java](https://www.baeldung.com/java-visitor-pattern)
+- [Interpreter Design Pattern in Java](https://www.baeldung.com/java-interpreter-pattern)
+- [State Design Pattern in Java](https://www.baeldung.com/java-state-design-pattern)
+- [Implementing the Template Method Pattern in Java](https://www.baeldung.com/java-template-method-pattern)
+- [Chain of Responsibility Design Pattern in Java](https://www.baeldung.com/chain-of-responsibility-pattern)
+- [The Command Pattern in Java](https://www.baeldung.com/java-command-pattern)
+- [The Mediator Pattern in Java](https://www.baeldung.com/java-mediator-pattern)
+- [Introduction to the Null Object Pattern](https://www.baeldung.com/java-null-object-pattern)
+- [Avoid Check for Null Statement in Java](https://www.baeldung.com/java-avoid-null-check)

patterns/design-patterns-behavioral/pom.xml

@@ -0,0 +1,51 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>design-patterns-behavioral</artifactId>
+    <version>1.0</version>
+    <name>design-patterns-behavioral</name>
+	<packaging>jar</packaging>
+	
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>patterns</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>${intellij.annotations.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+	
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        
+        <intellij.annotations.version>16.0.2</intellij.annotations.version>
+        <assertj-core.version>3.9.1</assertj-core.version>
+    </properties>
+</project>

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/AuthenticationProcessor.java

@@ -0,0 +1,13 @@
+package com.baeldung.chainofresponsibility;
+
+public abstract class AuthenticationProcessor {
+
+    // next element in chain or responsibility
+    public AuthenticationProcessor nextProcessor;
+    
+    public AuthenticationProcessor(AuthenticationProcessor nextProcessor) {
+        this.nextProcessor = nextProcessor;
+    }
+
+    public abstract boolean isAuthorized(AuthenticationProvider authProvider);
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/AuthenticationProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public interface AuthenticationProvider {
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/OAuthAuthenticationProcessor.java

@@ -0,0 +1,21 @@
+package com.baeldung.chainofresponsibility;
+
+public class OAuthAuthenticationProcessor extends AuthenticationProcessor {
+
+    public OAuthAuthenticationProcessor(AuthenticationProcessor nextProcessor) {
+        super(nextProcessor);
+    }
+
+    @Override
+    public boolean isAuthorized(AuthenticationProvider authProvider) {
+
+        if (authProvider instanceof OAuthTokenProvider) {
+            return Boolean.TRUE;
+        } else if (nextProcessor != null) {
+            return nextProcessor.isAuthorized(authProvider);
+        } else {
+            return Boolean.FALSE;
+        }
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/OAuthTokenProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public class OAuthTokenProvider implements AuthenticationProvider {
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/SamlAuthenticationProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public class SamlAuthenticationProvider implements AuthenticationProvider {
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/UsernamePasswordAuthenticationProcessor.java

@@ -0,0 +1,20 @@
+package com.baeldung.chainofresponsibility;
+
+public class UsernamePasswordAuthenticationProcessor extends AuthenticationProcessor {
+
+    public UsernamePasswordAuthenticationProcessor(AuthenticationProcessor nextProcessor) {
+        super(nextProcessor);
+    }
+
+    @Override
+    public boolean isAuthorized(AuthenticationProvider authProvider) {
+        if (authProvider instanceof UsernamePasswordProvider) {
+            return Boolean.TRUE;
+        } else if (nextProcessor != null) {
+            return nextProcessor.isAuthorized(authProvider);
+        } else {
+            return Boolean.FALSE;
+        }
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/chainofresponsibility/UsernamePasswordProvider.java

@@ -0,0 +1,5 @@
+package com.baeldung.chainofresponsibility;
+
+public class UsernamePasswordProvider implements AuthenticationProvider {
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/command/client/TextFileApplication.java

@@ -0,0 +1,19 @@
+package com.baeldung.command.client;
+
+import com.baeldung.command.command.OpenTextFileOperation;
+import com.baeldung.command.command.SaveTextFileOperation;
+import com.baeldung.command.command.TextFileOperation;
+import com.baeldung.command.invoker.TextFileOperationExecutor;
+import com.baeldung.command.receiver.TextFile;
+
+public class TextFileApplication {
+    
+    public static void main(String[] args) {
+        
+        TextFileOperation openTextFileOperation = new OpenTextFileOperation(new TextFile("file1.txt"));
+        TextFileOperation saveTextFileOperation = new SaveTextFileOperation(new TextFile("file2.txt"));
+        TextFileOperationExecutor textFileOperationExecutor = new TextFileOperationExecutor();
+        System.out.println(textFileOperationExecutor.executeOperation(openTextFileOperation));
+        System.out.println(textFileOperationExecutor.executeOperation(saveTextFileOperation));
+    }   
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/command/command/OpenTextFileOperation.java

@@ -0,0 +1,17 @@
+package com.baeldung.command.command;
+
+import com.baeldung.command.receiver.TextFile;
+
+public class OpenTextFileOperation implements TextFileOperation {
+
+    private final TextFile textFile;
+    
+    public OpenTextFileOperation(TextFile textFile) {
+        this.textFile = textFile;
+    }
+    
+    @Override
+    public String execute() {
+        return textFile.open();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/command/command/SaveTextFileOperation.java

@@ -0,0 +1,17 @@
+package com.baeldung.command.command;
+
+import com.baeldung.command.receiver.TextFile;
+
+public class SaveTextFileOperation implements TextFileOperation {
+    
+    private final TextFile textFile;
+    
+    public SaveTextFileOperation(TextFile textFile) {
+        this.textFile = textFile;
+    }
+    
+    @Override
+    public String execute() {
+        return textFile.save();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/command/command/TextFileOperation.java

@@ -0,0 +1,8 @@
+package com.baeldung.command.command;
+
+@FunctionalInterface
+public interface TextFileOperation {
+    
+    String execute();
+    
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/command/invoker/TextFileOperationExecutor.java

@@ -0,0 +1,15 @@
+package com.baeldung.command.invoker;
+
+import com.baeldung.command.command.TextFileOperation;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TextFileOperationExecutor {
+    
+    private final List<TextFileOperation> textFileOperations = new ArrayList<>();
+    
+    public String executeOperation(TextFileOperation textFileOperation) {
+        textFileOperations.add(textFileOperation);
+        return textFileOperation.execute();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/command/receiver/TextFile.java

@@ -0,0 +1,34 @@
+package com.baeldung.command.receiver;
+
+public class TextFile {
+    
+    private final String name;
+    
+    public TextFile(String name) {
+        this.name = name;
+    }
+    
+    public String open() {
+        return "Opening file " + name;
+    }
+    
+    public String read() {  
+        return "Reading file " + name;
+    }
+    
+    public String write() {  
+        return "Writing to file " + name;
+    }
+    
+    public String save() {  
+        return "Saving file " + name;
+    }
+    
+    public String copy() {  
+        return "Copying file " + name;
+    }
+    
+    public String paste() {  
+        return "Pasting file " + name;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/Context.java

@@ -0,0 +1,107 @@
+package com.baeldung.interpreter;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class Context {
+
+    private static Map<String, List<Row>> tables = new HashMap<>();
+
+    static {
+        List<Row> list = new ArrayList<>();
+        list.add(new Row("John", "Doe"));
+        list.add(new Row("Jan", "Kowalski"));
+        list.add(new Row("Dominic", "Doom"));
+
+        tables.put("people", list);
+    }
+
+    private String table;
+    private String column;
+
+    /**
+     * Index of column to be shown in result.
+     * Calculated in {@link #setColumnMapper()}
+     */
+    private int colIndex = -1;
+
+    /**
+     * Default setup, used for clearing the context for next queries.
+     * See {@link Context#clear()}
+     */
+    private static final Predicate<String> matchAnyString = s -> s.length() > 0;
+    private static final Function<String, Stream<? extends String>> matchAllColumns = Stream::of;
+    /**
+     * Varies based on setup in subclasses of {@link Expression}
+     */
+    private Predicate<String> whereFilter = matchAnyString;
+    private Function<String, Stream<? extends String>> columnMapper = matchAllColumns;
+
+    void setColumn(String column) {
+        this.column = column;
+        setColumnMapper();
+    }
+
+    void setTable(String table) {
+        this.table = table;
+    }
+
+    void setFilter(Predicate<String> filter) {
+        whereFilter = filter;
+    }
+
+    /**
+     * Clears the context to defaults.
+     * No filters, match all columns.
+     */
+    void clear() {
+        column = "";
+        columnMapper = matchAllColumns;
+        whereFilter = matchAnyString;
+    }
+
+    List<String> search() {
+
+        List<String> result = tables.entrySet()
+                .stream()
+                .filter(entry -> entry.getKey().equalsIgnoreCase(table))
+                .flatMap(entry -> Stream.of(entry.getValue()))
+                .flatMap(Collection::stream)
+                .map(Row::toString)
+                .flatMap(columnMapper)
+                .filter(whereFilter)
+                .collect(Collectors.toList());
+
+        clear();
+
+        return result;
+    }
+
+    /**
+     * Sets column mapper based on {@link #column} attribute.
+     * Note: If column is unknown, will remain to look for all columns.
+     */
+    private void setColumnMapper() {
+        switch (column) {
+            case "*":
+                colIndex = -1;
+                break;
+            case "name":
+                colIndex = 0;
+                break;
+            case "surname":
+                colIndex = 1;
+                break;
+        }
+        if (colIndex != -1) {
+            columnMapper = s -> Stream.of(s.split(" ")[colIndex]);
+        }
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/Expression.java

@@ -0,0 +1,7 @@
+package com.baeldung.interpreter;
+
+import java.util.List;
+
+interface Expression {
+    List<String> interpret(Context ctx);
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/From.java

@@ -0,0 +1,27 @@
+package com.baeldung.interpreter;
+
+import java.util.List;
+
+class From implements Expression {
+
+    private String table;
+    private Where where;
+
+    From(String table) {
+        this.table = table;
+    }
+
+    From(String table, Where where) {
+        this.table = table;
+        this.where = where;
+    }
+
+    @Override
+    public List<String> interpret(Context ctx) {
+        ctx.setTable(table);
+        if (where == null) {
+            return ctx.search();
+        }
+        return where.interpret(ctx);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/InterpreterDemo.java

@@ -0,0 +1,23 @@
+package com.baeldung.interpreter;
+
+import java.util.List;
+
+
+public class InterpreterDemo {
+
+    public static void main(String[] args) {
+
+        Expression query = new Select("name", new From("people"));
+        Context ctx = new Context();
+        List<String> result = query.interpret(ctx);
+        System.out.println(result);
+
+        Expression query2 = new Select("*", new From("people"));
+        List<String> result2 = query2.interpret(ctx);
+        System.out.println(result2);
+
+        Expression query3 = new Select("name", new From("people", new Where(name -> name.toLowerCase().startsWith("d"))));
+        List<String> result3 = query3.interpret(ctx);
+        System.out.println(result3);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/Row.java

@@ -0,0 +1,17 @@
+package com.baeldung.interpreter;
+
+class Row {
+
+    private String name;
+    private String surname;
+
+    Row(String name, String surname) {
+        this.name = name;
+        this.surname = surname;
+    }
+
+    @Override
+    public String toString() {
+        return name + " " + surname;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/Select.java

@@ -0,0 +1,20 @@
+package com.baeldung.interpreter;
+
+import java.util.List;
+
+class Select implements Expression {
+
+    private String column;
+    private From from;
+
+    Select(String column, From from) {
+        this.column = column;
+        this.from = from;
+    }
+
+    @Override
+    public List<String> interpret(Context ctx) {
+        ctx.setColumn(column);
+        return from.interpret(ctx);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/interpreter/Where.java

@@ -0,0 +1,19 @@
+package com.baeldung.interpreter;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+class Where implements Expression {
+
+    private Predicate<String> filter;
+
+    Where(Predicate<String> filter) {
+        this.filter = filter;
+    }
+
+    @Override
+    public List<String> interpret(Context ctx) {
+        ctx.setFilter(filter);
+        return ctx.search();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/mediator/Button.java

@@ -0,0 +1,13 @@
+package com.baeldung.mediator;
+
+public class Button {
+    private Mediator mediator;
+
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    public void press() {
+        this.mediator.press();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/mediator/Fan.java

@@ -0,0 +1,24 @@
+package com.baeldung.mediator;
+
+public class Fan {
+    private Mediator mediator;
+    private boolean isOn = false;
+
+    public void setMediator(Mediator mediator) {
+        this.mediator = mediator;
+    }
+
+    public boolean isOn() {
+        return isOn;
+    }
+
+    public void turnOn() {
+        this.mediator.start();
+        isOn = true;
+    }
+
+    public void turnOff() {
+        isOn = false;
+        this.mediator.stop();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/mediator/Mediator.java

@@ -0,0 +1,37 @@
+package com.baeldung.mediator;
+
+public class Mediator {
+    private Button button;
+    private Fan fan;
+    private PowerSupplier powerSupplier;
+
+    public void setButton(Button button) {
+        this.button = button;
+        this.button.setMediator(this);
+    }
+
+    public void setFan(Fan fan) {
+        this.fan = fan;
+        this.fan.setMediator(this);
+    }
+
+    public void setPowerSupplier(PowerSupplier powerSupplier) {
+        this.powerSupplier = powerSupplier;
+    }
+
+    public void press() {
+        if (fan.isOn()) {
+            fan.turnOff();
+        } else {
+            fan.turnOn();
+        }
+    }
+
+    public void start() {
+        powerSupplier.turnOn();
+    }
+
+    public void stop() {
+        powerSupplier.turnOff();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/mediator/PowerSupplier.java

@@ -0,0 +1,11 @@
+package com.baeldung.mediator;
+
+public class PowerSupplier {
+    public void turnOn() {
+        // implementation
+    }
+
+    public void turnOff() {
+        // implementation
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/JmsRouter.java

@@ -0,0 +1,10 @@
+package com.baeldung.nullobject;
+
+public class JmsRouter implements Router {
+
+    @Override
+    public void route(Message msg) {
+        System.out.println("Routing to a JMS queue. Msg: " + msg);
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/Message.java

@@ -0,0 +1,24 @@
+package com.baeldung.nullobject;
+
+public class Message {
+
+    private String body;
+
+    private String priority;
+
+    public Message(String body, String priority) {
+        this.body = body;
+        this.priority = priority;
+    }
+
+    public String getPriority() {
+        return priority;
+    }
+
+    @Override
+    public String toString() {
+        return "{body='" + body + '\'' +
+                ", priority='" + priority + '\'' +
+                '}';
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/NullRouter.java

@@ -0,0 +1,10 @@
+package com.baeldung.nullobject;
+
+public class NullRouter implements Router {
+
+    @Override
+    public void route(Message msg) {
+        // do nothing
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/Router.java

@@ -0,0 +1,7 @@
+package com.baeldung.nullobject;
+
+public interface Router {
+
+    void route(Message msg);
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/RouterFactory.java

@@ -0,0 +1,23 @@
+package com.baeldung.nullobject;
+
+public class RouterFactory {
+
+    public static Router getRouterForMessage(Message msg) {
+
+        if (msg.getPriority() == null) {
+            return new NullRouter();
+        }
+
+        switch (msg.getPriority()) {
+            case "high":
+                return new SmsRouter();
+
+            case "medium":
+                return new JmsRouter();
+
+            default:
+                return new NullRouter();
+        }
+
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/RoutingHandler.java

@@ -0,0 +1,30 @@
+package com.baeldung.nullobject;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class RoutingHandler {
+
+    public void handle(Iterable<Message> messages){
+        for (Message msg : messages) {
+            Router router = RouterFactory.getRouterForMessage(msg);
+            router.route(msg);
+        }
+    }
+
+    public static void main(String[] args) {
+        Message highPriorityMsg = new Message("Alert!", "high");
+        Message mediumPriorityMsg = new Message("Warning!", "medium");
+        Message lowPriorityMsg = new Message("Take a look!", "low");
+        Message nullPriorityMsg = new Message("Take a look!", null);
+
+        List<Message> messages = Arrays.asList(highPriorityMsg,
+                mediumPriorityMsg,
+                lowPriorityMsg,
+                nullPriorityMsg);
+
+        RoutingHandler routingHandler = new RoutingHandler();
+        routingHandler.handle(messages);
+
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nullobject/SmsRouter.java

@@ -0,0 +1,10 @@
+package com.baeldung.nullobject;
+
+public class SmsRouter implements Router {
+
+    @Override
+    public void route(Message msg) {
+        System.out.println("Routing to a SMS gateway. Msg: " + msg);
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/APIContracts.java

@@ -0,0 +1,30 @@
+package com.baeldung.nulls;
+
+public class APIContracts {
+
+    /**
+     * Prints the value of {@code param} if not null. Prints {@code null} otherwise.
+     *
+     * @param param
+     */
+    public void print(Object param) {
+        System.out.println("Printing " + param);
+    }
+
+    /**
+     * @return non null result
+     * @throws Exception - if result is null
+     */
+    public Object process() throws Exception {
+        Object result = doSomething();
+        if (result == null) {
+            throw new Exception("Processing fail. Got a null response");
+        } else {
+            return result;
+        }
+    }
+
+    private Object doSomething() {
+        return null;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/Assertions.java

@@ -0,0 +1,13 @@
+package com.baeldung.nulls;
+
+public class Assertions {
+    
+    public void accept(Object param){
+        assert param != null;
+        
+        doSomething(param);
+    }
+
+    private void doSomething(Object param) {
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/EmptyCollections.java

@@ -0,0 +1,25 @@
+package com.baeldung.nulls;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class EmptyCollections {
+
+    public List<String> names() {
+        if (userExist()) {
+            return Stream.of(readName()).collect(Collectors.toList());
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    private boolean userExist() {
+        return false;
+    }
+
+    private String readName() {
+        return "test";
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/FindBugsAnnotations.java

@@ -0,0 +1,30 @@
+package com.baeldung.nulls;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+
+public class FindBugsAnnotations {
+
+    public void accept(@NotNull Object param) {
+        System.out.println(param.toString());
+    }
+
+    public void print(@Nullable Object param) {
+        System.out.println("Printing " + param);
+    }
+
+    @NotNull
+    public Object process() throws Exception {
+        Object result = doSomething();
+        if (result == null) {
+            throw new Exception("Processing fail. Got a null response");
+        } else {
+            return result;
+        }
+    }
+
+    private Object doSomething() {
+        return null;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/Preconditions.java

@@ -0,0 +1,39 @@
+package com.baeldung.nulls;
+
+public class Preconditions {
+
+    public void goodAccept(String one, String two, String three) {
+        if (one == null || two == null || three == null) {
+            throw new IllegalArgumentException();
+        }
+
+        process(one);
+        process(two);
+        process(three);
+    }
+
+    public void badAccept(String one, String two, String three) {
+        if (one == null) {
+            throw new IllegalArgumentException();
+        } else {
+            process(one);
+        }
+
+        if (two == null) {
+            throw new IllegalArgumentException();
+        } else {
+            process(two);
+        }
+
+        if (three == null) {
+            throw new IllegalArgumentException();
+        } else {
+            process(three);
+        }
+
+    }
+
+    private void process(String one) {
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/PrimitivesAndWrapper.java

@@ -0,0 +1,21 @@
+package com.baeldung.nulls;
+
+public class PrimitivesAndWrapper {
+
+    public static int primitiveSum(int a, int b) {
+        return a + b;
+    }
+
+    public static Integer wrapperSum(Integer a, Integer b) {
+        return a + b;
+    }
+
+    public static Integer goodSum(Integer a, Integer b) {
+        if (a != null && b != null) {
+            return a + b;
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/UsingLombok.java

@@ -0,0 +1,10 @@
+package com.baeldung.nulls;
+
+import lombok.NonNull;
+
+public class UsingLombok {
+
+    public void accept(@NonNull Object param){
+        System.out.println(param);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/UsingObjects.java

@@ -0,0 +1,11 @@
+package com.baeldung.nulls;
+
+import java.util.Objects;
+
+public class UsingObjects {
+
+    public void accept(Object param) {
+        Objects.requireNonNull(param);
+        // doSomething()
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/UsingOptional.java

@@ -0,0 +1,23 @@
+package com.baeldung.nulls;
+
+import java.util.Optional;
+
+public class UsingOptional {
+
+    public Optional<Object> process(boolean processed) {
+
+        String response = doSomething(processed);
+
+        return Optional.ofNullable(response);
+    }
+
+    private String doSomething(boolean processed) {
+
+        if (processed) {
+            return "passed";
+        } else {
+            return null;
+        }
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/nulls/UsingStringUtils.java

@@ -0,0 +1,22 @@
+package com.baeldung.nulls;
+
+import org.apache.commons.lang3.StringUtils;
+
+public class UsingStringUtils {
+
+    public void accept(String param) {
+        if (StringUtils.isNotEmpty(param)) {
+            System.out.println(param);
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public void acceptOnlyNonBlank(String param) {
+        if (StringUtils.isNotBlank(param)) {
+            System.out.println(param);
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/Channel.java

@@ -0,0 +1,5 @@
+package com.baeldung.observer;
+
+public interface Channel {
+    public void update(Object o);
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/NewsAgency.java

@@ -0,0 +1,24 @@
+package com.baeldung.observer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NewsAgency {
+    private String news;
+    private List<Channel> channels = new ArrayList<>();
+
+    public void addObserver(Channel channel) {
+        this.channels.add(channel);
+    }
+
+    public void removeObserver(Channel channel) {
+        this.channels.remove(channel);
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+        for (Channel channel : this.channels) {
+            channel.update(this.news);
+        }
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/NewsChannel.java

@@ -0,0 +1,20 @@
+package com.baeldung.observer;
+
+public class NewsChannel implements Channel {
+
+    private String news;
+
+    @Override
+    public void update(Object news) {
+        this.setNews((String) news);
+    }
+
+    public String getNews() {
+        return news;
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/ONewsAgency.java

@@ -0,0 +1,13 @@
+package com.baeldung.observer;
+
+import java.util.Observable;
+
+public class ONewsAgency extends Observable {
+    private String news;
+
+    public void setNews(String news) {
+        this.news = news;
+        setChanged();
+        notifyObservers(news);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/ONewsChannel.java

@@ -0,0 +1,22 @@
+package com.baeldung.observer;
+
+import java.util.Observable;
+import java.util.Observer;
+
+public class ONewsChannel implements Observer {
+
+    private String news;
+
+    @Override
+    public void update(Observable o, Object news) {
+        this.setNews((String) news);
+    }
+
+    public String getNews() {
+        return news;
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/PCLNewsAgency.java

@@ -0,0 +1,28 @@
+package com.baeldung.observer;
+
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+
+public class PCLNewsAgency {
+    private String news;
+
+    private PropertyChangeSupport support;
+
+    public PCLNewsAgency() {
+        support = new PropertyChangeSupport(this);
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener pcl) {
+        support.addPropertyChangeListener(pcl);
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener pcl) {
+        support.removePropertyChangeListener(pcl);
+    }
+
+    public void setNews(String value) {
+        support.firePropertyChange("news", this.news, value);
+        this.news = value;
+
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/observer/PCLNewsChannel.java

@@ -0,0 +1,21 @@
+package com.baeldung.observer;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+public class PCLNewsChannel implements PropertyChangeListener {
+
+    private String news;
+
+    public void propertyChange(PropertyChangeEvent evt) {
+        this.setNews((String) evt.getNewValue());
+    }
+
+    public String getNews() {
+        return news;
+    }
+
+    public void setNews(String news) {
+        this.news = news;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/state/DeliveredState.java

@@ -0,0 +1,25 @@
+package com.baeldung.state;
+
+public class DeliveredState implements PackageState {
+
+    @Override
+    public void next(Package pkg) {
+        pkg.setState(new ReceivedState());
+    }
+
+    @Override
+    public void prev(Package pkg) {
+        pkg.setState(new OrderedState());
+    }
+
+    @Override
+    public void printStatus() {
+        System.out.println("Package delivered to post office, not received yet.");
+    }
+
+    @Override
+    public String toString() {
+        return "DeliveredState{}";
+    }
+
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/state/OrderedState.java

@@ -0,0 +1,24 @@
+package com.baeldung.state;
+
+public class OrderedState implements PackageState {
+
+    @Override
+    public void next(Package pkg) {
+        pkg.setState(new DeliveredState());
+    }
+
+    @Override
+    public void prev(Package pkg) {
+        System.out.println("The package is in it's root state.");
+    }
+
+    @Override
+    public void printStatus() {
+        System.out.println("Package ordered, not delivered to the office yet.");
+    }
+
+    @Override
+    public String toString() {
+        return "OrderedState{}";
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/state/Package.java

@@ -0,0 +1,26 @@
+package com.baeldung.state;
+
+public class Package {
+
+    private PackageState state = new OrderedState();
+
+    public PackageState getState() {
+        return state;
+    }
+
+    public void setState(PackageState state) {
+        this.state = state;
+    }
+
+    public void previousState() {
+        state.prev(this);
+    }
+
+    public void nextState() {
+        state.next(this);
+    }
+
+    public void printStatus() {
+        state.printStatus();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/state/PackageState.java

@@ -0,0 +1,10 @@
+package com.baeldung.state;
+
+public interface PackageState {
+
+    void next(Package pkg);
+
+    void prev(Package pkg);
+
+    void printStatus();
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/state/ReceivedState.java

@@ -0,0 +1,24 @@
+package com.baeldung.state;
+
+public class ReceivedState implements PackageState {
+
+    @Override
+    public void next(Package pkg) {
+        System.out.println("This package is already received by a client.");
+    }
+
+    @Override
+    public void prev(Package pkg) {
+        pkg.setState(new DeliveredState());
+    }
+
+    @Override
+    public void printStatus() {
+        System.out.println("Package was received by client.");
+    }
+
+    @Override
+    public String toString() {
+        return "ReceivedState{}";
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/state/StateDemo.java

@@ -0,0 +1,19 @@
+package com.baeldung.state;
+
+public class StateDemo {
+
+    public static void main(String[] args) {
+
+        Package pkg = new Package();
+        pkg.printStatus();
+
+        pkg.nextState();
+        pkg.printStatus();
+
+        pkg.nextState();
+        pkg.printStatus();
+
+        pkg.nextState();
+        pkg.printStatus();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/application/Application.java

@@ -0,0 +1,19 @@
+package com.baeldung.templatemethod.application;
+
+import com.baeldung.templatemethod.model.Computer;
+import com.baeldung.templatemethod.model.ComputerBuilder;
+import com.baeldung.templatemethod.model.HighEndComputerBuilder;
+import com.baeldung.templatemethod.model.StandardComputerBuilder;
+
+public class Application {
+    
+    public static void main(String[] args) {
+        ComputerBuilder standardComputerBuilder = new StandardComputerBuilder();
+        Computer standardComputer = standardComputerBuilder.buildComputer();
+        standardComputer.getComputerParts().forEach((k, v) -> System.out.println("Part : " + k + " Value : " + v));
+        
+        ComputerBuilder highEndComputerBuilder = new HighEndComputerBuilder();
+        Computer highEndComputer = highEndComputerBuilder.buildComputer();
+        highEndComputer.getComputerParts().forEach((k, v) -> System.out.println("Part : " + k + " Value : " + v));
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/model/Computer.java

@@ -0,0 +1,17 @@
+package com.baeldung.templatemethod.model;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Computer {
+    
+    private Map<String, String> computerParts = new HashMap<>();
+    
+    public Computer(Map<String, String> computerParts) {
+        this.computerParts = computerParts;
+    }
+    
+    public Map<String, String> getComputerParts() {
+        return computerParts;
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/model/ComputerBuilder.java

@@ -0,0 +1,37 @@
+package com.baeldung.templatemethod.model;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public abstract class ComputerBuilder {
+
+    protected Map<String, String> computerParts = new HashMap<>();
+    protected List<String> motherboardSetupStatus = new ArrayList<>();
+    
+    public final Computer buildComputer() {
+        addMotherboard();
+        setupMotherboard();
+        addProcessor();
+        return getComputer();
+    }
+    
+    public abstract void addMotherboard();
+
+    public abstract void setupMotherboard();
+    
+    public abstract void addProcessor();
+
+    public List<String> getMotherboardSetupStatus() {
+        return motherboardSetupStatus;
+    }
+    
+    public Map<String, String> getComputerParts() {
+        return computerParts;
+    }
+    
+    private Computer getComputer() {
+        return new Computer(computerParts);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/model/HighEndComputer.java

@@ -0,0 +1,10 @@
+package com.baeldung.templatemethod.model;
+
+import java.util.Map;
+
+public class HighEndComputer extends Computer {
+    
+    public HighEndComputer(Map<String, String> computerParts) {
+        super(computerParts);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/model/HighEndComputerBuilder.java

@@ -0,0 +1,21 @@
+package com.baeldung.templatemethod.model;
+
+public class HighEndComputerBuilder extends ComputerBuilder {
+
+    @Override
+    public void addMotherboard() {
+        computerParts.put("Motherboard", "High-end Motherboard");
+    }
+    
+    @Override
+    public void setupMotherboard() {
+        motherboardSetupStatus.add("Screwing the high-end motherboard to the case.");
+        motherboardSetupStatus.add("Pluging in the power supply connectors.");
+        motherboardSetupStatus.forEach(step -> System.out.println(step));
+    }
+    
+    @Override
+    public void addProcessor() {
+        computerParts.put("Processor", "High-end Processor");
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/model/StandardComputer.java

@@ -0,0 +1,10 @@
+package com.baeldung.templatemethod.model;
+
+import java.util.Map;
+
+public class StandardComputer extends Computer {
+    
+    public StandardComputer(Map<String, String> computerParts) {
+        super(computerParts);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/templatemethod/model/StandardComputerBuilder.java

@@ -0,0 +1,21 @@
+package com.baeldung.templatemethod.model;
+ 
+public class StandardComputerBuilder extends ComputerBuilder {
+
+    @Override
+    public void addMotherboard() {
+        computerParts.put("Motherboard", "Standard Motherboard");
+    }
+    
+    @Override
+    public void setupMotherboard() {
+        motherboardSetupStatus.add("Screwing the standard motherboard to the case.");
+        motherboardSetupStatus.add("Pluging in the power supply connectors.");
+        motherboardSetupStatus.forEach(step -> System.out.println(step));
+    }
+    
+    @Override
+    public void addProcessor() {
+        computerParts.put("Processor", "Standard Processor");
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/Document.java

@@ -0,0 +1,20 @@
+package com.baeldung.visitor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Document extends Element {
+
+    List<Element> elements = new ArrayList<>();
+
+    public Document(String uuid) {
+        super(uuid);
+    }
+
+    @Override
+    public void accept(Visitor v) {
+        for (Element e : this.elements) {
+            e.accept(v);
+        }
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/Element.java

@@ -0,0 +1,12 @@
+package com.baeldung.visitor;
+
+public abstract class Element {
+
+    public String uuid;
+
+    public Element(String uuid) {
+        this.uuid = uuid;
+    }
+
+    public abstract void accept(Visitor v);
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/ElementVisitor.java

@@ -0,0 +1,14 @@
+package com.baeldung.visitor;
+
+public class ElementVisitor implements Visitor {
+
+    @Override
+    public void visit(XmlElement xe) {
+        System.out.println("processing xml element with uuid: " + xe.uuid);
+    }
+
+    @Override
+    public void visit(JsonElement je) {
+        System.out.println("processing json element with uuid: " + je.uuid);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/JsonElement.java

@@ -0,0 +1,12 @@
+package com.baeldung.visitor;
+
+public class JsonElement extends Element {
+
+    public JsonElement(String uuid) {
+        super(uuid);
+    }
+
+    public void accept(Visitor v) {
+        v.visit(this);
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/Visitor.java

@@ -0,0 +1,8 @@
+package com.baeldung.visitor;
+
+public interface Visitor {
+
+    void visit(XmlElement xe);
+
+    void visit(JsonElement je);
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/VisitorDemo.java

@@ -0,0 +1,23 @@
+package com.baeldung.visitor;
+
+import java.util.UUID;
+
+public class VisitorDemo {
+
+    public static void main(String[] args) {
+
+        Visitor v = new ElementVisitor();
+
+        Document d = new Document(generateUuid());
+        d.elements.add(new JsonElement(generateUuid()));
+        d.elements.add(new JsonElement(generateUuid()));
+        d.elements.add(new XmlElement(generateUuid()));
+
+        d.accept(v);
+    }
+
+    private static String generateUuid() {
+        return UUID.randomUUID()
+            .toString();
+    }
+}

patterns/design-patterns-behavioral/src/main/java/com/baeldung/visitor/XmlElement.java

@@ -0,0 +1,12 @@
+package com.baeldung.visitor;
+
+public class XmlElement extends Element {
+
+    public XmlElement(String uuid) {
+        super(uuid);
+    }
+
+    public void accept(Visitor v) {
+        v.visit(this);
+    }
+}

patterns/design-patterns-behavioral/src/test/java/com/baeldung/chainofresponsibility/ChainOfResponsibilityIntegrationTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.chainofresponsibility;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class ChainOfResponsibilityIntegrationTest {
+
+    private static AuthenticationProcessor getChainOfAuthProcessor() {
+
+        AuthenticationProcessor oAuthProcessor = new OAuthAuthenticationProcessor(null);
+        AuthenticationProcessor unamePasswordProcessor = new UsernamePasswordAuthenticationProcessor(oAuthProcessor);
+        return unamePasswordProcessor;
+    }
+
+    @Test
+    public void givenOAuthProvider_whenCheckingAuthorized_thenSuccess() {
+        AuthenticationProcessor authProcessorChain = getChainOfAuthProcessor();
+        boolean isAuthorized = authProcessorChain.isAuthorized(new OAuthTokenProvider());
+        assertTrue(isAuthorized);
+    }
+
+    @Test
+    public void givenUsernamePasswordProvider_whenCheckingAuthorized_thenSuccess() {
+        AuthenticationProcessor authProcessorChain = getChainOfAuthProcessor();
+        boolean isAuthorized = authProcessorChain.isAuthorized(new UsernamePasswordProvider());
+        assertTrue(isAuthorized);
+    }
+
+    @Test
+    public void givenSamlAuthProvider_whenCheckingAuthorized_thenFailure() {
+        AuthenticationProcessor authProcessorChain = getChainOfAuthProcessor();
+        boolean isAuthorized = authProcessorChain.isAuthorized(new SamlAuthenticationProvider());
+        assertTrue(!isAuthorized);
+    }
+
+}

patterns/design-patterns-behavioral/src/test/java/com/baeldung/command/test/OpenTextFileOperationUnitTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.command.test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+import com.baeldung.command.command.OpenTextFileOperation;
+import com.baeldung.command.command.TextFileOperation;
+import com.baeldung.command.receiver.TextFile;
+
+public class OpenTextFileOperationUnitTest {
+    
+    @Test
+    public void givenOpenTextFileOperationIntance_whenCalledExecuteMethod_thenOneAssertion() {
+        TextFileOperation openTextFileOperation = new OpenTextFileOperation(new TextFile("file1.txt"));
+        assertThat(openTextFileOperation.execute()).isEqualTo("Opening file file1.txt");
+    }
+}

patterns/design-patterns-behavioral/src/test/java/com/baeldung/command/test/SaveTextFileOperationUnitTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.command.test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+import com.baeldung.command.command.SaveTextFileOperation;
+import com.baeldung.command.command.TextFileOperation;
+import com.baeldung.command.receiver.TextFile;
+
+public class SaveTextFileOperationUnitTest {
+    
+    @Test
+    public void givenSaveTextFileOperationIntance_whenCalledExecuteMethod_thenOneAssertion() {
+        TextFileOperation openTextFileOperation = new SaveTextFileOperation(new TextFile("file1.txt"));
+        assertThat(openTextFileOperation.execute()).isEqualTo("Saving file file1.txt");
+    }
+}

patterns/design-patterns-behavioral/src/test/java/com/baeldung/command/test/TextFileOperationExecutorUnitTest.java

@@ -0,0 +1,78 @@
+package com.baeldung.command.test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.function.Function;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.command.command.OpenTextFileOperation;
+import com.baeldung.command.command.SaveTextFileOperation;
+import com.baeldung.command.command.TextFileOperation;
+import com.baeldung.command.invoker.TextFileOperationExecutor;
+import com.baeldung.command.receiver.TextFile;
+
+public class TextFileOperationExecutorUnitTest {
+    
+    private static TextFileOperationExecutor textFileOperationExecutor;
+    
+    
+    @BeforeClass
+    public static void setUpTextFileOperationExecutor() {
+        textFileOperationExecutor = new TextFileOperationExecutor();
+    }
+    
+    @Test
+    public void givenTextFileOPerationExecutorInstance_whenCalledexecuteOperationWithOpenTextOperation_thenOneAssertion() {
+        TextFileOperation textFileOperation = new OpenTextFileOperation(new TextFile("file1.txt"));
+        assertThat(textFileOperationExecutor.executeOperation(textFileOperation)).isEqualTo("Opening file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileOPerationExecutorInstance_whenCalledexecuteOperationWithSaveTextOperation_thenOneAssertion() {
+        TextFileOperation textFileOperation = new SaveTextFileOperation(new TextFile("file1.txt"));
+        assertThat(textFileOperationExecutor.executeOperation(textFileOperation)).isEqualTo("Saving file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileOperationExecutorInstance_whenCalledexecuteOperationWithTextFileOpenLambda_thenOneAssertion() {
+        assertThat(textFileOperationExecutor.executeOperation(() -> {return "Opening file file1.txt";})).isEqualTo("Opening file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileOperationExecutorInstance_whenCalledexecuteOperationWithTextFileSaveLambda_thenOneAssertion() {
+        assertThat(textFileOperationExecutor.executeOperation(() -> {return "Saving file file1.txt";})).isEqualTo("Saving file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileOperationExecutorInstance_whenCalledexecuteOperationWithTextFileOpenMethodReferenceOfExistingObject_thenOneAssertion() {
+        TextFile textFile = new TextFile("file1.txt");
+        assertThat(textFileOperationExecutor.executeOperation(textFile::open)).isEqualTo("Opening file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileOperationExecutorInstance_whenCalledexecuteOperationWithTextFileSaveMethodReferenceOfExistingObject_thenOneAssertion() {
+        TextFile textFile = new TextFile("file1.txt");
+        assertThat(textFileOperationExecutor.executeOperation(textFile::save)).isEqualTo("Saving file file1.txt");
+    }
+    
+    @Test
+    public void givenOpenTextFileOperationExecuteMethodReference_whenCalledApplyMethod_thenOneAssertion() {
+        Function<OpenTextFileOperation, String> executeMethodReference = OpenTextFileOperation::execute;
+        assertThat(executeMethodReference.apply(new OpenTextFileOperation(new TextFile("file1.txt")))).isEqualTo("Opening file file1.txt"); 
+    }
+    
+    @Test
+    public void givenSaveTextFileOperationExecuteMethodReference_whenCalledApplyMethod_thenOneAssertion() {
+        Function<SaveTextFileOperation, String> executeMethodReference = SaveTextFileOperation::execute;
+        assertThat(executeMethodReference.apply(new SaveTextFileOperation(new TextFile("file1.txt")))).isEqualTo("Saving file file1.txt"); 
+    }
+    
+    @Test
+    public void givenOpenAndSaveTextFileOperationExecutorInstance_whenCalledExecuteOperationWithLambdaExpression_thenBothAssertion() {
+        TextFileOperationExecutor textFileOperationExecutor = new TextFileOperationExecutor();
+        assertThat(textFileOperationExecutor.executeOperation(() -> "Opening file file1.txt")).isEqualTo("Opening file file1.txt");
+        assertThat(textFileOperationExecutor.executeOperation(() -> "Saving file file1.txt")).isEqualTo("Saving file file1.txt");
+    }
+}

patterns/design-patterns-behavioral/src/test/java/com/baeldung/command/test/TextFileUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.command.test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.command.receiver.TextFile;
+
+public class TextFileUnitTest {
+    
+    private static TextFile textFile;
+    
+    
+    @BeforeClass
+    public static void setUpTextFileInstance() {
+        textFile = new TextFile("file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileInstance_whenCalledopenMethod_thenOneAssertion() {
+        assertThat(textFile.open()).isEqualTo("Opening file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileInstance_whenCalledwriteMethod_thenOneAssertion() {
+        assertThat(textFile.write()).isEqualTo("Writing to file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileInstance_whenCalledsaveMethod_thenOneAssertion() {
+        assertThat(textFile.save()).isEqualTo("Saving file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileInstance_whenCalledcopyMethod_thenOneAssertion() {
+        assertThat(textFile.copy()).isEqualTo("Copying file file1.txt");
+    }
+    
+    @Test
+    public void givenTextFileInstance_whenCalledpasteMethod_thenOneAssertion() {
+        assertThat(textFile.paste()).isEqualTo("Pasting file file1.txt");
+    }
+}