public void TestSetInnerValueDerived()
{
var maybe = new Maybe <IList <int> >();
var boxedMaybe = (object)maybe;
var innerValue = new List <int>();
MaybeUtils.SetInnerValue(boxedMaybe, innerValue);
maybe = (Maybe <IList <int> >)boxedMaybe;
Assert.AreSame(innerValue, maybe.Value);
}
public void Should_Throw_InvalidOperationException_If_Parameter_Is_Null()
{
// Arrange
var parameterName = "parameterName";
// Act
var exception = Record.Exception(() => MaybeUtils.CheckParameterNotNull <BaseClass>(null, parameterName));
// Assert
exception.ShouldBeOfType <InvalidOperationException>();
exception.Message.ShouldContain(parameterName);
}
public void Should_Throw_ArgumentNullException_If_Argument_Is_Null()
{
// Arrange
var argumentName = "argumentName";
// Act
var exception = Record.Exception(() => MaybeUtils.CheckArgumentNotNull <BaseClass>(null, argumentName));
// Assert
exception.ShouldBeOfType <ArgumentNullException>();
exception.Message.ShouldContain(argumentName);
}
public void Should_Return_Value_If_SerializationInfo_Contains_Value()
{
// Arrange
var baseClass = new BaseClass();
var key = "key";
var serializationInfo = new SerializationInfo(typeof(Maybe <>), new FormatterConverter());
serializationInfo.AddValue(key, baseClass, typeof(BaseClass));
// Act
var value = MaybeUtils.GetDeserializedValue <BaseClass>(serializationInfo, key);
//Assert
value.ShouldBe(baseClass);
}
public void Should_Add_Value_To_SerializationInfo()
{
// Arrange
var baseClass = new BaseClass();
var key = "key";
var serializationInfo = new SerializationInfo(typeof(BaseClass), new FormatterConverter());
// Act
MaybeUtils.SetData <BaseClass>(serializationInfo, key, baseClass);
// Assert
var value = serializationInfo.GetValue(key, typeof(BaseClass));
value.ShouldBe(baseClass);
}
/// <inheritdoc />
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
var maybeValue = MaybeUtils.Unbox(value);
if (!maybeValue.HasValue)
{
// 对于空的 Optional<T> 实例，向 JSON 输出写入 undefined
writer.WriteUndefined();
return;
}
serializer.Serialize(writer, maybeValue.Value);
}
/// <inheritdoc />
public override bool IsValid(object value)
{
if (value == null)
{
return(true);
}
if (!MaybeUtils.IsMaybe(value))
{
return(true);
}
var maybe = MaybeUtils.Unbox(value);
if (!maybe.HasValue)
{
return(true);
}
var innerAttr = ActivateInnerValidationAttribute();
return(innerAttr.IsValid(maybe.Value));
}
/// <inheritdoc />
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Undefined)
{
// undefined 表示空的 Maybe<T> 实例。直接使用 Activator 实例化即可。
existingValue = Activator.CreateInstance(objectType);
return(existingValue);
}
var valueType = MaybeUtils.GetInnerType(objectType);
var value = serializer.Deserialize(reader, valueType);
if (existingValue != null && MaybeUtils.IsMaybe(existingValue))
{
MaybeUtils.SetInnerValue(existingValue, value);
}
else
{
existingValue = MaybeUtils.Create(valueType, value);
}
return(existingValue);
}
public void TestCreateNullValue()
{
var maybe = (Maybe <object>)MaybeUtils.Create(typeof(object), null);
Assert.IsNull(maybe.Value);
}
public void TestCreateNullType()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.Create(null, new object()));
}
public void TestCreateEmptyNull()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.CreateEmpty(null));
}
public void TestIsMaybeTrue()
{
Assert.IsTrue(MaybeUtils.IsMaybe(new Maybe <int>()));
Assert.IsTrue(MaybeUtils.IsMaybe(new Maybe <object>(new object())));
}
public void TestUnboxEmpty()
{
var maybe = MaybeUtils.Unbox(new Maybe <int>());
Assert.IsFalse(maybe.HasValue);
}
public void TestUnboxNonMaybe()
{
Assert.Throws <ArgumentException>(() => MaybeUtils.Unbox(10));
}
public void TestUnboxNull()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.Unbox(null));
}
public void TestIsMaybeGenericFalse()
{
Assert.IsFalse(MaybeUtils.IsMaybe <int>(10));
Assert.IsFalse(MaybeUtils.IsMaybe <int>(new Maybe <short>(10)));
}
public void TestIsMaybeGenericTrue()
{
Assert.IsTrue(MaybeUtils.IsMaybe <int>(new Maybe <int>()));
Assert.IsTrue(MaybeUtils.IsMaybe <int>(new Maybe <int>(10)));
}
public void TestIsMaybeGenericNull()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.IsMaybe <object>(null));
}
public void TestIsMaybeFalse()
{
Assert.IsFalse(MaybeUtils.IsMaybe(10));
}
public void TestCreateNullValueWithoutType()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.Create(null));
}
public void TestCreate()
{
var maybe = (Maybe <int>)MaybeUtils.Create(10);
Assert.AreEqual(10, maybe.Value);
}
public void TestSetInnerValueNull()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.SetInnerValue(null, 10));
Assert.DoesNotThrow(() => MaybeUtils.SetInnerValue(new Maybe <object>(), null));
}
public void TestGetInnerType()
{
Assert.AreEqual(typeof(int), MaybeUtils.GetInnerType(typeof(Maybe <int>)));
}
public void TestGetInnerTypeNull()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.GetInnerType(null));
}
/// <inheritdoc />
public override bool CanConvert(Type objectType)
{
return(MaybeUtils.IsMaybeType(objectType));
}
public void TestGetInnerTypeNonMaybe()
{
Assert.Throws <ArgumentException>(() => MaybeUtils.GetInnerType(typeof(int)));
Assert.Throws <ArgumentException>(() => MaybeUtils.GetInnerType(typeof(Maybe <>)));
}
public void TestSetInnerValueNonMaybe()
{
Assert.Throws <ArgumentException>(() => MaybeUtils.SetInnerValue(new object(), new object()));
}
public void TestIsMaybeNull()
{
Assert.Throws <ArgumentNullException>(() => MaybeUtils.IsMaybe(null));
}
public void TestSetInnerValueTypeMismatch()
{
Assert.Throws <InvalidOperationException>(() => MaybeUtils.SetInnerValue(new Maybe <int>(), new object()));
}
public void TestIsMaybeTypeGenericTrue()
{
Assert.IsTrue(MaybeUtils.IsMaybeType <int>(typeof(Maybe <int>)));
Assert.IsTrue(MaybeUtils.IsMaybeType <DateTime>(typeof(Maybe <DateTime>)));
}
