public void ProcessWithReturnValueReturnsCorrectValueWhenNoExceptionThrown()
{
var policies = new Dictionary <string, ExceptionPolicyImpl>();
var policy1Entries = new Dictionary <Type, ExceptionPolicyEntry>
{
{
typeof(ArithmeticException),
new ExceptionPolicyEntry(typeof(ArithmeticException),
PostHandlingAction.NotifyRethrow,
new IExceptionHandler[] { new TestExceptionHandler("handler11") })
},
{
typeof(ArgumentException),
new ExceptionPolicyEntry(typeof(ArgumentException),
PostHandlingAction.ThrowNewException,
new IExceptionHandler[] { new TestExceptionHandler("handler12") })
},
{
typeof(ArgumentOutOfRangeException),
new ExceptionPolicyEntry(typeof(ArgumentOutOfRangeException),
PostHandlingAction.None,
new IExceptionHandler[] { new TestExceptionHandler("handler13") })
}
};
policies.Add("policy1", new ExceptionPolicyImpl("policy1", policy1Entries));
ExceptionManager manager = new ExceptionManagerImpl(policies);
int result = manager.Process(() => 42, "policy1");
Assert.AreEqual(42, result);
}
public void ProcessForwardsHandlingToConfiguredExceptionEntry()
{
Dictionary <string, ExceptionPolicyImpl> policies = new Dictionary <string, ExceptionPolicyImpl>();
Dictionary <Type, ExceptionPolicyEntry> policy1Entries = new Dictionary <Type, ExceptionPolicyEntry>();
policy1Entries.Add(
typeof(ArithmeticException),
new ExceptionPolicyEntry(PostHandlingAction.NotifyRethrow, new IExceptionHandler[] { new TestExceptionHandler("handler11") }));
policy1Entries.Add(
typeof(ArgumentException),
new ExceptionPolicyEntry(PostHandlingAction.ThrowNewException, new IExceptionHandler[] { new TestExceptionHandler("handler12") }));
policy1Entries.Add(
typeof(ArgumentOutOfRangeException),
new ExceptionPolicyEntry(PostHandlingAction.None, new IExceptionHandler[] { new TestExceptionHandler("handler13") }));
policies.Add("policy1", new ExceptionPolicyImpl("policy1", policy1Entries));
ExceptionManager manager = new ExceptionManagerImpl(policies);
Exception thrownException;
// is the exception rethrown?
thrownException = new ArithmeticException();
try
{
manager.Process(
() => { throw (thrownException); },
"policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e);
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler11", TestExceptionHandler.HandlingNames[0]);
}
// is the new exception thrown?
TestExceptionHandler.HandlingNames.Clear();
thrownException = new ArgumentException();
try
{
manager.Process(
() => { throw (thrownException); },
"policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e.InnerException);
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler12", TestExceptionHandler.HandlingNames[0]);
}
// is the exception swallowed? action == None
TestExceptionHandler.HandlingNames.Clear();
thrownException = new ArgumentOutOfRangeException();
manager.Process(
() => { throw (thrownException); },
"policy1");
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler13", TestExceptionHandler.HandlingNames[0]);
// is the unknwon exception rethrown?
TestExceptionHandler.HandlingNames.Clear();
thrownException = new Exception();
try
{
manager.Process(
() => { throw (thrownException); },
"policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e);
Assert.AreEqual(0, TestExceptionHandler.HandlingNames.Count);
}
}
public void ProcessWithReturnValueProcessesExceptionsOnThrow()
{
var policies = new Dictionary<string, ExceptionPolicyImpl>();
var policy1Entries = new Dictionary<Type, ExceptionPolicyEntry>
{
{
typeof (ArithmeticException),
new ExceptionPolicyEntry(typeof (ArithmeticException),
PostHandlingAction.NotifyRethrow,
new IExceptionHandler[] {new TestExceptionHandler("handler11")})
},
{
typeof (ArgumentException),
new ExceptionPolicyEntry(typeof (ArgumentException),
PostHandlingAction.ThrowNewException,
new IExceptionHandler[] {new TestExceptionHandler("handler12")})
},
{
typeof (ArgumentOutOfRangeException),
new ExceptionPolicyEntry(typeof (ArgumentOutOfRangeException),
PostHandlingAction.None,
new IExceptionHandler[] {new TestExceptionHandler("handler13")})
}
};
policies.Add("policy1", new ExceptionPolicyImpl("policy1", policy1Entries));
ExceptionManager manager = new ExceptionManagerImpl(policies);
// is the exception rethrown?
Exception thrownException = new ArithmeticException();
try
{
Exception ex1 = thrownException;
int result = manager.Process(() => { throw ex1;
#pragma warning disable 162 // Unreachable code
return 37;
#pragma warning restore 162
}, "policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e);
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler11", TestExceptionHandler.HandlingNames[0]);
}
// is the exception swallowed? action == None
TestExceptionHandler.HandlingNames.Clear();
thrownException = new ArgumentOutOfRangeException();
Exception ex3 = thrownException;
int swallowedResult = manager.Process(() => { throw ex3;
#pragma warning disable 162 // Unreachable code
return 17;
#pragma warning restore 162
}, -20, "policy1");
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler13", TestExceptionHandler.HandlingNames[0]);
Assert.AreEqual(-20, swallowedResult);
}
public void ProcessWithReturnValueReturnsCorrectValueWhenNoExceptionThrown()
{
var policies = new Dictionary<string, ExceptionPolicyImpl>();
var policy1Entries = new Dictionary<Type, ExceptionPolicyEntry>
{
{
typeof (ArithmeticException),
new ExceptionPolicyEntry(typeof (ArithmeticException),
PostHandlingAction.NotifyRethrow,
new IExceptionHandler[] {new TestExceptionHandler("handler11")})
},
{
typeof (ArgumentException),
new ExceptionPolicyEntry(typeof (ArgumentException),
PostHandlingAction.ThrowNewException,
new IExceptionHandler[] {new TestExceptionHandler("handler12")})
},
{
typeof (ArgumentOutOfRangeException),
new ExceptionPolicyEntry(typeof (ArgumentOutOfRangeException),
PostHandlingAction.None,
new IExceptionHandler[] {new TestExceptionHandler("handler13")})
}
};
policies.Add("policy1", new ExceptionPolicyImpl("policy1", policy1Entries));
ExceptionManager manager = new ExceptionManagerImpl(policies);
int result = manager.Process(() => 42, "policy1");
Assert.AreEqual(42, result);
}
public void ProcessForwardsHandlingToConfiguredExceptionEntry()
{
var policies = new Dictionary<string, ExceptionPolicyImpl>();
var policy1Entries = new Dictionary<Type, ExceptionPolicyEntry>
{
{
typeof (ArithmeticException),
new ExceptionPolicyEntry(typeof (ArithmeticException),
PostHandlingAction.NotifyRethrow,
new IExceptionHandler[] {new TestExceptionHandler("handler11")})
},
{
typeof (ArgumentException),
new ExceptionPolicyEntry(typeof (ArgumentException),
PostHandlingAction.ThrowNewException,
new IExceptionHandler[] {new TestExceptionHandler("handler12")})
},
{
typeof (ArgumentOutOfRangeException),
new ExceptionPolicyEntry(typeof (ArgumentOutOfRangeException),
PostHandlingAction.None,
new IExceptionHandler[] {new TestExceptionHandler("handler13")})
}
};
policies.Add("policy1", new ExceptionPolicyImpl("policy1", policy1Entries));
ExceptionManager manager = new ExceptionManagerImpl(policies);
// is the exception rethrown?
Exception thrownException = new ArithmeticException();
try
{
Exception ex1 = thrownException;
manager.Process( () => { throw ex1; }, "policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e);
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler11", TestExceptionHandler.HandlingNames[0]);
}
// is the new exception thrown?
TestExceptionHandler.HandlingNames.Clear();
thrownException = new ArgumentException();
try
{
Exception ex2 = thrownException;
manager.Process(() => { throw ex2; }, "policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e.InnerException);
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler12", TestExceptionHandler.HandlingNames[0]);
}
// is the exception swallowed? action == None
TestExceptionHandler.HandlingNames.Clear();
thrownException = new ArgumentOutOfRangeException();
Exception ex3 = thrownException;
manager.Process(() => { throw ex3; }, "policy1");
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler13", TestExceptionHandler.HandlingNames[0]);
// is the unknwon exception rethrown?
TestExceptionHandler.HandlingNames.Clear();
thrownException = new Exception();
try
{
manager.Process(
() => { throw (thrownException); },
"policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e);
Assert.AreEqual(0, TestExceptionHandler.HandlingNames.Count);
}
}
public void ProcessWithReturnValueProcessesExceptionsOnThrow()
{
var policies = new Dictionary <string, ExceptionPolicyImpl>();
var policy1Entries = new Dictionary <Type, ExceptionPolicyEntry>
{
{
typeof(ArithmeticException),
new ExceptionPolicyEntry(typeof(ArithmeticException),
PostHandlingAction.NotifyRethrow,
new IExceptionHandler[] { new TestExceptionHandler("handler11") })
},
{
typeof(ArgumentException),
new ExceptionPolicyEntry(typeof(ArgumentException),
PostHandlingAction.ThrowNewException,
new IExceptionHandler[] { new TestExceptionHandler("handler12") })
},
{
typeof(ArgumentOutOfRangeException),
new ExceptionPolicyEntry(typeof(ArgumentOutOfRangeException),
PostHandlingAction.None,
new IExceptionHandler[] { new TestExceptionHandler("handler13") })
}
};
policies.Add("policy1", new ExceptionPolicyImpl("policy1", policy1Entries));
ExceptionManager manager = new ExceptionManagerImpl(policies);
// is the exception rethrown?
Exception thrownException = new ArithmeticException();
try
{
Exception ex1 = thrownException;
int result = manager.Process(() => { throw ex1;
#pragma warning disable 162 // Unreachable code
return(37);
#pragma warning restore 162
}, "policy1");
Assert.Fail("should have thrown");
}
catch (Exception e)
{
Assert.AreSame(thrownException, e);
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler11", TestExceptionHandler.HandlingNames[0]);
}
// is the exception swallowed? action == None
TestExceptionHandler.HandlingNames.Clear();
thrownException = new ArgumentOutOfRangeException();
Exception ex3 = thrownException;
int swallowedResult = manager.Process(() => { throw ex3;
#pragma warning disable 162 // Unreachable code
return(17);
#pragma warning restore 162
}, -20, "policy1");
Assert.AreEqual(1, TestExceptionHandler.HandlingNames.Count);
Assert.AreEqual("handler13", TestExceptionHandler.HandlingNames[0]);
Assert.AreEqual(-20, swallowedResult);
}