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

[BAEL-12897] - Moved set related articles from core-java-collections, core-java to core-java-collections-set

Browse Source
This commit is contained in:
amit2103
2019-04-28 23:25:52 +05:30
parent a6b462c7eb
commit 566ce43d90
7 changed files with 5 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core-java-collections/src/test/java/com/baeldung/collection/WhenUsingHashSet.java
-93
View File
@@ -1,93 +0,0 @@
package com.baeldung.collection;
import java.util.ConcurrentModificationException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.junit.Assert;
import org.junit.Test;
public class WhenUsingHashSet {
@Test
public void whenAddingElement_shouldAddElement() {
Set<String> hashset = new HashSet<>();
Assert.assertTrue(hashset.add("String Added"));
}
@Test
public void whenCheckingForElement_shouldSearchForElement() {
Set<String> hashsetContains = new HashSet<>();
hashsetContains.add("String Added");
Assert.assertTrue(hashsetContains.contains("String Added"));
}
@Test
public void whenCheckingTheSizeOfHashSet_shouldReturnThesize() {
Set<String> hashSetSize = new HashSet<>();
hashSetSize.add("String Added");
Assert.assertEquals(1, hashSetSize.size());
}
@Test
public void whenCheckingForEmptyHashSet_shouldCheckForEmpty() {
Set<String> emptyHashSet = new HashSet<>();
Assert.assertTrue(emptyHashSet.isEmpty());
}
@Test
public void whenRemovingElement_shouldRemoveElement() {
Set<String> removeFromHashSet = new HashSet<>();
removeFromHashSet.add("String Added");
Assert.assertTrue(removeFromHashSet.remove("String Added"));
}
@Test
public void whenClearingHashSet_shouldClearHashSet() {
Set<String> clearHashSet = new HashSet<>();
clearHashSet.add("String Added");
clearHashSet.clear();
Assert.assertTrue(clearHashSet.isEmpty());
}
@Test
public void whenIteratingHashSet_shouldIterateHashSet() {
Set<String> hashset = new HashSet<>();
hashset.add("First");
hashset.add("Second");
hashset.add("Third");
Iterator<String> itr = hashset.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
@Test(expected = ConcurrentModificationException.class)
public void whenModifyingHashSetWhileIterating_shouldThrowException() {
Set<String> hashset = new HashSet<>();
hashset.add("First");
hashset.add("Second");
hashset.add("Third");
Iterator<String> itr = hashset.iterator();
while (itr.hasNext()) {
itr.next();
hashset.remove("Second");
}
}
@Test
public void whenRemovingElementUsingIterator_shouldRemoveElement() {
Set<String> hashset = new HashSet<>();
hashset.add("First");
hashset.add("Second");
hashset.add("Third");
Iterator<String> itr = hashset.iterator();
while (itr.hasNext()) {
String element = itr.next();
if (element.equals("Second"))
itr.remove();
}
Assert.assertEquals(2, hashset.size());
}
}
core-java-collections/src/test/java/com/baeldung/collection/WhenUsingTreeSet.java
-228
View File
@@ -1,228 +0,0 @@
package com.baeldung.collection;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import org.junit.Assert;
import org.junit.Test;
public class WhenUsingTreeSet {
private static class Element {
private Integer id;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Override
public String toString() {
return id.toString();
}
}
private Comparator<Element> comparator = (ele1, ele2) -> {
return ele1.getId()
.compareTo(ele2.getId());
};
@Test
public void whenAddingElement_shouldAddElement() {
Set<String> treeSet = new TreeSet<>();
Assert.assertTrue(treeSet.add("String Added"));
}
@Test
public void whenCheckingForElement_shouldSearchForElement() {
Set<String> treeSetContains = new TreeSet<>();
treeSetContains.add("String Added");
Assert.assertTrue(treeSetContains.contains("String Added"));
}
@Test
public void whenRemovingElement_shouldRemoveElement() {
Set<String> removeFromTreeSet = new TreeSet<>();
removeFromTreeSet.add("String Added");
Assert.assertTrue(removeFromTreeSet.remove("String Added"));
}
@Test
public void whenClearingTreeSet_shouldClearTreeSet() {
Set<String> clearTreeSet = new TreeSet<>();
clearTreeSet.add("String Added");
clearTreeSet.clear();
Assert.assertTrue(clearTreeSet.isEmpty());
}
@Test
public void whenCheckingTheSizeOfTreeSet_shouldReturnThesize() {
Set<String> treeSetSize = new TreeSet<>();
treeSetSize.add("String Added");
Assert.assertEquals(1, treeSetSize.size());
}
@Test
public void whenCheckingForEmptyTreeSet_shouldCheckForEmpty() {
Set<String> emptyTreeSet = new TreeSet<>();
Assert.assertTrue(emptyTreeSet.isEmpty());
}
@Test
public void whenIteratingTreeSet_shouldIterateTreeSetInAscendingOrder() {
Set<String> treeSet = new TreeSet<>();
treeSet.add("First");
treeSet.add("Second");
treeSet.add("Third");
Iterator<String> itr = treeSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
@Test
public void whenIteratingTreeSet_shouldIterateTreeSetInDescendingOrder() {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("First");
treeSet.add("Second");
treeSet.add("Third");
Iterator<String> itr = treeSet.descendingIterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
@Test(expected = ConcurrentModificationException.class)
public void whenModifyingTreeSetWhileIterating_shouldThrowException() {
Set<String> treeSet = new TreeSet<>();
treeSet.add("First");
treeSet.add("Second");
treeSet.add("Third");
Iterator<String> itr = treeSet.iterator();
while (itr.hasNext()) {
itr.next();
treeSet.remove("Second");
}
}
@Test
public void whenRemovingElementUsingIterator_shouldRemoveElement() {
Set<String> treeSet = new TreeSet<>();
treeSet.add("First");
treeSet.add("Second");
treeSet.add("Third");
Iterator<String> itr = treeSet.iterator();
while (itr.hasNext()) {
String element = itr.next();
if (element.equals("Second"))
itr.remove();
}
Assert.assertEquals(2, treeSet.size());
}
@Test(expected = NullPointerException.class)
public void whenAddingNullToNonEmptyTreeSet_shouldThrowException() {
Set<String> treeSet = new TreeSet<>();
treeSet.add("First");
treeSet.add(null);
}
@Test
public void whenCheckingFirstElement_shouldReturnFirstElement() {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("First");
Assert.assertEquals("First", treeSet.first());
}
@Test
public void whenCheckingLastElement_shouldReturnLastElement() {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("First");
treeSet.add("Last");
Assert.assertEquals("Last", treeSet.last());
}
@Test
public void whenUsingComparator_shouldSortAndInsertElements() {
Set<Element> treeSet = new TreeSet<>(comparator);
Element ele1 = new Element();
ele1.setId(100);
Element ele2 = new Element();
ele2.setId(200);
treeSet.add(ele1);
treeSet.add(ele2);
System.out.println(treeSet);
}
@Test
public void whenUsingHeadSet_shouldReturnElementsLessThanSpecifiedElement() {
Set<Element> treeSet = new TreeSet<>(comparator);
Element ele1 = new Element();
ele1.setId(100);
Element ele2 = new Element();
ele2.setId(200);
treeSet.add(ele1);
treeSet.add(ele2);
System.out.println(treeSet);
}
@Test
public void whenUsingSubSet_shouldReturnSubSetElements() {
SortedSet<Integer> treeSet = new TreeSet<>();
treeSet.add(1);
treeSet.add(2);
treeSet.add(3);
treeSet.add(4);
treeSet.add(5);
treeSet.add(6);
Set<Integer> expectedSet = new TreeSet<>();
expectedSet.add(2);
expectedSet.add(3);
expectedSet.add(4);
expectedSet.add(5);
Set<Integer> subSet = treeSet.subSet(2, 6);
Assert.assertEquals(expectedSet, subSet);
}
@Test
public void whenUsingHeadSet_shouldReturnHeadSetElements() {
SortedSet<Integer> treeSet = new TreeSet<>();
treeSet.add(1);
treeSet.add(2);
treeSet.add(3);
treeSet.add(4);
treeSet.add(5);
treeSet.add(6);
Set<Integer> subSet = treeSet.headSet(6);
Assert.assertEquals(subSet, treeSet.subSet(1, 6));
}
@Test
public void whenUsingTailSet_shouldReturnTailSetElements() {
NavigableSet<Integer> treeSet = new TreeSet<>();
treeSet.add(1);
treeSet.add(2);
treeSet.add(3);
treeSet.add(4);
treeSet.add(5);
treeSet.add(6);
Set<Integer> subSet = treeSet.tailSet(3);
Assert.assertEquals(subSet, treeSet.subSet(3, true, 6, true));
}
}
core-java-collections/src/test/java/com/baeldung/java/set/HashSetInitalizingUnitTest.java
-70
View File
@@ -1,70 +0,0 @@
package com.baeldung.java.set;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
public class HashSetInitalizingUnitTest {
@Test
public void whenUsingJava_usingArraysStaticMethod_thenCorrectSize() {
Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
assertEquals(3, set.size());
}
@Test
public void whenUsingJava_usingAnonymousClass_thenCorrectSize() {
Set<String> set = new HashSet<String>(){{
add("a");
add("b");
add("c");
}};
assertEquals(3, set.size());
}
@Test
public void whenUsingJava_creatingSingletonSet_thenCorrectSize() {
Set<String> set = Collections.singleton("a");
assertEquals(1, set.size());
}
public static final <T> Set<T> newHashSet(T... objs) {
Set<T> set = new HashSet<T>();
Collections.addAll(set, objs);
return set;
}
@Test
public void whenUsingJava_usingCustomStaticUtilMethod_thenCorrectSize() {
Set<String> set = newHashSet("a","b","c");
assertEquals(3, set.size());
}
@Test
public void whenUsingJava8_usingCollectOnStream_thenCorrectSize() {
Set<String> set = Stream.of("a", "b", "c").collect(Collectors.toCollection(HashSet::new));
assertEquals(3, set.size());
}
@Test
public void whenUsingGoogleGuava_createMutableSet_thenCorrectSize() {
Set<String> set = Sets.newHashSet("a", "b", "c");
assertEquals(3, set.size());
}
@Test
public void whenUsingGoogleGuava_createImmutableSet_thenCorrectSize() {
Set<String> set = ImmutableSet.of("a", "b", "c");
assertEquals(3, set.size());
}
}