Tests of Try assertions (#12)

* EitherAssert initial version

* Javadoc updated

* EitherAssert_containsLeft/Right

* EitherAssert_containsSameRight

* EitherAssert_containsSameLeft

* WitherAssert_containsSameLeft/Right renamed

* Updated javadoc

* Not used constructor removed

* EitherAssert_containsRightInstanceOf

* Redundant throws removed

* EitherAssert_containsLeftInstanceOf

* Redundant Exception throws removed

* Javadoc updated

* EitherAssert_containsRight_usingComparator

* EitherAssert_containsLeft_usingComparator

* EitherAssert_containsRight_usingFieldByFieldValueComparator

* EitherAssert_containsLeft_usingFieldByFieldValueComparator

* Merge remote-tracking branch 'upstream/master'

# Conflicts:
#	src/main/java/org/assertj/vavr/api/AbstractEitherAssert.java
#	src/main/java/org/assertj/vavr/api/EitherAssert.java
#	src/main/java/org/assertj/vavr/api/EitherShouldContain.java

* TryAssert_contains_usingValueComparator_Test

* TryAssert_contains_usingFieldByFieldValueComparator_Test

Author: mchmielarz

src/main/java/org/assertj/vavr/api/AbstractTryAssert.java

@@ -48,11 +48,11 @@ abstract class AbstractTryAssert<SELF extends AbstractTryAssert<SELF, VALUE>, VA
 
     private Conditions conditions = Conditions.instance();
 
-    private ComparisonStrategy TryValueComparisonStrategy;
+    private ComparisonStrategy tryValueComparisonStrategy;
 
     AbstractTryAssert(Try<VALUE> actual, Class<?> selfType) {
         super(actual, selfType);
-        this.TryValueComparisonStrategy = StandardComparisonStrategy.instance();
+        this.tryValueComparisonStrategy = StandardComparisonStrategy.instance();
     }
 
     /**
@@ -65,7 +65,7 @@ public SELF contains(VALUE expectedValue) {
         isNotNull();
         checkNotNull(expectedValue);
         if (actual.isEmpty()) throwAssertionError(shouldContain(expectedValue));
-        if (!TryValueComparisonStrategy.areEqual(actual.get(), expectedValue))
+        if (!tryValueComparisonStrategy.areEqual(actual.get(), expectedValue))
             throwAssertionError(shouldContain(actual, expectedValue));
         return myself;
     }
@@ -134,7 +134,7 @@ public SELF usingFieldByFieldValueComparator() {
      */
     @CheckReturnValue
     public SELF usingValueComparator(Comparator<? super VALUE> customComparator) {
-        TryValueComparisonStrategy = new ComparatorBasedComparisonStrategy(customComparator);
+        tryValueComparisonStrategy = new ComparatorBasedComparisonStrategy(customComparator);
         return myself;
     }
 
@@ -149,7 +149,7 @@ public SELF usingValueComparator(Comparator<? super VALUE> customComparator) {
     @CheckReturnValue
     public SELF usingDefaultValueComparator() {
         // fall back to default strategy to compare actual with other objects.
-        TryValueComparisonStrategy = StandardComparisonStrategy.instance();
+        tryValueComparisonStrategy = StandardComparisonStrategy.instance();
         return myself;
     }
 

src/test/java/org/assertj/vavr/api/TryAssert_contains_usingFieldByFieldValueComparator_Test.java

@@ -0,0 +1,76 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2017 the original author or authors.
+ */
+package org.assertj.vavr.api;
+
+import io.vavr.control.Option;
+import io.vavr.control.Try;
+
+import org.assertj.vavr.test.BaseTest;
+import org.junit.Test;
+
+import static org.assertj.core.util.FailureMessages.actualIsNull;
+import static org.assertj.vavr.api.TryShouldContain.shouldContain;
+import static org.assertj.vavr.api.VavrAssertions.assertThat;
+
+public class TryAssert_contains_usingFieldByFieldValueComparator_Test extends BaseTest {
+
+  @Test
+  public void should_fail_when_try_is_null() {
+    thrown.expectAssertionError(actualIsNull());
+
+    assertThat((Option<Foo>) null).usingFieldByFieldValueComparator()
+                                  .contains(new Foo("something"));
+  }
+
+  @Test
+  public void should_fail_if_expected_value_is_null() {
+    thrown.expectIllegalArgumentException("The expected value should not be <null>.");
+
+    assertThat(Try.success(new Foo("something"))).usingFieldByFieldValueComparator().contains(null);
+  }
+
+  @Test
+  public void should_pass_if_successful_try_contains_expected_value() {
+    assertThat(Try.success(new Foo("something")))
+        .usingFieldByFieldValueComparator()
+        .contains(new Foo("something"));
+  }
+
+  @Test
+  public void should_fail_if_successful_try_does_not_contain_expected_value() {
+    Try<Foo> actual = Try.success(new Foo("something"));
+    Foo expectedValue = new Foo("something else");
+
+    thrown.expectAssertionError(shouldContain(actual, expectedValue).create());
+
+    assertThat(actual).usingFieldByFieldValueComparator().contains(expectedValue);
+  }
+
+  private static class Foo {
+
+    private final String value;
+
+    Foo(String value) {
+      this.value = value;
+    }
+
+    String getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "Foo{value='" + value + "'}";
+    }
+  }
+}

src/test/java/org/assertj/vavr/api/TryAssert_contains_usingValueComparator_Test.java

@@ -0,0 +1,81 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2017 the original author or authors.
+ */
+package org.assertj.vavr.api;
+
+import io.vavr.control.Option;
+import io.vavr.control.Try;
+
+import org.assertj.vavr.test.BaseTest;
+import org.junit.Test;
+
+import java.util.Comparator;
+
+import static org.assertj.core.util.FailureMessages.actualIsNull;
+import static org.assertj.vavr.api.TryShouldContain.shouldContain;
+import static org.assertj.vavr.api.VavrAssertions.assertThat;
+
+public class TryAssert_contains_usingValueComparator_Test extends BaseTest {
+
+  private static Comparator<Foo> FOO_COMPARATOR = Comparator
+      .comparing(o -> o.getValue().toLowerCase());
+
+  @Test
+  public void should_fail_when_try_is_null() {
+    thrown.expectAssertionError(actualIsNull());
+
+    assertThat((Option<Foo>) null).usingValueComparator(FOO_COMPARATOR)
+                                  .contains(new Foo("something"));
+  }
+
+  @Test
+  public void should_fail_if_expected_value_is_null() {
+    thrown.expectIllegalArgumentException("The expected value should not be <null>.");
+
+    assertThat(Try.success(new Foo("something"))).usingValueComparator(FOO_COMPARATOR).contains(null);
+  }
+
+  @Test
+  public void should_pass_if_successful_try_contains_expected_value() {
+    assertThat(Try.success(new Foo("something")))
+        .usingValueComparator(FOO_COMPARATOR)
+        .contains(new Foo("SoMething"));
+  }
+
+  @Test
+  public void should_fail_if_successful_try_does_not_contain_expected_value() {
+    Try<Foo> actual = Try.success(new Foo("something"));
+    Foo expectedValue = new Foo("something else");
+
+    thrown.expectAssertionError(shouldContain(actual, expectedValue).create());
+
+    assertThat(actual).usingValueComparator(FOO_COMPARATOR).contains(expectedValue);
+  }
+
+  private static class Foo {
+
+    private final String value;
+
+    Foo(String value) {
+      this.value = value;
+    }
+
+    String getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "Foo{value='" + value + "'}";
+    }
+  }
+}