public async void Hydrate_Works() { var settings = Mixer.Configure.OnType <int>(() => 999) .MapAbstract <ITestClass>(new[] { typeof(TestClass) }); TestClass testClass = await Juiced.HydrateAsync <TestClass>(settings); Assert.NotNull(testClass); Assert.Equal(testClass.BoolValue, false); Assert.Equal(testClass.ByteValue, new byte()); Assert.NotNull(testClass.ChildStruct); Assert.Equal(testClass.ChildStruct.IntB, 999); Assert.Equal(testClass.DecimalValue, 1.1M); Assert.Equal(testClass.DoubleValue, 1.1D); Assert.Equal(testClass.UIntValue, 1U); Assert.Equal(testClass.IntA, 999); Assert.NotNull(testClass.Items); Assert.Equal(testClass.LongValue, 1L); Assert.Null(testClass.Recursion); Assert.NotNull(testClass.RecursionAsInterface); Assert.Equal(testClass.ShortValue, (short)1); Assert.Equal(testClass.ULongValue, 1UL); Assert.Equal(testClass.FloatValue, 1.1F); Assert.Equal(testClass.CharValue, new char()); Assert.NotNull(testClass.StringArrayValue); Assert.NotNull(testClass.StringValue); Assert.NotEmpty(testClass.StringValue); }
public async void HydrateAsync_HandledExceptionsBasedOnType() { var intCount = 0; var count = 0; var settings = Mixer.Configure.OnType <double>(() => { throw new InvalidCastException("This is an invalid cast exception"); }).OnType <int>(() => { throw new InvalidCastException("This is an invalid cast exception"); }) .SetRecursion(0); settings.HandleTypeError <int>((type, handledException) => { intCount++; return(true); }); settings.OnError = (type, handledException) => { count++; return(true); }; var exception = await Juiced.HydrateAsync <TestClassB>(settings); Assert.Equal(1, intCount); Assert.Equal(1, count); }
public void HydrateAsync_AsValueType() { var settings = Mixer.Configure.OnType <double>(() => 999.0d); var result = Juiced.HydrateAsync <double>(settings).Result; Assert.Equal(result, 999.0d); }
public void HydrateAsync_UnhandledExceptionsThrows() { var settings = Mixer.Configure.OnType <double>(() => { throw new InvalidCastException("This is an invalid cast exception"); }); var exception = Assert.Throws <AggregateException>(() => { var i = Juiced.HydrateAsync <double>(settings).Result; }); Assert.Equal(typeof(AggregateException), exception.GetType()); Assert.Equal(typeof(JuicedException), exception.InnerExceptions[0].GetType()); Assert.Equal(typeof(InvalidCastException), exception.InnerExceptions[0].InnerException.GetType()); }
public void Inject_RecursionLimit(int recursion) { var settings = Mixer.Configure.SetRecursion(recursion); var result = Juiced.HydrateAsync <TestClass>(settings).Result; var testClass = result.Recursion; for (var i = 0; i <= recursion; i++) { if (i == recursion) { Assert.Null(testClass); continue; } Assert.NotNull(testClass); testClass = testClass.Recursion; } }
public async void HydrateAsync_AbstractRegistrationCompletes() { var settings = Mixer.Configure .MapAbstract <ITestClass>(new[] { typeof(TestClass) }) .SetRecursion(1); TestClass testClass = null; var result = Juiced.HydrateAsync <TestClass>(settings); await result.ContinueWith((continuation) => { if (!continuation.IsFaulted) { testClass = continuation.Result; } }); Assert.NotNull(testClass); Assert.NotNull(testClass.RecursionAsInterface); }
public async void HydrateAsync_WorksAsync() { var settings = Mixer.Configure.OnType <int>(() => 999); TestClass testClass = null; var result = Juiced.HydrateAsync <TestClass>(settings); await result.ContinueWith((continuation) => { if (!continuation.IsFaulted) { testClass = continuation.Result; } }); Assert.NotNull(testClass); Assert.Equal(testClass.BoolValue, false); Assert.Equal(testClass.ByteValue, new byte()); Assert.NotNull(testClass.ChildStruct); Assert.Equal(testClass.ChildStruct.IntB, 999); Assert.Equal(testClass.DecimalValue, 1.1M); Assert.Equal(testClass.DoubleValue, 1.1D); Assert.Equal(testClass.UIntValue, 1U); Assert.Equal(testClass.IntA, 999); Assert.NotNull(testClass.Items); Assert.Equal(testClass.LongValue, 1L); Assert.Null(testClass.Recursion); Assert.Equal(testClass.ShortValue, (short)1); Assert.Equal(testClass.ULongValue, 1UL); Assert.Equal(testClass.FloatValue, 1.1F); Assert.Equal(testClass.CharValue, new char()); Assert.NotNull(testClass.StringArrayValue); Assert.NotNull(testClass.StringValue); Assert.NotEmpty(testClass.StringValue); }
public void HydrateAsync_HandledExceptions(bool suppressExceptions) { var settings = Mixer.Configure.OnType <double>(() => { throw new InvalidCastException("This is an invalid cast exception"); }); settings.OnError = (type, handledException) => suppressExceptions; double instance = 0; if (!suppressExceptions) { var exception = Assert.Throws <AggregateException>(() => { instance = Juiced.HydrateAsync <double>(settings).Result; }); var firstInnerException = exception.InnerExceptions[0]; var secondInner = firstInnerException.InnerException; Assert.Equal(firstInnerException.GetType(), typeof(JuicedException)); Assert.Equal(secondInner.GetType(), typeof(InvalidCastException)); return; } Assert.Equal(instance, 0); }