Merge pull request #473 from egimaben/master

added hamcrest api tutorial

guava/src/test/java/org/baeldung/hamcrest/Animal.java

@@ -0,0 +1,33 @@
+package org.baeldung.hamcrest;
+
+public class Animal {
+	String name;
+	boolean wild;
+	String sound;
+	
+	public Animal(String name, boolean wild, String sound) {
+		super();
+		this.name = name;
+		this.wild = wild;
+		this.sound = sound;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public boolean isWild() {
+		return wild;
+	}
+	public void setWild(boolean wild) {
+		this.wild = wild;
+	}
+	public String getSound() {
+		return sound;
+	}
+	public void setSound(String sound) {
+		this.sound = sound;
+	}
+	
+}

guava/src/test/java/org/baeldung/hamcrest/Cat.java

@@ -0,0 +1,13 @@
+package org.baeldung.hamcrest;
+
+public class Cat extends Animal {
+
+	public Cat() {
+		super("cat", false, "meow");
+	}
+
+	public String makeSound() {
+		return getSound();
+	}
+
+}

guava/src/test/java/org/baeldung/hamcrest/HamcrestMatcherTest.java

@@ -0,0 +1,340 @@
+package org.baeldung.hamcrest;
+
+import static org.baeldung.hamcrest.IsPositiveInteger.isAPositiveInteger;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.lessThan;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.closeTo;
+import static org.hamcrest.beans.HasProperty.hasProperty;
+import static org.hamcrest.beans.HasPropertyWithValue.hasProperty;
+import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
+import static org.hamcrest.collection.IsArrayContaining.hasItemInArray;
+import static org.hamcrest.collection.IsArrayContainingInAnyOrder.arrayContainingInAnyOrder;
+import static org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining;
+import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.collection.IsIn.isIn;
+import static org.hamcrest.collection.IsIn.isOneOf;
+import static org.hamcrest.collection.IsMapContaining.hasKey;
+import static org.hamcrest.collection.IsMapContaining.hasEntry;
+import static org.hamcrest.collection.IsMapContaining.hasValue;
+import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.text.IsEqualIgnoringCase.equalToIgnoringCase;
+import static org.hamcrest.text.IsEmptyString.isEmptyOrNullString;
+import static org.hamcrest.text.IsEmptyString.isEmptyString;
+import static org.hamcrest.text.IsEqualIgnoringWhiteSpace.equalToIgnoringWhiteSpace;
+import static org.hamcrest.text.StringContainsInOrder.stringContainsInOrder;
+import static org.hamcrest.object.HasToString.hasToString;
+import static org.hamcrest.object.IsCompatibleType.typeCompatibleWith;
+import static org.hamcrest.core.AllOf.allOf;
+import static org.hamcrest.core.AnyOf.anyOf;
+import static org.hamcrest.core.Every.everyItem;
+import static org.hamcrest.core.Is.is;//class
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.core.IsNot.not;//matcher
+import static org.hamcrest.core.IsNull.notNullValue;//without arg
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.hamcrest.core.StringContains.containsString;
+import static org.hamcrest.core.StringEndsWith.endsWith;
+import static org.hamcrest.core.StringStartsWith.startsWith;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+public class HamcrestMatcherTest {
+	@Test
+	public void given2Strings_whenEqual_thenCorrect() {
+		String a = "foo";
+		String b = "FOO";
+		assertThat(a, equalToIgnoringCase(b));
+	}
+
+	@Test
+	public void givenBean_whenHasValue_thenCorrect() {
+		Person person = new Person("Baeldung", "New York");
+		assertThat(person, hasProperty("name"));
+	}
+
+	@Test
+	public void givenBean_whenHasCorrectValue_thenCorrect() {
+		Person person = new Person("Baeldung", "New York");
+		assertThat(person, hasProperty("address", equalTo("New York")));
+	}
+
+	@Test
+	public void given2Beans_whenHavingSameValues_thenCorrect() {
+		Person person1 = new Person("Baeldung", "New York");
+		Person person2 = new Person("Baeldung", "New York");
+		assertThat(person1, samePropertyValuesAs(person2));
+	}
+
+	@Test
+	public void givenAList_whenChecksSize_thenCorrect() {
+		List<String> hamcrestMatchers = Arrays.asList("collections", "beans",
+				"text", "number");
+		assertThat(hamcrestMatchers, hasSize(4));
+	}
+
+	@Test
+	public void givenArray_whenChecksSize_thenCorrect() {
+		String[] hamcrestMatchers = { "collections", "beans", "text", "number" };
+		assertThat(hamcrestMatchers, arrayWithSize(4));
+	}
+
+	@Test
+	public void givenAListAndValues_whenChecksListForGivenValues_thenCorrect() {
+		List<String> hamcrestMatchers = Arrays.asList("collections", "beans",
+				"text", "number");
+		assertThat(hamcrestMatchers,
+				containsInAnyOrder("beans", "text", "collections", "number"));
+	}
+
+	@Test
+	public void givenAListAndValues_whenChecksListForGivenValuesWithOrder_thenCorrect() {
+		List<String> hamcrestMatchers = Arrays.asList("collections", "beans",
+				"text", "number");
+		assertThat(hamcrestMatchers,
+				contains("collections", "beans", "text", "number"));
+	}
+
+	@Test
+	public void givenArrayAndValue_whenValueFoundInArray_thenCorrect() {
+		String[] hamcrestMatchers = { "collections", "beans", "text", "number" };
+		assertThat(hamcrestMatchers, hasItemInArray("text"));
+
+	}
+
+	@Test
+	public void givenValueAndArray_whenValueIsOneOfArrayElements_thenCorrect() {
+		String[] hamcrestMatchers = { "collections", "beans", "text", "number" };
+		assertThat("text", isOneOf(hamcrestMatchers));
+
+	}
+
+	@Test
+	public void givenArrayAndValues_whenValuesFoundInArray_thenCorrect() {
+		String[] hamcrestMatchers = { "collections", "beans", "text", "number" };
+		assertThat(
+				hamcrestMatchers,
+				arrayContainingInAnyOrder("beans", "collections", "number",
+						"text"));
+
+	}
+
+	@Test
+	public void givenArrayAndValues_whenValuesFoundInArrayInOrder_thenCorrect() {
+		String[] hamcrestMatchers = { "collections", "beans", "text", "number" };
+		assertThat(hamcrestMatchers,
+				arrayContaining("collections", "beans", "text", "number"));
+
+	}
+
+	@Test
+	public void givenCollection_whenEmpty_thenCorrect() {
+		List<String> emptyList = new ArrayList<>();
+		assertThat(emptyList, empty());
+
+	}
+
+	@Test
+	public void givenValueAndArray_whenValueFoundInArray_thenCorrect() {
+		String[] array = new String[] { "collections", "beans", "text",
+				"number" };
+		assertThat("bean", isIn(array));
+
+	}
+
+	@Test
+	public void givenMapAndKey_whenKeyFoundInMap_thenCorrect() {
+		Map<String, String> map = new HashMap<>();
+		map.put("blogname", "baeldung");
+		assertThat(map, hasKey("blogname"));
+	}
+
+	@Test
+	public void givenMapAndEntry_whenEntryFoundInMap_thenCorrect() {
+		Map<String, String> map = new HashMap<>();
+		map.put("blogname", "baeldung");
+		assertThat(map, hasEntry("blogname", "baeldung"));
+	}
+
+	@Test
+	public void givenMapAndValue_whenValueFoundInMap_thenCorrect() {
+		Map<String, String> map = new HashMap<>();
+		map.put("blogname", "baeldung");
+		assertThat(map, hasValue("baeldung"));
+	}
+
+	@Test
+	public void givenString_whenEmpty_thenCorrect() {
+		String str = "";
+		assertThat(str, isEmptyString());
+	}
+
+	@Test
+	public void givenString_whenEmptyOrNull_thenCorrect() {
+		String str = null;
+		assertThat(str, isEmptyOrNullString());
+	}
+
+	@Test
+	public void given2Strings_whenEqualRegardlessWhiteSpace_thenCorrect() {
+		String str1 = "text";
+		String str2 = " text ";
+		assertThat(str1, equalToIgnoringWhiteSpace(str2));
+	}
+
+	@Test
+	public void givenString_whenContainsGivenSubstring_thenCorrect() {
+		String str = "calligraphy";
+		assertThat(str, stringContainsInOrder(Arrays.asList("call", "graph")));
+	}
+
+	@Test
+	public void givenBean_whenToStringReturnsRequiredString_thenCorrect() {
+		Person person = new Person("Barrack", "Washington");
+		String str = person.toString();
+		assertThat(person, hasToString(str));
+	}
+
+	@Test
+	public void given2Classes_whenOneInheritsFromOther_thenCorrect() {
+		assertThat(Cat.class, typeCompatibleWith(Animal.class));
+	}
+
+	
+	@Test
+	public void given2Strings_whenIsEqualRegardlessWhiteSpace_thenCorrect() {
+		String str1 = "text";
+		String str2 = " text ";
+		assertThat(str1, is(equalToIgnoringWhiteSpace(str2)));
+	}
+
+	@Test
+	public void given2Strings_whenIsNotEqualRegardlessWhiteSpace_thenCorrect() {
+		String str1 = "text";
+		String str2 = " texts ";
+		assertThat(str1, not(equalToIgnoringWhiteSpace(str2)));
+	}
+
+	@Test
+	public void given2Strings_whenNotEqual_thenCorrect() {
+		String str1 = "text";
+		String str2 = "texts";
+		assertThat(str1, not(str2));
+	}
+
+	@Test
+	public void given2Strings_whenIsEqual_thenCorrect() {
+		String str1 = "text";
+		String str2 = "text";
+		assertThat(str1, is(str2));
+	}
+
+	@Test
+	public void givenAStrings_whenContainsAnotherGivenString_thenCorrect() {
+		String str1 = "calligraphy";
+		String str2 = "call";
+		assertThat(str1, containsString(str2));
+	}
+
+	@Test
+	public void givenAString_whenEndsWithAnotherGivenString_thenCorrect() {
+		String str1 = "calligraphy";
+		String str2 = "phy";
+		assertThat(str1, endsWith(str2));
+	}
+
+	@Test
+	public void givenAString_whenStartsWithAnotherGivenString_thenCorrect() {
+		String str1 = "calligraphy";
+		String str2 = "call";
+		assertThat(str1, startsWith(str2));
+	}
+
+	@Test
+	public void given2Objects_whenSameInstance_thenCorrect() {
+		Cat cat = new Cat();
+		assertThat(cat, sameInstance(cat));
+	}
+
+	@Test
+	public void givenAnObject_whenInstanceOfGivenClass_thenCorrect() {
+		Cat cat = new Cat();
+		assertThat(cat, instanceOf(Cat.class));
+	}
+
+	@Test
+	public void givenList_whenEachElementGreaterThan0_thenCorrect() {
+		List<Integer> list = Arrays.asList(1, 2, 3);
+		int baseCase = 0;
+		assertThat(list, everyItem(greaterThan(baseCase)));
+	}
+
+	@Test
+	public void givenString_whenNotNull_thenCorrect() {
+		String str = "notnull";
+		assertThat(str, notNullValue());
+	}
+
+	@Test
+	public void givenString_whenMeetsAnyOfGivenConditions_thenCorrect() {
+		String str = "calligraphy";
+		String start = "call";
+		String end = "foo";
+		assertThat(str, anyOf(startsWith(start), containsString(end)));
+	}
+
+	@Test
+	public void givenString_whenMeetsAllOfGivenConditions_thenCorrect() {
+		String str = "calligraphy";
+		String start = "call";
+		String end = "foo";
+		assertThat(str, allOf(startsWith(start), endsWith(end)));
+	}
+
+	@Test
+	public void givenInteger_whenAPositiveValue_thenCorrect() {
+		int num = 1;
+		assertThat(num, isAPositiveInteger());
+	}
+
+	@Test
+	public void givenAnInteger_whenGreaterThan0_thenCorrect() {
+		int num = 1;
+		assertThat(num, greaterThan(0));
+	}
+
+	@Test
+	public void givenAnInteger_whenGreaterThanOrEqTo5_thenCorrect() {
+		int num = 5;
+		assertThat(num, greaterThanOrEqualTo(5));
+	}
+
+	@Test
+	public void givenAnInteger_whenLessThan0_thenCorrect() {
+		int num = -1;
+		assertThat(num, lessThan(0));
+	}
+
+	@Test
+	public void givenAnInteger_whenLessThanOrEqTo5_thenCorrect() {
+		assertThat(-1, lessThanOrEqualTo(5));
+	}
+
+	@Test
+	public void givenADouble_whenCloseTo_thenCorrect() {
+		assertThat(1.2, closeTo(1, 0.5));
+	}
+
+}

guava/src/test/java/org/baeldung/hamcrest/IsPositiveInteger.java

@@ -0,0 +1,24 @@
+package org.baeldung.hamcrest;
+
+import org.hamcrest.Description;
+import org.hamcrest.Factory;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+
+public class IsPositiveInteger extends TypeSafeMatcher<Integer> {
+
+	public void describeTo(Description description) {
+		description.appendText("a positive integer");
+	}
+
+	@Factory
+	public static Matcher<Integer> isAPositiveInteger() {
+		return new IsPositiveInteger();
+	}
+
+	@Override
+	protected boolean matchesSafely(Integer integer) {
+		return integer > 0;
+	}
+
+}

guava/src/test/java/org/baeldung/hamcrest/Person.java

@@ -0,0 +1,37 @@
+package org.baeldung.hamcrest;
+
+public class Person {
+	String name;
+	String address;
+
+	public Person(String personName, String personAddress) {
+		name = personName;
+		address = personAddress;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getAddress() {
+		return address;
+	}
+
+	public void setAddress(String address) {
+		this.address = address;
+	}
+
+	@Override
+	public String toString() {
+		String str="[address:"+address+",name:"+name+"]";
+		return str;
+	}
+	
+
+
+	
+}