Maven Project - LinkedHashMap and LinkedHashSet usage Along with JUnit Testing

public class GeekArticles {
    public GeekArticles(String articleName, int articleId, String publishedUnder, int rating, String authorName) {
        super();
        this.articleName = articleName;
        this.articleId = articleId;
        this.publishedUnder = publishedUnder;
        this.rating = rating;
        this.authorName = authorName;
    }

    public GeekArticles() {
        // via setter methods, rest fields are done
    }

    String articleName;
    int articleId;
    String publishedUnder;
    int rating;
    String authorName;    

    public String getArticleName() {
        return articleName;
    }

    public void setArticleName(String articleName) {
        this.articleName = articleName;
    }

    public int getArticleId() {
        return articleId;
    }

    public void setArticleId(int articleId) {
        this.articleId = articleId;
    }

    public String getPublishedUnder() {
        return publishedUnder;
    }

    public void setPublishedUnder(String publishedUnder) {
        this.publishedUnder = publishedUnder;
    }

    public int getRating() {
        return rating;
    }

    public void setRating(int rating) {
        this.rating = rating;
    }

    public String getAuthorName() {
        return authorName;
    }

    public void setAuthorName(String authorName) {
        this.authorName = authorName;
    }

    // We need to override 2 methods namely 
    // equals and hashcode whenever we no need
    // to store two article objects     
    // if their names are same
    @Override
    public boolean equals(Object o) {
        if (o instanceof GeekArticles) {
            GeekArticles other = (GeekArticles) o;
            return articleName.equals(other.getArticleName());
        }

        return false;
    }

    @Override
    public int hashCode() {
        return articleName.hashCode();
    }

}

import java.util.LinkedHashMap;

public class LinkedHashMapSample {
    // In order to represent LinkedHashMap does not allow 
    // duplicates in a LinkedHashMap for the same key "Excellent",
    // two separate article data is added
    // Though adding is allowed, instead of keeping 
    // 3 different entries, only 2 will be the size and for
    // "Excellent" key, last data is updated
    public int addArticles(LinkedHashMap articleMap) 
    {
        articleMap.put("Excellent",new GeekArticles("DSA", 1, "DSA", 10,"GeekA"));
        articleMap.put("Best",new GeekArticles("JavaProgramming", 2, "Java", 9,"GeekA")); 
        articleMap.put("Excellent",new GeekArticles("SoftwareTesting", 3, "Testing", 10,"GeekB")); 
        return articleMap.size();
    }
    public int getArticles(LinkedHashMap articles) {
        return articles.size();
    }
    public String getArticleName(LinkedHashMap articleMap,String articleNameKey) {
        GeekArticles geekArticles = new GeekArticles();
        if (articleMap.containsKey(articleNameKey)) {
            // Mapping the retrieved value
            geekArticles = (GeekArticles) articleMap.get(articleNameKey);            
        }
        return geekArticles.getArticleName();
    }
    public String getAuthorName(LinkedHashMap articleMap,String articleNameKey) {
        GeekArticles geekArticles = new GeekArticles();
        if (articleMap.containsKey(articleNameKey)) {
            // Mapping the retrieved value
            geekArticles = (GeekArticles) articleMap.get(articleNameKey);            
        }
        return geekArticles.getAuthorName();
    }
}

import java.util.LinkedHashSet;

public class LinkedHashSetSample {    
    public int addArticlesViaLinkedHashSet(LinkedHashSet articleSet) 
    {
        GeekArticles dsa = new GeekArticles("DSA", 1, "DSA", 10,"GeekA");
        GeekArticles javaProgramming = new GeekArticles("JavaProgramming", 1, "Java", 9,"GeekA");
        GeekArticles dsaProgramming = new GeekArticles("DSA", 1, "DSA", 10,"GeekB");
        articleSet.add(dsa);
        articleSet.add(javaProgramming); 
        articleSet.add(dsaProgramming);        
        return articleSet.size();
    }
    public int getArticles(LinkedHashSet articlesSet) {
        return articlesSet.size();
    }
    
    public String getArticleName(LinkedHashSet article,GeekArticles geekArticle) {
        if (article.contains(geekArticle)) {
            // Mapping the retrieved value
            return geekArticle.getArticleName();            
        }
        return null;
    }
    public String getAuthorName(LinkedHashSet article,GeekArticles geekArticle) {
        if (article.contains(geekArticle)) {
            // Mapping the retrieved value
            return geekArticle.getAuthorName();            
        }
        return null;
    }
}

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class TestLinkedCollectionServicesJava {
    @DisplayName("Test check for adding geekarticles in LinkedHashMap collection ")
    @Test
    public void testCheckForAdditionOfArticlesInLinkedHashMap() {
        LinkedHashMap<String,GeekArticles> articles = new LinkedHashMap<String,GeekArticles>();
        LinkedHashMapSample linkedHashMapServicesObject = new LinkedHashMapSample();
        assertEquals(true, linkedHashMapServicesObject.getArticles(articles) == 0);
        // adding few articles
        linkedHashMapServicesObject.addArticles(articles);
        // "Excellent" key is duplicated and hence we expect only 2
        assertEquals(true, linkedHashMapServicesObject.getArticles(articles) == 2);
        // "Excellent" key is duplicated, now lets assert that the last 
        // taken value is updated for "Excellent" key
        assertEquals(true, linkedHashMapServicesObject.getArticleName(articles,"Excellent").equalsIgnoreCase("SoftwareTesting"));
        assertEquals(true, linkedHashMapServicesObject.getAuthorName(articles,"Excellent").equalsIgnoreCase("GeekB"));
        assertTrue(linkedHashMapServicesObject.getAuthorName(articles,"Excellent").equalsIgnoreCase("GeekB"));
        // "Best" key is available only once,
        assertEquals(true, linkedHashMapServicesObject.getArticleName(articles,"Best").equalsIgnoreCase("JavaProgramming"));
        assertTrue(linkedHashMapServicesObject.getArticleName(articles,"Best").equalsIgnoreCase("JavaProgramming"));
                
    }
    @DisplayName("Test check for adding geekarticles in LinkedHashSet collection ")
    @Test
    public void testCheckForAdditionOfAuthorsInLinkedHashSet() {
        LinkedHashSet<GeekArticles> articles = new LinkedHashSet<GeekArticles>();
        LinkedHashSetSample collectionObject = new LinkedHashSetSample();
        assertEquals(true, collectionObject.getArticles(articles) == 0);
        // adding few articles
        collectionObject.addArticlesViaLinkedHashSet(articles);
        // "dsa" article is duplicated and since we have 
        // overridden equals and hashcode method,
        // only 1 time "dsa" named article is added and hence
        // the total number of articles are 2
        assertEquals(true, collectionObject.getArticles(articles) == 2);
        GeekArticles dsa = new GeekArticles("DSA", 1, "DSA", 10,"GeekA");
        // "dsa" article is duplicated and since we have overridden equals and hashcode method,
        // duplicates are not allowed and hence we get only "dsa" as the output
        assertEquals(true, collectionObject.getArticleName(articles,dsa).equalsIgnoreCase("DSA"));
        assertTrue(collectionObject.getArticleName(articles,dsa).equalsIgnoreCase("DSA"));
        assertEquals(true, collectionObject.getAuthorName(articles,dsa).equalsIgnoreCase("GeekA"));
        assertTrue(collectionObject.getAuthorName(articles,dsa).equalsIgnoreCase("GeekA"));
    }
}