public void Throw()
{
var ex = new MyException();
var xs = EnumerableEx.Throw<int>(ex);
var e = xs.GetEnumerator();
AssertThrows<MyException>(() => e.MoveNext());
}
public void Catch3()
{
var ex = new MyException();
AssertThrows<MyException>(() =>
{
EnumerableEx.Throw<int>(ex).Catch<int, InvalidOperationException>(e => { Assert.True(false); return new[] { 42 }; }).Single();
});
}
[Test] // .ctor (SerializationInfo, StreamingContext)
public void Constructor3 ()
{
SerializationInfo si;
MyException ex;
Exception inner;
inner = new ArgumentException ();
si = new SerializationInfo (typeof (Exception),
new FormatterConverter ());
si.AddValue ("ClassName", "CLASS");
si.AddValue ("Message", "MSG");
si.AddValue ("InnerException", inner, typeof (Exception));
si.AddValue ("HelpURL", "URL");
si.AddValue ("StackTraceString", null);
si.AddValue ("RemoteStackTraceString", null);
si.AddValue ("RemoteStackIndex", 0);
si.AddValue ("HResult", 10);
si.AddValue ("Source", "SRC");
si.AddValue ("ExceptionMethod", null);
Hashtable data = new Hashtable ();
data.Add ("XX", "ZZ");
si.AddValue ("Data", data, typeof (IDictionary));
ex = new MyException (si, new StreamingContext ());
Assert.AreEqual ("MSG", ex.Message, "#A1");
Assert.AreSame (inner, ex.InnerException, "#A2");
Assert.AreEqual ("URL", ex.HelpLink, "#A3");
Assert.AreEqual (10, ex.HResult, "#A4");
Assert.AreEqual ("SRC", ex.Source, "#A5");
Assert.IsNotNull (ex.Data, "#A6");
Assert.AreEqual (1, ex.Data.Keys.Count, "#A7");
Assert.AreEqual ("ZZ", ex.Data ["XX"], "#A8");
inner = null;
si = new SerializationInfo (typeof (Exception),
new FormatterConverter ());
si.AddValue ("ClassName", "CLASS");
si.AddValue ("Message", null);
si.AddValue ("InnerException", inner, typeof (Exception));
si.AddValue ("HelpURL", "URL");
si.AddValue ("StackTraceString", null);
si.AddValue ("RemoteStackTraceString", null);
si.AddValue ("RemoteStackIndex", 0);
si.AddValue ("HResult", 10);
si.AddValue ("Source", "SRC");
si.AddValue ("ExceptionMethod", null);
ex = new MyException (si, new StreamingContext ());
Assert.IsNotNull (ex.Message, "#B1");
Assert.IsTrue (ex.Message.IndexOf ("CLASS") != -1, "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.AreEqual ("URL", ex.HelpLink, "#B4");
Assert.AreEqual (10, ex.HResult, "#B5");
Assert.AreEqual ("SRC", ex.Source, "#B6");
Assert.IsNotNull (ex.Data, "#B7");
Assert.AreEqual (0, ex.Data.Keys.Count, "#B8");
}
public void Memoize6()
{
var ex = new MyException();
var rng = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw<int>(ex)).Memoize();
var e1 = rng.GetEnumerator();
var e2 = rng.GetEnumerator();
HasNext(e1, 0);
HasNext(e1, 1);
AssertThrows<MyException>(() => e1.MoveNext());
HasNext(e2, 0);
HasNext(e2, 1);
AssertThrows<MyException>(() => e2.MoveNext());
}
public void ValueOrThrow_WithNone_ThrowsException()
{
var exception = new MyException();
Assert.That(() => None.ValueOrThrow(exception), Throws.TypeOf(exception.GetType()));
}
public void ValueOrThrowUsing_WithNone_ThrowsException()
{
var exception = new MyException();
Action throwException = () => { throw exception; };
Assert.That(() => None.ValueOrThrowUsing(throwException), Throws.TypeOf(exception.GetType()));
}
public static void MyError(int i)
{
// Ceci est une methode qui alors quelle retourne uniquement Void va transmettre des infos de retour à travers MyException
Exception e = new MyException("Ceci est une exception de type MyException");
if (i == 0)
throw e; // Le mecanisme des exceptions permet de transmettre des infos encapsulées dans une exception à la méthode appelante
}
public void HResult ()
{
MyException ex = new MyException ();
Assert.AreEqual (-2146233088, ex.HResult, "#1");
ex.HResult = int.MaxValue;
Assert.AreEqual (int.MaxValue, ex.HResult, "#2");
ex.HResult = int.MinValue;
Assert.AreEqual (int.MinValue, ex.HResult, "#3");
}
public void RaiseCustomError()
{
FaultException e = new MyException();
e.Source = "ok";
throw e;
}
public void Retry3()
{
var ex = new MyException();
var xs = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw<int>(ex));
var res = xs.Retry(2);
var e = res.GetEnumerator();
HasNext(e, 0);
HasNext(e, 1);
HasNext(e, 0);
HasNext(e, 1);
AssertThrows<MyException>(() => e.MoveNext(), ex_ => ex == ex_);
}
public void Catch2()
{
var ex = new MyException();
var res = EnumerableEx.Throw<int>(ex).Catch<int, Exception>(e => { Assert.Same(ex, e); return new[] { 42 }; }).Single();
Assert.Equal(42, res);
}
public void Finally3()
{
var done = false;
var ex = new MyException();
var xs = EnumerableEx.Throw<int>(ex).Finally(() => done = true);
Assert.False(done);
var e = xs.GetEnumerator();
Assert.False(done);
try
{
HasNext(e, 0);
Assert.True(false);
}
catch (MyException ex_)
{
Assert.Same(ex, ex_);
}
Assert.True(done);
}
public void Catch11()
{
var e1 = new MyException();
var ex1 = EnumerableEx.Throw<int>(e1);
var e2 = new MyException();
var ex2 = EnumerableEx.Throw<int>(e2);
var e3 = new MyException();
var ex3 = EnumerableEx.Throw<int>(e3);
var xss = new[] { Enumerable.Range(0, 2).Concat(ex1), Enumerable.Range(2, 2).Concat(ex2), ex3 };
var res = xss.Catch();
var e = res.GetEnumerator();
HasNext(e, 0);
HasNext(e, 1);
HasNext(e, 2);
HasNext(e, 3);
AssertThrows<MyException>(() => e.MoveNext(), ex => ex == e3);
}
/// <summary>
/// 解析响应的soap消息
/// </summary>
/// <param name="soapMessage">响应的soap消息字符串</param>
private void Parse(string soapMessage)
{
if (string.IsNullOrEmpty(soapMessage))
{
throw new MyException(ESB_TraceCategory.ESB, ESB_ErrorCodes.ESB.NotValidSOAP_1, "soap响应字符串为空");
}
try
{
// schema校验
var doc = new XmlDocument();
doc.LoadXml(soapMessage);
var xsdstream = Assembly.GetExecutingAssembly().GetManifestResourceStream(EsbConfig.Soap11SchemaResPath);
if (xsdstream != null)
{
var schemaset = new XmlSchemaSet();
schemaset.Add(null, XmlReader.Create(xsdstream));
doc.Schemas = schemaset;
doc.Validate(this.SoapValidationEventHandler);
var docElement = doc.DocumentElement;
if (docElement == null)
{
throw new MyException(ESB_TraceCategory.ESB, ESB_ErrorCodes.ESB.NotValidSOAP_1, "DocumentElement为空");
}
// 解析soap的内容。soap响应成功和失败的结构不一样，
if (docElement.FirstChild.FirstChild.LocalName.ToLower() == "fault")
{
// 异常消息
this.IsSuccessed = false;
foreach (XmlNode node in docElement.FirstChild.FirstChild)
{
if (node.LocalName.ToLower() == "faultstring")
{
this.FaultString = node.InnerText.Trim();
}
}
}
else
{
// 正常消息
this.IsSuccessed = true;
this.targetNamespace = docElement.FirstChild.FirstChild.NamespaceURI;
var responseNode = docElement.FirstChild.FirstChild;
// 提取response节点名称、服务操作名称、result节点名称
var responseNodeLocalName = responseNode.LocalName;
this.OperationName = responseNodeLocalName.Substring(0, responseNodeLocalName.Length - 8);
// TODO: 该处应从wsdl中取得返回元素名称
var resultNodeLocalName = this.OperationName + "Result";
if (responseNode.FirstChild == null)
{
// 无任何返回值（无<xxxResult>节点，也无out参数）
this.ResultString = string.Empty;
}
else
{
// 取出Result节点下的内容，这就是真实的返回值
// Result节点下可能是text，也可能是xml元素。所以先用ReadSubtree把Result节点缓存起来，用于读取下面的xml子节点，ReadSubtree()执行不会往后移动游标。
var childNote = responseNode.FirstChild;
// 如果存在<xxxResult>节点
if (string.Compare(childNote.LocalName, resultNodeLocalName, StringComparison.CurrentCultureIgnoreCase) == 0)
{
this.ResultString = this.GetSubContent(childNote);
childNote = childNote.NextSibling;
}
// 取出out类型返回参数，可能有多个
while (childNote != null)
{
this.OutParamReturnValues[childNote.LocalName] = this.GetSubContent(childNote);
childNote = childNote.NextSibling;
}
}
}
}
else
{
throw new MyException(ESB_TraceCategory.ESB, ESB_ErrorCodes.ESB.NotValidSOAP_1, "schema文件【" + EsbConfig.Soap11SchemaResPath + "】不存在");
}
}
catch (Exception ex)
{
var ex1 = new MyException(ESB_TraceCategory.ESB, ESB_ErrorCodes.ESB.NotValidSOAP_1, ex, ex.Message);
ex1.ExceptionData.Add("SoapResponseMessage", this.RawString);
throw ex1;
}
}
public void FailingAction_InvokedThroughThreadPoolGSO_PreservesExceptionAsInnerException()
{
using (ScopedSynchronizationContext x = new ScopedSynchronizationContext(new SynchronizationContext()))
{
GenericSynchronizingObject test = new GenericSynchronizingObject();
Exception errorToThrow = new MyException();
Exception innerErrorCaught = null;
try
{
test.Invoke((MethodInvoker)(() => { throw errorToThrow; }), null);
}
catch (TargetInvocationException ex)
{
innerErrorCaught = ex.InnerException;
}
Assert.AreSame(errorToThrow, innerErrorCaught, "Exception not preserved");
}
}
public void FailingAction_InvokedThroughActionThreadGSO_PreservesExceptionAsInnerException()
{
using (ActionThread thread = new ActionThread())
{
thread.Start();
// Capture GenericSynchronizingObject
GenericSynchronizingObject test = thread.DoGet(() => { return new GenericSynchronizingObject(); });
Exception errorToThrow = new MyException();
Exception innerErrorCaught = null;
try
{
test.Invoke((MethodInvoker)(() => { throw errorToThrow; }), null);
}
catch (TargetInvocationException ex)
{
innerErrorCaught = ex.InnerException;
}
Assert.AreSame(errorToThrow, innerErrorCaught, "Exception not preserved");
}
}
