public bool TryBuild(out ClearableValue <T> result) { T value = Value; string state = State; if (string.IsNullOrEmpty(state) || string.Equals(state, Constants.Clearable_NoActionState, StringComparison.OrdinalIgnoreCase)) { result = ClearableValue <T> .NoAction(); return(true); } if (string.Equals(state, Constants.Clearable_ClearState, StringComparison.OrdinalIgnoreCase)) { result = ClearableValue <T> .Clear(); return(true); } if (string.Equals(state, Constants.Clearable_SetState, StringComparison.OrdinalIgnoreCase)) { result = ClearableValue <T> .Set(value); return(true); } result = default(ClearableValue <T>); return(false); }
public AndConstraint <ClearableValueAssertions <T> > NotBe(ClearableValue <T> expected, string because = "", params object[] becauseArgs) { Execute.Assertion .ForCondition(!Subject.Equals(expected)) .BecauseOf(because, becauseArgs) .FailWith("Expected {context:ClearableValue<T>} to be {0}{reason}, but found {1}.", expected, Subject); return(new AndConstraint <ClearableValueAssertions <T> >(this)); }
public AndConstraint <NullableClearableValueAssertions <T> > Be(ClearableValue <T>?expected, string because = "", params object[] becauseArgs) { Execute.Assertion .ForCondition(Subject == expected) .BecauseOf(because, becauseArgs) .FailWith("Expected {context:Address} to be {0}{reason}, but found {1}.", expected, Subject); return(new AndConstraint <NullableClearableValueAssertions <T> >(this)); }
public void ParameterlessConstructor_ShouldBeNoAction() { // arrange var sut = new ClearableValue <int>(); // act // assert sut.Should().BeNoActionVariant(because: "{0} is created using parameterless constructor and should be treated as 'noAction'", sut); }
public void GenericSet_ShouldBeSet() { // arrange var sut = ClearableValue.Set(Fixture.Create <int>()); // act // assert sut.Should().BeSetVariant(because: "{0} is created using generic Set<T>() method and should be treated as 'set'", sut); }
public void ConstructorWithValue_ShouldBeSet() { // arrange var sut = new ClearableValue <int>(Fixture.Create <int>()); // act // assert sut.Should().BeSetVariant(because: "{0} is created using constructor with value parameter and should be treated as 'set'", sut); }
public void DomesticNoAction_ShouldBeNoAction() { // arrange var sut = ClearableValue <int> .NoAction(); // act // assert sut.Should().BeNoActionVariant(because: "{0} is created using domestic static NoAction() method and should be treated as 'noAction'", sut); }
public void GenericNoAction_ShouldBeNoAction() { // arrange var sut = ClearableValue.NoAction(Fixture.Create <int>()); // act // assert sut.Should().BeNoActionVariant(because: "{0} is created using generic NoAction<T>() method and should be treated as 'noAction'", sut); }
public void NoAction_ShouldNotCallMapper() { // arrange var sut = ClearableValue <int> .NoAction(); // act Action map = () => sut.Map <int>(_ => throw new InvalidOperationException()); // assert map.Should().NotThrow(because: "mapping 'noAction' should not call mapper function"); }
public void Clear_ShouldMapToClear() { // arrange var sut = ClearableValue <int> .Clear(); // act var result = sut.Map(e => e.ToString()); // assert result.Should().BeClearVariant(); }
public void NoAction_ShouldMapToNoAction() { // arrange var sut = ClearableValue <int> .NoAction(); // act var result = sut.Map(e => e.ToString()); // assert result.Should().BeNoActionVariant(); }
private static IEnumerable <ClearableValue <string> > GetSerializeTestData() { yield return(ClearableValue <string> .NoAction()); yield return(ClearableValue <string> .Clear()); yield return(ClearableValue <string> .Set(null)); yield return(ClearableValue <string> .Set(string.Empty)); yield return(ClearableValue <string> .Set(System.Guid.NewGuid().ToString())); }
public void SetOfDifferentValues_ShouldNotBeEqual() { // arrange var set1 = ClearableValue <int> .Set(1); var set2 = ClearableValue <int> .Set(2); // act // assert set1.Equals(set2).Should().BeFalse(); set2.Equals(set1).Should().BeFalse(); }
public void NoActionAndDefaultClearableValue_ShouldBeEqual() { // arrange var noAction = ClearableValue <int> .NoAction(); var @default = default(ClearableValue <int>); // act // assert noAction.Equals(@default).Should().BeTrue(); @default.Equals(noAction).Should().BeTrue(); }
public void ClearAndSetOfDefaultValue_ShouldNotBeEqual() { // arrange var clear = ClearableValue <int> .Clear(); var set = ClearableValue <int> .Set(default(int)); // act // assert clear.Equals(set).Should().BeFalse(); set.Equals(clear).Should().BeFalse(); }
public void SetOfSameValues_ShouldBeEqual() { // arrange var set1 = ClearableValue <int> .Set(1); var set2 = ClearableValue <int> .Set(1); // act // assert set1.Equals(set2).Should().BeTrue(); set2.Equals(set1).Should().BeTrue(); }
public void NoActionAndClear_ShouldNotBeEqual() { // arrange var noAction = ClearableValue <int> .NoAction(); var clear = ClearableValue <int> .Clear(); // act // assert noAction.Equals(clear).Should().BeFalse(); clear.Equals(noAction).Should().BeFalse(); }
public void NoActionAndSetOfDefaultValue_ShouldNotBeEqual() { // arrange var noAction = ClearableValue <int> .NoAction(); var set = ClearableValue <int> .Set(default(int)); // act // assert noAction.Equals(set).Should().BeFalse(); set.Equals(noAction).Should().BeFalse(); }
public void Clear_ShouldMatch() { // arrange var sut = ClearableValue <int> .Clear(); // act var result = sut.Match( set: _ => State.Set, clear: () => State.Clear, noAction: () => State.NoAction); // assert result.Should().Be(State.Clear); }
public void Set_ShouldMatch() { // arrange var sut = ClearableValue <int> .Set(Fixture.Create <int>()); // act var result = sut.Match( set: _ => State.Set, clear: () => State.Clear, noAction: () => State.NoAction); // assert result.Should().Be(State.Set); }
public void Set_ShouldNotCallClearOrNoActionFunc() { // arrange var sut = ClearableValue <int> .Set(Fixture.Create <int>()); // act Action match = () => sut.Match( set: _ => State.Set, clear: () => throw new InvalidOperationException(), noAction: () => throw new InvalidOperationException()); // assert match.Should().NotThrow(because: "matching 'set' should not call neither 'clear' nor 'noAction' function"); }
public void NoAction_ShouldNotCallSetOrClearFunc() { // arrange var sut = ClearableValue <int> .NoAction(); // act Action match = () => sut.Match( set: _ => throw new InvalidOperationException(), clear: () => throw new InvalidOperationException(), noAction: () => State.NoAction); // assert match.Should().NotThrow(because: "matching 'noAction' should not call neither 'set' nor 'clear' function"); }
public void Set_ShouldMapToSet() { // arrange int originalValue = Fixture.Create <int>(); var sut = ClearableValue <int> .Set(originalValue); Func <int, string> map = e => e.ToString(); string expectedValue = map(originalValue); // act var result = sut.Map(map); // assert result.Should().BeSetOf(expectedValue); }
public void SerializeAndDeserialize_NoAction_ShouldBeIdempotent(ClearableValue <string> originalValue) { // arrange var converter = new ClearableValueJsonConverter <string>(); // act string serializedValue1 = JsonConvert.SerializeObject(originalValue, converter); var deserializedValue1 = JsonConvert.DeserializeObject <ClearableValue <string> >(serializedValue1, converter); string serializedValue2 = JsonConvert.SerializeObject(deserializedValue1, converter); var deserializedValue2 = JsonConvert.DeserializeObject <ClearableValue <string> >(serializedValue2, converter); // assert deserializedValue1.Should().Be(originalValue); deserializedValue2.Should().Be(originalValue); deserializedValue2.Should().Be(deserializedValue1); serializedValue2.Should().Be(serializedValue1); }
public override void WriteJson(JsonWriter writer, ClearableValue <T> clearable, JsonSerializer serializer) { writer.WriteStartObject(); string state = clearable.Match( set: _ => Constants.Clearable_SetState, clear: () => Constants.Clearable_ClearState, noAction: () => Constants.Clearable_NoActionState); writer.WritePropertyName(Constants.StatePropertyName); writer.WriteValue(state); var(isSet, value) = clearable.Match( set: e => (true, e), clear: () => (false, default(T)), noAction: () => (false, default(T))); if (isSet) { writer.WritePropertyName(Constants.ValuePropertyName); serializer.Serialize(writer, value); } writer.WriteEndObject(); }
public NullableClearableValueAssertions(ClearableValue <T>?subject) : base(subject) { }
public ClearableValueAssertions(ClearableValue <T>?subject) { Subject = subject; }
public static ClearableValueAssertions <T> Should <T>(this ClearableValue <T> actualValue) => new ClearableValueAssertions <T>(actualValue);
public static NullableClearableValueAssertions <T> Should <T>(this ClearableValue <T>?actualValue) => new NullableClearableValueAssertions <T>(actualValue);
public override ClearableValue <T> ReadJson(JsonReader reader, Type objectType, ClearableValue <T> existingValue, bool hasExistingValue, JsonSerializer serializer) { var builder = new ClearableValueBuilder <T>(); if (reader.TokenType == JsonToken.StartObject) { while (reader.Read() && reader.TokenType != JsonToken.EndObject) { if (reader.TryReadPropertyAs(Constants.StatePropertyName, serializer, e => e.ReadAsString(), out var stateValue)) { builder.State = stateValue; } else if (reader.TryDeserializeProperty(Constants.ValuePropertyName, serializer, out T valueObj)) { builder.Value = valueObj; } } } if (!builder.TryBuild(out var clearable)) { throw new InvalidOperationException($"Could not read {typeof(ClearableValue<T>)} from JSON."); } return(clearable); }