public static void Main(string[] args)
{
nick = "SecureIRC";
owner = "SecureIRC";
server = "irc.entalyan.com";
port = 6999;
chan = "#SecureIRC";
pass = ""; //Enter just the password
//Connect to irc server and get input and output text streams from TcpClient.
sock.Connect(server, port);
if (!sock.Connected)
{
Console.WriteLine("Failed to connect!");
return;
}
input = new System.IO.StreamReader(sock.GetStream());
output = new System.IO.StreamWriter(sock.GetStream());
//Starting USER and NICK login commands
output.Write(
"PASS " + nick + ":" + pass + "\r\n" +
"USER " + nick + " 0 * :" + owner + "\r\n" +
"NICK " + nick + "\r\n" +
"PRIVMSG #SecureIRC Successful login at: " + DateTime.Now.ToString() + "\r\n"
);
output.Flush();
Listen();
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
/// <summary>
/// Formats a complete HTML document describing the given
/// <see cref="Error"/> instance.
/// </summary>
public override void Format(TextWriter writer, Error error)
{
if (writer == null) throw new ArgumentNullException("writer");
if (error == null) throw new ArgumentNullException("error");
var page = new ErrorMailHtmlPage(error);
writer.Write(page.TransformText());
}
protected override void DumpChildren(TextWriter Out, uint Depth)
{
foreach (VEntry e in Fields.Values) {
Indent(Out, Depth);
Out.Write(e.Name);
Out.WriteLine(" =");
e.Value.Dump(Out, Depth+1);
}
}
/** Need to take note of AlwaysDoubleQuotePropertyNames when writing property type
Always escape property name with double quotes
**/
int writeTypeAliasProperty(TextWriter writer, Object to, TypeAliaser typeAliaser, int currentFramePropertyCount)
{
if (typeAliaser != null)
{
if (currentFramePropertyCount > 0) writer.Write(',');
string strAliasPropertyWrapper = AlwaysDoubleQuotePropertyNames ? "\"" : "";
writer.Write(strAliasPropertyWrapper + this.TypeAliasProperty + strAliasPropertyWrapper + ":\"" + typeAliaser(to.GetType()) + "\"");
return 1;
}
else
{
return 0;
}
}
// This method is REQUIRED if the template contains any Razor helpers, but you may choose to implement it differently
//
/// <summary>
/// Conditionally writes an attribute to a TextWriter.
/// </summary>
/// <param name="writer">The TextWriter to which to write the attribute.</param>
/// <param name="name">The name of the attribute.</param>
/// <param name="prefix">The prefix of the attribute.</param>
/// <param name="suffix">The suffix of the attribute.</param>
/// <param name="values">Attribute values, each specifying a prefix, value and whether it's a literal.</param>
///<remarks>Used by Razor helpers to write attributes.</remarks>
protected static void WriteAttributeTo(System.IO.TextWriter writer, string name, string prefix, string suffix, params Tuple <string, object, bool>[] values)
{
// this is based on System.Web.WebPages.WebPageExecutingBase
// Copyright (c) Microsoft Open Technologies, Inc.
// Licensed under the Apache License, Version 2.0
if (values.Length == 0)
{
// Explicitly empty attribute, so write the prefix and suffix
writer.Write(prefix);
writer.Write(suffix);
return;
}
bool first = true;
bool wroteSomething = false;
for (int i = 0; i < values.Length; i++)
{
Tuple <string, object, bool> attrVal = values [i];
string attPrefix = attrVal.Item1;
object value = attrVal.Item2;
bool isLiteral = attrVal.Item3;
if (value == null)
{
// Nothing to write
continue;
}
// The special cases here are that the value we're writing might already be a string, or that the
// value might be a bool. If the value is the bool 'true' we want to write the attribute name instead
// of the string 'true'. If the value is the bool 'false' we don't want to write anything.
//
// Otherwise the value is another object (perhaps an IHtmlString), and we'll ask it to format itself.
string stringValue;
bool? boolValue = value as bool?;
if (boolValue == true)
{
stringValue = name;
}
else if (boolValue == false)
{
continue;
}
else
{
stringValue = value as string;
}
if (first)
{
writer.Write(prefix);
first = false;
}
else
{
writer.Write(attPrefix);
}
if (isLiteral)
{
writer.Write(stringValue ?? value);
}
else
{
WriteTo(writer, stringValue ?? value);
}
wroteSomething = true;
}
if (wroteSomething)
{
writer.Write(suffix);
}
}
// This method is REQUIRED, but you may choose to implement it differently
//
/// <summary>Writes a literal value to the template output without HTML escaping it.</summary>
/// <param name="value">The literal value.</param>
protected void WriteLiteral(string value)
{
__razor_writer.Write(value);
}
protected void dump_SimboloAbstracto(System.IO.TextWriter cout, int n, SimboloAbstracto sym)
{
cout.Write(Utilidades.pad(n));
cout.WriteLine(sym.Texto);
}
public static Test.ITestIntfPrx allTests(TestHelper helper)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
string sref = "test:" + helper.GetTestEndpoint(0);
var obj = IObjectPrx.Parse(sref, communicator);
TestHelper.Assert(obj != null);
var proxy = Test.ITestIntfPrx.UncheckedCast(obj);
TestHelper.Assert(proxy != null);
System.IO.TextWriter output = helper.GetWriter();
output.Write("testing enum values... ");
output.Flush();
TestHelper.Assert((int)Test.ByteEnum.benum1 == 0);
TestHelper.Assert((int)Test.ByteEnum.benum2 == 1);
TestHelper.Assert((int)Test.ByteEnum.benum3 == Test.Constants.ByteConst1);
TestHelper.Assert((int)Test.ByteEnum.benum4 == Test.Constants.ByteConst1 + 1);
TestHelper.Assert((int)Test.ByteEnum.benum5 == Test.Constants.ShortConst1);
TestHelper.Assert((int)Test.ByteEnum.benum6 == Test.Constants.ShortConst1 + 1);
TestHelper.Assert((int)Test.ByteEnum.benum7 == Test.Constants.IntConst1);
TestHelper.Assert((int)Test.ByteEnum.benum8 == Test.Constants.IntConst1 + 1);
TestHelper.Assert((int)Test.ByteEnum.benum9 == Test.Constants.LongConst1);
TestHelper.Assert((int)Test.ByteEnum.benum10 == Test.Constants.LongConst1 + 1);
TestHelper.Assert((int)Test.ByteEnum.benum11 == Test.Constants.ByteConst2);
TestHelper.Assert((int)Test.ShortEnum.senum1 == 3);
TestHelper.Assert((int)Test.ShortEnum.senum2 == 4);
TestHelper.Assert((int)Test.ShortEnum.senum3 == Test.Constants.ByteConst1);
TestHelper.Assert((int)Test.ShortEnum.senum4 == Test.Constants.ByteConst1 + 1);
TestHelper.Assert((int)Test.ShortEnum.senum5 == Test.Constants.ShortConst1);
TestHelper.Assert((int)Test.ShortEnum.senum6 == Test.Constants.ShortConst1 + 1);
TestHelper.Assert((int)Test.ShortEnum.senum7 == Test.Constants.IntConst1);
TestHelper.Assert((int)Test.ShortEnum.senum8 == Test.Constants.IntConst1 + 1);
TestHelper.Assert((int)Test.ShortEnum.senum9 == Test.Constants.LongConst1);
TestHelper.Assert((int)Test.ShortEnum.senum10 == Test.Constants.LongConst1 + 1);
TestHelper.Assert((int)Test.ShortEnum.senum11 == Test.Constants.ShortConst2);
TestHelper.Assert((int)Test.IntEnum.ienum1 == 0);
TestHelper.Assert((int)Test.IntEnum.ienum2 == 1);
TestHelper.Assert((int)Test.IntEnum.ienum3 == Test.Constants.ByteConst1);
TestHelper.Assert((int)Test.IntEnum.ienum4 == Test.Constants.ByteConst1 + 1);
TestHelper.Assert((int)Test.IntEnum.ienum5 == Test.Constants.ShortConst1);
TestHelper.Assert((int)Test.IntEnum.ienum6 == Test.Constants.ShortConst1 + 1);
TestHelper.Assert((int)Test.IntEnum.ienum7 == Test.Constants.IntConst1);
TestHelper.Assert((int)Test.IntEnum.ienum8 == Test.Constants.IntConst1 + 1);
TestHelper.Assert((int)Test.IntEnum.ienum9 == Test.Constants.LongConst1);
TestHelper.Assert((int)Test.IntEnum.ienum10 == Test.Constants.LongConst1 + 1);
TestHelper.Assert((int)Test.IntEnum.ienum11 == Test.Constants.IntConst2);
TestHelper.Assert((int)Test.IntEnum.ienum12 == Test.Constants.LongConst2);
TestHelper.Assert((int)Test.SimpleEnum.red == 0);
TestHelper.Assert((int)Test.SimpleEnum.green == 1);
TestHelper.Assert((int)Test.SimpleEnum.blue == 2);
output.WriteLine("ok");
output.Write("testing enum operations... ");
output.Flush();
{
(Test.ByteEnum r, Test.ByteEnum o) = proxy.opByte(Test.ByteEnum.benum1);
TestHelper.Assert(r == Test.ByteEnum.benum1 && o == Test.ByteEnum.benum1);
(r, o) = proxy.opByte(Test.ByteEnum.benum11);
TestHelper.Assert(r == Test.ByteEnum.benum11 && o == Test.ByteEnum.benum11);
}
{
(Test.ShortEnum r, Test.ShortEnum o) = proxy.opShort(Test.ShortEnum.senum1);
TestHelper.Assert(r == Test.ShortEnum.senum1 && o == Test.ShortEnum.senum1);
(r, o) = proxy.opShort(Test.ShortEnum.senum11);
TestHelper.Assert(r == Test.ShortEnum.senum11 && o == Test.ShortEnum.senum11);
}
{
(Test.IntEnum r, Test.IntEnum o) = proxy.opInt(Test.IntEnum.ienum1);
TestHelper.Assert(r == Test.IntEnum.ienum1 && o == Test.IntEnum.ienum1);
(r, o) = proxy.opInt(Test.IntEnum.ienum11);
TestHelper.Assert(r == Test.IntEnum.ienum11 && o == Test.IntEnum.ienum11);
(r, o) = proxy.opInt(Test.IntEnum.ienum12);
TestHelper.Assert(r == Test.IntEnum.ienum12 && o == Test.IntEnum.ienum12);
}
{
(Test.SimpleEnum r, Test.SimpleEnum o) = proxy.opSimple(Test.SimpleEnum.green);
TestHelper.Assert(r == Test.SimpleEnum.green && o == Test.SimpleEnum.green);
}
output.WriteLine("ok");
output.Write("testing enum sequences operations... ");
output.Flush();
{
var b1 = new Test.ByteEnum[11]
{
Test.ByteEnum.benum1,
Test.ByteEnum.benum2,
Test.ByteEnum.benum3,
Test.ByteEnum.benum4,
Test.ByteEnum.benum5,
Test.ByteEnum.benum6,
Test.ByteEnum.benum7,
Test.ByteEnum.benum8,
Test.ByteEnum.benum9,
Test.ByteEnum.benum10,
Test.ByteEnum.benum11
};
(Test.ByteEnum[] b3, Test.ByteEnum[] b2) = proxy.opByteSeq(b1);
for (int i = 0; i < b1.Length; ++i)
{
TestHelper.Assert(b1[i] == b2[i]);
TestHelper.Assert(b1[i] == b3[i]);
}
}
{
var s1 = new Test.ShortEnum[11]
{
Test.ShortEnum.senum1,
Test.ShortEnum.senum2,
Test.ShortEnum.senum3,
Test.ShortEnum.senum4,
Test.ShortEnum.senum5,
Test.ShortEnum.senum6,
Test.ShortEnum.senum7,
Test.ShortEnum.senum8,
Test.ShortEnum.senum9,
Test.ShortEnum.senum10,
Test.ShortEnum.senum11
};
(Test.ShortEnum[] s3, Test.ShortEnum[] s2) = proxy.opShortSeq(s1);
for (int i = 0; i < s1.Length; ++i)
{
TestHelper.Assert(s1[i] == s2[i]);
TestHelper.Assert(s1[i] == s3[i]);
}
}
{
var i1 = new Test.IntEnum[11]
{
Test.IntEnum.ienum1,
Test.IntEnum.ienum2,
Test.IntEnum.ienum3,
Test.IntEnum.ienum4,
Test.IntEnum.ienum5,
Test.IntEnum.ienum6,
Test.IntEnum.ienum7,
Test.IntEnum.ienum8,
Test.IntEnum.ienum9,
Test.IntEnum.ienum10,
Test.IntEnum.ienum11
};
(Test.IntEnum[] i3, Test.IntEnum[] i2) = proxy.opIntSeq(i1);
for (int i = 0; i < i1.Length; ++i)
{
TestHelper.Assert(i1[i] == i2[i]);
TestHelper.Assert(i1[i] == i3[i]);
}
}
{
var s1 = new Test.SimpleEnum[3]
{
Test.SimpleEnum.red,
Test.SimpleEnum.green,
Test.SimpleEnum.blue
};
(Test.SimpleEnum[] s3, Test.SimpleEnum[] s2) = proxy.opSimpleSeq(s1);
for (int i = 0; i < s1.Length; ++i)
{
TestHelper.Assert(s1[i] == s2[i]);
TestHelper.Assert(s1[i] == s3[i]);
}
}
output.WriteLine("ok");
return(proxy);
}
public void SaveAs(System.IO.TextWriter _textwriter)
{
this.AddRule(true, "Default", null, null, null, defaultRuleActionType, defaultRuleProxyID);
_textwriter.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
_textwriter.Write("\r\n<ProxifierProfile version=\"101\" platform=\"Windows\" product_id=\"1\" product_minver=\"310\">");
_textwriter.Write("\r\n" + profileOptions());
if (this.innerProxyList.Count > 0)
{
_textwriter.Write("\r\n" + profileProxyList());
}
else
{
_textwriter.Write("\r\n <ProxyList />");
}
if (this.innerChainList.Count > 0)
{
_textwriter.Write("\r\n" + profileChain());
}
else
{
_textwriter.Write("\r\n <ChainList />");
}
_textwriter.Write("\r\n <RuleList>");
if (this.innerRuleList.Count > 0)
{
_textwriter.Write("\r\n" + profileRuleList());
}
_textwriter.Write("\r\n </RuleList>");
_textwriter.Write("\r\n</ProxifierProfile>");
_textwriter.Flush();
}
public virtual void xmlSerializeRootClose(TextWriter outWriter)
{
outWriter.Write("</" + GetType().FullName + ">\n");
}
protected override void WriteTriviaTo(System.IO.TextWriter writer)
{
writer.Write(Text);
}
public static void RunWithController(TestHelper helper, IControllerPrx controller)
{
Communicator?communicator = helper.Communicator;
TestHelper.Assert(communicator != null);
bool ice1 = TestHelper.GetTestProtocol(communicator.GetProperties()) == Protocol.Ice1;
var timeout = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), communicator);
System.IO.TextWriter output = helper.Output;
output.Write("testing connect timeout... ");
output.Flush();
{
Dictionary <string, string>?properties = communicator.GetProperties();
properties["Ice.ConnectTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
// Expect ConnectTimeoutException.
controller.HoldAdapter(-1);
try
{
to.Op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
{
// Expect success.
controller.HoldAdapter(100);
timeout.Op();
}
output.WriteLine("ok");
output.Write("testing invocation timeout... ");
output.Flush();
{
timeout.IcePing(); // Makes sure a working connection is associated with the proxy
Connection?connection = timeout.GetConnection();
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(100)).SleepAsync(1000).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
}
timeout.IcePing();
TestHelper.Assert(connection == timeout.GetConnection());
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(1000)).SleepAsync(100).Wait();
}
catch (AggregateException ex) when(ex.InnerException is OperationCanceledException)
{
TestHelper.Assert(false);
}
TestHelper.Assert(connection == timeout.GetConnection());
try
{
timeout.Clone(invocationTimeout: TimeSpan.FromMilliseconds(100)).Sleep(1000);
TestHelper.Assert(false);
}
catch (OperationCanceledException)
{
}
}
output.WriteLine("ok");
output.Write("testing close timeout... ");
output.Flush();
{
Dictionary <string, string> properties = communicator.GetProperties();
properties["Ice.CloseTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm);
Connection?connection = to.GetConnection();
Connection?connection2 = timeout.GetConnection(); // No close timeout
TestHelper.Assert(connection != null && connection2 != null);
controller.HoldAdapter(-1);
// Make sure there's no ReadAsync pending
_ = to.IcePingAsync();
_ = timeout.IcePingAsync();
var semaphore = new System.Threading.SemaphoreSlim(0);
connection.Closed += (sender, args) => semaphore.Release();
connection.GoAwayAsync();
TestHelper.Assert(semaphore.Wait(500));
connection2.Closed += (sender, args) => semaphore.Release();
connection2.GoAwayAsync();
TestHelper.Assert(!semaphore.Wait(500));
controller.ResumeAdapter();
timeout.Op(); // Ensure adapter is active.
}
output.WriteLine("ok");
if (!ice1)
{
output.Write("testing deadlines... ");
output.Flush();
{
var comm1 = new Communicator(communicator.GetProperties());
comm1.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.BinaryContextOverride.Add(10, ostr =>
{
var deadline = (request.Deadline - DateTime.UnixEpoch).TotalMilliseconds;
ostr.WriteVarLong((long)deadline);
});
return(next(target, request, cancel));
});
for (int i = 1000; i < 5000;)
{
i += 33;
ITimeoutPrx to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm1).Clone(
invocationTimeout: TimeSpan.FromMilliseconds(i));
TestHelper.Assert(to.CheckDeadline());
}
}
output.WriteLine("ok");
}
controller.Shutdown();
}
private static void Serialize(System.IO.TextWriter writer, IEnumerable <KeyValuePair <string, JValue> > value, int indentLevel, bool prettyPrint = false)
{
if (prettyPrint)
{
writer.WriteLine('{');
}
else
{
writer.Write('{');
}
int maxKeyLength = 0;
if (prettyPrint)
{
foreach (var item in value)
{
maxKeyLength = Math.Max(maxKeyLength, item.Key.Length);
}
maxKeyLength += 1;
}
bool isFirst = true;
foreach (var item in value)
{
if (isFirst == false)
{
if (prettyPrint)
{
writer.WriteLine(',');
}
else
{
writer.Write(',');
}
}
else
{
isFirst = false;
}
if (prettyPrint)
{
Indent(writer, indentLevel + 1);
}
writer.Write('"');
writer.Write(item.Key);
writer.Write('"');
writer.Write(':');
if (prettyPrint)
{
Spaces(writer, maxKeyLength - item.Key.Length);
}
Serialize(writer, item.Value, indentLevel + 1, prettyPrint);
}
if (prettyPrint)
{
writer.WriteLine();
Indent(writer, indentLevel);
}
writer.Write('}');
}
private static void WriteElementEnd(string elementName,
System.IO.TextWriter writer)
{
writer.Write("</{0}>", elementName);
}
public void Print(System.IO.TextWriter output)
{
output.Write("IntegerConstant:{" + Constant.ToString() + "}");
}
public override void Write(char value)
{
InnerWriter.Write(value);
}
private void writePropertyName(string propertyName, TextWriter writer)
{
bool escapeRequired = this.AlwaysDoubleQuotePropertyNames || (propertyName.IndexOf('.') >= 0);
if (escapeRequired) writer.Write('\"');
writer.Write(propertyName);
if (escapeRequired) writer.Write('\"');
}
/*
** Print a single opcode. This routine is used for debugging only.
*/
static void sqlite3VdbePrintOp( FILE pOut, int pc, Op pOp )
{
string zP4;
string zPtr = null;
string zFormat1 = "%4d %-13s %4d %4d %4d %-4s %.2X %s\n";
if ( pOut == null ) pOut = System.Console.Out;
zP4 = displayP4( pOp, zPtr, 50 );
string zOut = "";
sqlite3_snprintf( 999, ref zOut, zFormat1, pc,
sqlite3OpcodeName( pOp.opcode ), pOp.p1, pOp.p2, pOp.p3, zP4, pOp.p5,
#if SQLITE_DEBUG
pOp.zComment != null ? pOp.zComment : ""
#else
""
#endif
);
pOut.Write( zOut );
//fflush(pOut);
}
public static async Task RunAsync(TestHelper helper)
{
bool ice2 = helper.Protocol == Protocol.Ice2;
var prx = IMyObjectPrx.Parse(helper.GetTestProxy("test"), helper.Communicator !);
System.IO.TextWriter output = helper.Output;
output.Write("testing retry... ");
output.Flush();
TestHelper.Assert(prx.AddWithRetry(33, 12) == 45);
output.WriteLine("ok");
output.Write("testing remote exception... ");
output.Flush();
try
{
prx.BadAdd(33, 12);
TestHelper.Assert(false);
}
catch (InvalidInputException)
{
// expected
}
output.WriteLine("ok");
output.Write("testing ONE... ");
output.Flush();
try
{
prx.NotExistAdd(33, 12);
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
// expected
}
output.WriteLine("ok");
output.Write("testing exceptions raised by the interceptor... ");
output.Flush();
var exceptions = new List <(string operation, string kind)>
{
("raiseBeforeDispatch", "invalidInput"),
("raiseBeforeDispatch", "notExist"),
("raiseAfterDispatch", "invalidInput"),
("raiseAfterDispatch", "notExist")
};
foreach ((string operation, string kind) in exceptions)
{
var ctx = new Dictionary <string, string>
{
{ operation, kind }
};
try
{
prx.IcePing(ctx);
TestHelper.Assert(false);
}
catch (InvalidInputException) when(kind == "invalidInput")
{
}
catch (ObjectNotExistException) when(kind == "notExist")
{
}
}
output.WriteLine("ok");
output.Write("testing invocation interceptors... ");
output.Flush();
{
var tasks = new List <Task>();
var invocationContext = new AsyncLocal <int>();
await using var communicator = new Communicator(prx.Communicator.GetProperties());
communicator.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.WritableContext["interceptor-1"] = "interceptor-1";
if (ice2)
{
request.BinaryContextOverride.Add(110, ostr => ostr.WriteInt(110));
}
return(next(target, request, cancel));
},
async(target, request, next, cancel) =>
{
TestHelper.Assert(request.Context["interceptor-1"] == "interceptor-1");
request.WritableContext["interceptor-2"] = "interceptor-2";
if (ice2)
{
request.BinaryContextOverride.Add(120, ostr => ostr.WriteInt(120));
}
IncomingResponseFrame response = await next(target, request, cancel);
TestHelper.Assert(invocationContext.Value == int.Parse(request.Context["local-user"]));
if (ice2)
{
TestHelper.Assert(response.BinaryContext.ContainsKey(110));
TestHelper.Assert(response.BinaryContext[110].Read(istr => istr.ReadInt()) == 110);
TestHelper.Assert(response.BinaryContext.ContainsKey(120));
TestHelper.Assert(response.BinaryContext[120].Read(istr => istr.ReadInt()) == 120);
}
return(response);
});
await communicator.ActivateAsync();
for (int i = 0; i < 10; ++i)
{
invocationContext.Value = i;
var prx1 = IMyObjectPrx.Parse(prx.ToString() !, communicator);
Task t = prx1.Op1Async(new Dictionary <string, string> {
{ "local-user", $"{i}" }
});
tasks.Add(t);
}
Task.WaitAll(tasks.ToArray());
}
{
IncomingResponseFrame?response = null;
int invocations = 0;
// An interceptor can stop the chain and directly return a response without calling next,
// the first invocation calls next and subsequent invocations reuse the first response.
await using var communicator = new Communicator(prx.Communicator.GetProperties());
communicator.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.WritableContext["interceptor-1"] = "interceptor-1";
return(next(target, request, cancel));
},
async(target, request, next, cancel) =>
{
if (response == null)
{
response = await next(target, request, cancel);
}
return(response);
},
(target, request, next, cancel) =>
{
invocations++;
TestHelper.Assert(response == null);
return(next(target, request, cancel));
});
TestHelper.Assert(communicator.DefaultInvocationInterceptors.Count == 3);
await communicator.ActivateAsync();
TestHelper.Assert(communicator.DefaultInvocationInterceptors.Count == 4);
var prx1 = IMyObjectPrx.Parse(prx.ToString() !, communicator);
// Truly reference equal
TestHelper.Assert(prx1.InvocationInterceptors == communicator.DefaultInvocationInterceptors);
prx1.Op1(new Dictionary <string, string> {
{ "local-user", "10" }
});
prx1.Op1(new Dictionary <string, string> {
{ "local-user", "11" }
});
prx1.Op1(new Dictionary <string, string> {
{ "local-user", "12" }
});
TestHelper.Assert(invocations == 1);
}
{
// throwing from an interceptor stops the interceptor chain
await using var communicator = new Communicator(prx.Communicator.GetProperties());
communicator.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.WritableContext["interceptor-1"] = "interceptor-1";
return(next(target, request, cancel));
},
(target, request, next, cancel) =>
{
TestHelper.Assert(request.Context["interceptor-1"] == "interceptor-1");
throw new InvalidOperationException("stop interceptor chain");
},
(target, request, next, cancel) =>
{
TestHelper.Assert(false);
return(next(target, request, cancel));
});
await communicator.ActivateAsync();
var prx1 = IMyObjectPrx.Parse(prx.ToString() !, communicator);
try
{
prx1.Op1();
TestHelper.Assert(false);
}
catch (InvalidOperationException)
{
}
}
output.WriteLine("ok");
output.Write("testing binary context... ");
output.Flush();
if (ice2)
{
for (int size = 128; size < 4096; size *= 2)
{
var token = new Token(1, "mytoken", Enumerable.Range(0, size).Select(i => (byte)2).ToArray());
{
using var request = OutgoingRequestFrame.WithArgs(prx,
"opWithBinaryContext",
idempotent: false,
compress: false,
format: default,
context: null,
token,
Token.IceWriter);
request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token));
request.BinaryContextOverride.Add(3, ostr => ostr.WriteShort((short)size));
request.BinaryContextOverride.Add(
2,
ostr => ostr.WriteSequence(
Enumerable.Range(0, 10).Select(i => $"string-{i}").ToArray(),
(ostr, s) => ostr.WriteString(s)));
using IncomingResponseFrame response = prx.InvokeAsync(request).Result;
}
{
// repeat with compressed frame
using OutgoingRequestFrame request = OutgoingRequestFrame.WithArgs(prx,
"opWithBinaryContext",
idempotent: false,
compress: false,
format: default,
context: null,
token,
Token.IceWriter);
request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token));
request.BinaryContextOverride.Add(3, ostr => ostr.WriteShort((short)size));
request.BinaryContextOverride.Add(
2,
ostr => ostr.WriteSequence(
Enumerable.Range(0, 10).Select(i => $"string-{i}").ToArray(),
(ostr, s) => ostr.WriteString(s)));
TestHelper.Assert(request.CompressPayload() == CompressionResult.Success);
using IncomingResponseFrame response = prx.InvokeAsync(request).Result;
}
{
// repeat compressed the frame before writing the context
using OutgoingRequestFrame request = OutgoingRequestFrame.WithArgs(prx,
"opWithBinaryContext",
idempotent: false,
compress: false,
format: default,
context: null,
token,
Token.IceWriter);
TestHelper.Assert(request.CompressPayload() == CompressionResult.Success);
request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token));
request.BinaryContextOverride.Add(3, ostr => ostr.WriteShort((short)size));
request.BinaryContextOverride.Add(
2,
ostr => ostr.WriteSequence(
Enumerable.Range(0, 10).Select(i => $"string-{i}").ToArray(),
(ostr, s) => ostr.WriteString(s)));
using IncomingResponseFrame response = prx.InvokeAsync(request).Result;
}
}
}
else
{
var token = new Token(1, "mytoken", Enumerable.Range(0, 256).Select(i => (byte)2).ToArray());
using var request = OutgoingRequestFrame.WithArgs(prx,
"opWithBinaryContext",
idempotent: false,
compress: false,
format: default,
context: null,
token,
Token.IceWriter);
try
{
request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token));
TestHelper.Assert(false);
}
catch (NotSupportedException)
{
}
using IncomingResponseFrame response = prx.InvokeAsync(request).Result;
}
output.WriteLine("ok");
output.Write("testing per proxy invocation interceptors... ");
output.Flush();
{
var communicator = helper.Communicator !;
SortedDictionary <string, string>?context = prx.Op2();
TestHelper.Assert(context["context1"] == "plug-in");
TestHelper.Assert(context["context2"] == "plug-in");
TestHelper.Assert(!context.ContainsKey("context3"));
prx = prx.Clone(invocationInterceptors: ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.WritableContext["context2"] = "proxy";
request.WritableContext["context3"] = "proxy";
return(next(target, request, cancel));
}).AddRange(communicator.DefaultInvocationInterceptors));
context = prx.Op2();
TestHelper.Assert(context["context1"] == "plug-in");
TestHelper.Assert(context["context2"] == "plug-in");
TestHelper.Assert(context["context3"] == "proxy");
// Calling next twice doesn't change the result
prx = prx.Clone(invocationInterceptors: ImmutableList.Create <InvocationInterceptor>(
(target, request, next, cancel) =>
{
request.WritableContext["context2"] = "proxy";
request.WritableContext["context3"] = "proxy";
_ = next(target, request, cancel);
return(next(target, request, cancel));
}).AddRange(communicator.DefaultInvocationInterceptors));
context = prx.Op2();
TestHelper.Assert(context["context1"] == "plug-in");
TestHelper.Assert(context["context2"] == "plug-in");
TestHelper.Assert(context["context3"] == "proxy");
// Cloning the proxy preserve its interceptors
prx = prx.Clone(invocationTimeout: TimeSpan.FromSeconds(10));
context = prx.Op2();
TestHelper.Assert(context["context1"] == "plug-in");
TestHelper.Assert(context["context2"] == "plug-in");
TestHelper.Assert(context["context3"] == "proxy");
// The server increments the result with each call when using the invocation interceptor we
// return a cached response, and we will see the same result with each call.
IncomingResponseFrame?response = null;
prx = prx.Clone(invocationInterceptors: ImmutableList.Create <InvocationInterceptor>(
async(target, request, next, cancel) =>
{
response ??= await next(target, request, cancel);
return(response);
}).AddRange(communicator.DefaultInvocationInterceptors));
TestHelper.Assert(prx.Op3() == 0);
TestHelper.Assert(prx.Op3() == 0);
// After clearing the invocation interceptors we should see the result increase with each call
prx = prx.Clone(invocationInterceptors: communicator.DefaultInvocationInterceptors);
TestHelper.Assert(prx.Op3() == 1);
TestHelper.Assert(prx.Op3() == 2);
}
output.WriteLine("ok");
await prx.ShutdownAsync();
}
private void EmitLocals(string caption, TextWriter writer)
{
if (StackVarsOut.Count <= 0)
return;
writer.Write(caption);
SortedList<string, string> list = new SortedList<string, string>();
foreach (KeyValuePair<Storage, int> de in StackVarsOut)
{
Storage id = (Storage)de.Key;
StringWriter sb = new StringWriter();
id.Write(sb);
string sName = sb.ToString();
list[sName] = string.Format("{0}({1})", sName, de.Value);
}
foreach (string s in list.Values)
{
writer.Write(" ");
writer.Write(s);
}
writer.WriteLine();
}
/// <summary>
/// Writes fielddef as JSON. Do not call this method directly, instead call rowset.ToJSON() or use JSONWriter class
/// </summary>
void IJsonWritable.WriteAsJson(System.IO.TextWriter wri, int nestingLevel, JsonWritingOptions options)
{
var attr = this[null];
if (attr != null && attr.NonUI)
{
wri.Write("{}");
return; //nothing to write for NONUI
}
bool typeIsNullable;
string tp = JSONMappings.MapCLRTypeToJSON(m_Type, out typeIsNullable);
var map = new Dictionary <string, object>
{
{ "Name", m_Name },
{ "Order", m_Order },
{ "Type", tp },
{ "Nullable", typeIsNullable }
};
//20190322 DKh inner schema
if (typeof(Doc).IsAssignableFrom(this.NonNullableType))
{
map["IsDataDoc"] = true;
map["IsAmorphous"] = typeof(IAmorphousData).IsAssignableFrom(this.NonNullableType);
map["IsForm"] = typeof(Form).IsAssignableFrom(this.NonNullableType);
if (typeof(TypedDoc).IsAssignableFrom(this.NonNullableType))
{
var innerSchema = Schema.GetForTypedDoc(this.NonNullableType);
if (innerSchema.Any(fd => typeof(TypedDoc).IsAssignableFrom(fd.Type)))
{
map["DataDocSchema"] = "@complex";
}
else
{
map["DataDocSchema"] = innerSchema;
}
}
}
if (attr != null)
{
map.Add("IsKey", attr.Key);
map.Add("IsRequired", attr.Required);
map.Add("Visible", attr.Visible);
if (attr.Default != null)
{
map.Add("Default", attr.Default);
}
if (attr.CharCase != CharCase.AsIs)
{
map.Add("CharCase", attr.CharCase);
}
if (attr.Kind != DataKind.Text)
{
map.Add("Kind", attr.Kind);
}
if (attr.MinLength != 0)
{
map.Add("MinLen", attr.MinLength);
}
if (attr.MaxLength != 0)
{
map.Add("MaxLen", attr.MaxLength);
}
if (attr.Min != null)
{
map.Add("Min", attr.Min);
}
if (attr.Max != null)
{
map.Add("Max", attr.Max);
}
if (attr.ValueList != null)
{
map.Add("ValueList", attr.ValueList);
}
if (attr.Description != null)
{
map.Add("Description", attr.Description);
}
//metadata content is in the internal format and not dumped
}
JsonWriter.WriteMap(wri, map, nestingLevel, options);
}
public static async Task RunAsync(TestHelper helper)
{
Communicator communicator = helper.Communicator;
System.IO.TextWriter output = helper.Output;
var initial = IInitialPrx.Parse(helper.GetTestProxy("initial", 0), communicator);
output.Write("getting proxies for interface hierarchy... ");
output.Flush();
MA.IAPrx? ia = initial.Iaop();
MB.IB1Prx?ib1 = initial.Ib1op();
MB.IB2Prx?ib2 = initial.Ib2op();
MA.ICPrx? ic = initial.Icop();
TestHelper.Assert(ia != null);
TestHelper.Assert(ib1 != null);
TestHelper.Assert(ib2 != null);
TestHelper.Assert(ic != null);
TestHelper.Assert(ia != ib1);
TestHelper.Assert(ia != ib2);
TestHelper.Assert(ia != ic);
TestHelper.Assert(ib1 != ic);
TestHelper.Assert(ib2 != ic);
output.WriteLine("ok");
output.Write("invoking proxy operations on interface hierarchy... ");
output.Flush();
MA.IAPrx? iao;
MB.IB1Prx?ib1o;
MB.IB2Prx?ib2o;
MA.ICPrx? ico;
iao = ia.Iaop(ia);
TestHelper.Assert(iao !.Equals(ia));
iao = ia.Iaop(ib1);
TestHelper.Assert(iao !.Equals(ib1));
iao = ia.Iaop(ib2);
TestHelper.Assert(iao !.Equals(ib2));
iao = ia.Iaop(ic);
TestHelper.Assert(iao !.Equals(ic));
iao = ib1.Iaop(ia);
TestHelper.Assert(iao !.Equals(ia));
iao = ib1.Iaop(ib1);
TestHelper.Assert(iao !.Equals(ib1));
iao = ib1.Iaop(ib2);
TestHelper.Assert(iao !.Equals(ib2));
iao = ib1.Iaop(ic);
TestHelper.Assert(iao !.Equals(ic));
iao = ib2.Iaop(ia);
TestHelper.Assert(iao !.Equals(ia));
iao = ib2.Iaop(ib1);
TestHelper.Assert(iao !.Equals(ib1));
iao = ib2.Iaop(ib2);
TestHelper.Assert(iao !.Equals(ib2));
iao = ib2.Iaop(ic);
TestHelper.Assert(iao !.Equals(ic));
iao = ic.Iaop(ia);
TestHelper.Assert(iao !.Equals(ia));
iao = ic.Iaop(ib1);
TestHelper.Assert(iao !.Equals(ib1));
iao = ic.Iaop(ib2);
TestHelper.Assert(iao !.Equals(ib2));
iao = ic.Iaop(ic);
TestHelper.Assert(iao !.Equals(ic));
iao = ib1.Ib1op(ib1);
TestHelper.Assert(iao !.Equals(ib1));
ib1o = ib1.Ib1op(ib1);
TestHelper.Assert(ib1o !.Equals(ib1));
iao = ib1.Ib1op(ic);
TestHelper.Assert(iao !.Equals(ic));
ib1o = ib1.Ib1op(ic);
TestHelper.Assert(ib1o !.Equals(ic));
iao = ic.Ib1op(ib1);
TestHelper.Assert(iao !.Equals(ib1));
ib1o = ic.Ib1op(ib1);
TestHelper.Assert(ib1o !.Equals(ib1));
iao = ic.Ib1op(ic);
TestHelper.Assert(iao !.Equals(ic));
ib1o = ic.Ib1op(ic);
TestHelper.Assert(ib1o !.Equals(ic));
iao = ib2.Ib2op(ib2);
TestHelper.Assert(iao !.Equals(ib2));
ib2o = ib2.Ib2op(ib2);
TestHelper.Assert(ib2o !.Equals(ib2));
iao = ib2.Ib2op(ic);
TestHelper.Assert(iao !.Equals(ic));
ib2o = ib2.Ib2op(ic);
TestHelper.Assert(ib2o !.Equals(ic));
iao = ic.Ib2op(ib2);
TestHelper.Assert(iao !.Equals(ib2));
ib2o = ic.Ib2op(ib2);
TestHelper.Assert(ib2o !.Equals(ib2));
iao = ic.Ib2op(ic);
TestHelper.Assert(iao !.Equals(ic));
ib2o = ic.Ib2op(ic);
TestHelper.Assert(ib2o !.Equals(ic));
iao = ic.Icop(ic);
TestHelper.Assert(iao !.Equals(ic));
ib1o = ic.Icop(ic);
TestHelper.Assert(ib1o !.Equals(ic));
ib2o = ic.Icop(ic);
TestHelper.Assert(ib2o !.Equals(ic));
ico = ic.Icop(ic);
TestHelper.Assert(ico !.Equals(ic));
output.WriteLine("ok");
await initial.ShutdownAsync();
}
public static IMyClassPrx Run(TestHelper helper)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
var cl = IMyClassPrx.Parse(helper.GetTestProxy("test", 0), communicator);
IMyClassPrx oneway = cl.Clone(oneway: true);
System.IO.TextWriter output = helper.GetWriter();
output.Write("testing Invoke... ");
output.Flush();
{
var request = OutgoingRequestFrame.WithEmptyParamList(oneway, "opOneway", idempotent: false);
// Whether the proxy is oneway or not does not matter for Invoke's oneway parameter.
IncomingResponseFrame response = cl.Invoke(request, oneway: true);
TestHelper.Assert(response.ReplyStatus == ReplyStatus.OK);
response = cl.Invoke(request, oneway: false);
TestHelper.Assert(response.ReplyStatus == ReplyStatus.UserException);
response = oneway.Invoke(request, oneway: true);
TestHelper.Assert(response.ReplyStatus == ReplyStatus.OK);
response = oneway.Invoke(request, oneway: false);
TestHelper.Assert(response.ReplyStatus == ReplyStatus.UserException);
request = OutgoingRequestFrame.WithParamList(cl, "opString", idempotent: false,
format: null, context: null, TestString, OutputStream.IceWriterFromString);
response = cl.Invoke(request);
(string s1, string s2) = response.ReadReturnValue(communicator, istr =>
{
string s1 = istr.ReadString();
string s2 = istr.ReadString();
return(s1, s2);
});
TestHelper.Assert(s1.Equals(TestString) && s2.Equals(TestString));
}
for (int i = 0; i < 2; ++i)
{
Dictionary <string, string>?ctx = null;
if (i == 1)
{
ctx = new Dictionary <string, string>
{
["raise"] = ""
};
}
var request = OutgoingRequestFrame.WithEmptyParamList(cl, "opException", idempotent: false, context: ctx);
IncomingResponseFrame response = cl.Invoke(request);
try
{
response.ReadVoidReturnValue(communicator);
}
catch (MyException)
{
// expected
}
catch
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("testing InvokeAsync... ");
output.Flush();
{
var request = OutgoingRequestFrame.WithEmptyParamList(oneway, "opOneway", idempotent: false);
IncomingResponseFrame response;
try
{
response = oneway.InvokeAsync(request, oneway: true).AsTask().Result;
}
catch
{
TestHelper.Assert(false);
}
request = OutgoingRequestFrame.WithParamList(cl, "opString", idempotent: false,
format: null, context: null, TestString, OutputStream.IceWriterFromString);
response = cl.InvokeAsync(request).AsTask().Result;
(string s1, string s2) = response.ReadReturnValue(communicator, istr =>
{
string s1 = istr.ReadString();
string s2 = istr.ReadString();
return(s1, s2);
});
TestHelper.Assert(s1.Equals(TestString));
TestHelper.Assert(s2.Equals(TestString));
}
{
var request = OutgoingRequestFrame.WithEmptyParamList(cl, "opException", idempotent: false);
IncomingResponseFrame response = cl.InvokeAsync(request).AsTask().Result;
try
{
response.ReadVoidReturnValue(communicator);
TestHelper.Assert(false);
}
catch (MyException)
{
}
catch
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
return(cl);
}
public void Write(System.IO.TextWriter sr)
{
sr.Write(ToString());
}
protected override void WriteSelfEnd(System.IO.TextWriter writer)
{
writer.Write("</tr>");
}
protected void dumpLineaColumna(System.IO.TextWriter cout, int n)
{
cout.Write(Utilidades.pad(n) + "#" + linea + ":" + columna + ": ");
}
public static IInitialPrx Run(TestHelper helper)
{
Communicator?communicator = helper.Communicator;
TestHelper.Assert(communicator != null);
System.IO.TextWriter output = helper.Output;
output.Write("testing stringToProxy... ");
output.Flush();
var initial = IInitialPrx.Parse(helper.GetTestProxy("initial", 0), communicator);
output.WriteLine("ok");
{
output.Write("testing types without package... ");
output.Flush();
NoNamespace.C1?c1 = initial.GetNoNamespaceC2AsC1();
TestHelper.Assert(c1 != null);
TestHelper.Assert(c1 is NoNamespace.C2);
NoNamespace.C2?c2 = initial.GetNoNamespaceC2AsC2();
TestHelper.Assert(c2 != null);
try
{
initial.ThrowNoNamespaceE2AsE1();
TestHelper.Assert(false);
}
catch (NoNamespace.E1 ex)
{
TestHelper.Assert(ex is NoNamespace.E2);
}
try
{
initial.ThrowNoNamespaceE2AsE2();
TestHelper.Assert(false);
}
catch (NoNamespace.E2)
{
// Expected
}
try
{
initial.ThrowNoNamespaceNotify();
TestHelper.Assert(false);
}
catch (NoNamespace.@notify)
{
// Expected
}
output.WriteLine("ok");
}
{
output.Write("testing types with package... ");
output.Flush();
{
WithNamespace.C1?c1 = initial.GetWithNamespaceC2AsC1();
TestHelper.Assert(c1 != null);
TestHelper.Assert(c1 is WithNamespace.C2);
WithNamespace.C2?c2 = initial.GetWithNamespaceC2AsC2();
TestHelper.Assert(c2 != null);
try
{
initial.ThrowWithNamespaceE2AsE1();
TestHelper.Assert(false);
}
catch (WithNamespace.E1 ex)
{
TestHelper.Assert(ex is WithNamespace.E2);
}
try
{
initial.ThrowWithNamespaceE2AsE2();
TestHelper.Assert(false);
}
catch (WithNamespace.E2)
{
// Expected
}
output.WriteLine("ok");
}
}
return(initial);
}
// This method is REQUIRED if the template contains any Razor helpers, but you may choose to implement it differently
//
/// <summary>Writes a literal value to the TextWriter without HTML escaping it.</summary>
/// <param name="writer">The TextWriter to which to write the literal.</param>
/// <param name="value">The literal value.</param>
protected static void WriteLiteralTo(System.IO.TextWriter writer, string value)
{
writer.Write(value);
}
protected override void WriteMetadata(System.IO.TextWriter writer)
{
writer.Write(MetaGenerator._edmxJson);
}
public void writeAsJson(Object o, TextWriter writer, TypeAliaser typeAliaser=null)
{
if (LeafDefaultSet != null && OmitDefaultLeafValuesInJs && OmitMarkAsArrayFunction)
{
throw new Exception("Leaf defaulting requires Array marker for js code");
}
ObjectIDGenerator idGenerator = null;
if (UseReferences)
{
idGenerator=new ObjectIDGenerator();
}
Stack<ExploreStackFrame> exploreStack = new Stack<ExploreStackFrame>();
Explorer explorerImpl = ExplorerFactory();
((Explorer)explorerImpl).NodeExpander = NodeExpander;
MoveAway down = delegate (Object from, string propertyName, Object to, bool isIndexed, int? index)
{
ExploreStackFrame currentFrame = exploreStack.Count>0 ? exploreStack.Peek():null;
if (currentFrame != null)
{
if (currentFrame.propertyCount > 0) writer.Write(", ");
currentFrame.propertyCount++;
}
if (from != null && propertyName != null)
{
writePropertyName(propertyName, writer);
writer.Write(":");
}
ExploreStackFrame childFrame = new ExploreStackFrame();
exploreStack.Push(childFrame);
writeIndent(writer, exploreStack);
if (UseReferences)
{
bool firstTime;
long objectid = idGenerator.GetId(to, out firstTime);
if (firstTime)
{
// could be done like this ! (function() {var x=[1,2]; x.id="uuu";return x;})()
if (!isIndexed)
{
writer.Write("{" + this.IdTag + ":" + objectid + ' ');
childFrame.propertyCount++;
childFrame.propertyCount += writeTypeAliasProperty(writer, to, typeAliaser, childFrame.propertyCount);
}
else
{
// no need for type alias
writer.Write(AttachId2ArrayFunctionName + "(" + objectid + ",[");
}
}
else
{
writer.Write("{" + this.ReferenceTag + ":" + objectid);
return false;
}
}
else // !Use References
{
if (!isIndexed)
{
writer.Write('{');
// todo -- check this out ............
childFrame.propertyCount += writeTypeAliasProperty(writer, to, typeAliaser, childFrame.propertyCount);
}
else
{
if (!OmitMarkAsArrayFunction)
{
writer.Write(markAsArrayFunctionName);
writer.Write("([");
}
else
{
writer.Write("[");
}
}
}
return true;
};
MoveBack up = (from, propertyName, to, isIndexed) =>
{
if (!isIndexed) writer.Write('}');
else
{
writer.Write(']');
// is there a function wrapper ?
if (!OmitMarkAsArrayFunction || UseReferences) writer.Write(")");
}
exploreStack.Pop();
writeIndent(writer, exploreStack);
};
OnLeaf leaf = (from, propertyName, to, index) =>
{
//check for default leaf values
if (!this.OmitDefaultLeafValuesInJs ||
!isDefaultLeafValue(from, propertyName, to, LeafDefaultSet))
{
ExploreStackFrame currentFrame = exploreStack.Peek();
if (currentFrame.propertyCount > 0) writer.Write(", ");
currentFrame.propertyCount++;
if (propertyName!=null)
{
writePropertyName(propertyName, writer);
writer.Write(":");
}
writeLeafValue(writer, to, propertyName);
}
};
explorerImpl.explore(o, down, up, leaf);
}
public override void WriteText(Cosmos.Assembler.Assembler aAssembler, System.IO.TextWriter aOutput)
{
aOutput.Write(this.GetAsText());
}
void writeIndent(TextWriter writer, Stack<ExploreStackFrame> exploreStack)
{
if (IndentSize != null)
{
writer.Write(NewLine);
int fullIndentSize = ((int)IndentSize) * exploreStack.Count;
for (int done = 0; done < fullIndentSize; done++)
{
writer.Write(' ');
}
}
}
public static void allTestsWithController(TestHelper helper, IControllerPrx controller)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
var timeout = ITimeoutPrx.Parse($"timeout:{helper.GetTestEndpoint(0)}", communicator);
System.IO.TextWriter output = helper.GetWriter();
output.Write("testing connect timeout... ");
output.Flush();
{
var properties = communicator.GetProperties();
properties["Ice.ConnectTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse($"timeout:{helper.GetTestEndpoint(0)}", comm);
// Expect ConnectTimeoutException.
controller.holdAdapter(-1);
try
{
to.op();
TestHelper.Assert(false);
}
catch (ConnectTimeoutException)
{
// Expected.
}
controller.resumeAdapter();
timeout.op(); // Ensure adapter is active.
}
{
//
// Expect success.
//
controller.holdAdapter(100);
timeout.op();
}
output.WriteLine("ok");
// The sequence needs to be large enough to fill the write/recv buffers
byte[] seq = new byte[2000000];
output.Write("testing connection timeout... ");
output.Flush();
{
//
// Expect TimeoutException.
//
controller.holdAdapter(-1);
timeout.GetConnection() !.Acm = new Acm(TimeSpan.FromMilliseconds(50),
AcmClose.OnInvocationAndIdle,
AcmHeartbeat.Off);
try
{
timeout.sendData(seq);
TestHelper.Assert(false);
}
catch (ConnectionTimeoutException)
{
// Expected.
}
controller.resumeAdapter();
timeout.op(); // Ensure adapter is active.
}
{
//
// Expect success.
//
controller.holdAdapter(100);
try
{
timeout.sendData(new byte[1000000]);
}
catch (ConnectionTimeoutException)
{
TestHelper.Assert(false);
}
}
output.WriteLine("ok");
output.Write("testing invocation timeout... ");
output.Flush();
{
timeout.IcePing(); // Makes sure a working connection is associated with the proxy
var connection = timeout.GetConnection();
var to = timeout.Clone(invocationTimeout: 100);
TestHelper.Assert(connection == to.GetConnection());
try
{
to.sleep(1000);
TestHelper.Assert(false);
}
catch (TimeoutException)
{
}
timeout.IcePing();
to = timeout.Clone(invocationTimeout: 1000);
TestHelper.Assert(connection == to.GetConnection());
try
{
to.sleep(100);
}
catch (TimeoutException)
{
TestHelper.Assert(false);
}
TestHelper.Assert(connection == to.GetConnection());
}
{
//
// Expect TimeoutException.
//
var to = timeout.Clone(invocationTimeout: 100);
try
{
to.sleepAsync(1000).Wait();
}
catch (AggregateException ex) when(ex.InnerException is TimeoutException)
{
}
timeout.IcePing();
}
{
//
// Expect success.
//
var to = timeout.Clone(invocationTimeout: 1000);
to.sleepAsync(100).Wait();
}
output.WriteLine("ok");
output.Write("testing close timeout... ");
output.Flush();
{
var properties = communicator.GetProperties();
properties["Ice.CloseTimeout"] = "100ms";
using var comm = new Communicator(properties);
var to = ITimeoutPrx.Parse($"timeout:{helper.GetTestEndpoint(0)}", comm);
var connection = to.GetConnection();
var connection2 = timeout.GetConnection(); // No close timeout
TestHelper.Assert(connection != null && connection2 != null);
controller.holdAdapter(-1);
// Make sure there's no ReadAsync pending
_ = to.IcePingAsync();
_ = timeout.IcePingAsync();
var semaphore = new System.Threading.SemaphoreSlim(0);
connection.Closed += (sender, args) => semaphore.Release();
connection.Close(ConnectionClose.Gracefully);
TestHelper.Assert(semaphore.Wait(500));
connection2.Closed += (sender, args) => semaphore.Release();
connection2.Close(ConnectionClose.Gracefully);
TestHelper.Assert(!semaphore.Wait(500));
controller.resumeAdapter();
timeout.op(); // Ensure adapter is active.
}
output.WriteLine("ok");
output.Write("testing invocation timeouts with collocated calls... ");
output.Flush();
{
communicator.SetProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
var adapter = communicator.CreateObjectAdapter("TimeoutCollocated");
adapter.Activate();
var proxy = adapter.AddWithUUID(new Timeout(), ITimeoutPrx.Factory).Clone(invocationTimeout: 100);
try
{
proxy.sleep(500);
TestHelper.Assert(false);
}
catch (TimeoutException)
{
}
try
{
proxy.sleepAsync(500).Wait();
TestHelper.Assert(false);
}
catch (AggregateException ex) when(ex.InnerException is TimeoutException)
{
}
adapter.Dispose();
}
output.WriteLine("ok");
controller.shutdown();
}
/// <summary>
/// Writes CSV Representation of <paramref name="CSVData"/>
/// to <paramref name="TextWriter"/>
/// </summary>
/// <param name="TextWriter"><see cref="System.IO.TextWriter"/> destination to write CSV Text</param>
/// <param name="CSVData"><see cref="IEnumerable{T}"/> of Values to Serialize to CSV</param>
/// <param name="IncludeHeaderRow">
/// Indicates whether to add a header row at the top of the file with the Column Names
/// </param>
public void Serialize(System.IO.TextWriter TextWriter, IEnumerable<T> CSVData, bool IncludeHeaderRow = true)
=> TextWriter.Write(Serialize(CSVData, IncludeHeaderRow));
/// <summary>
/// 呈现本元素的数据
/// </summary>
/// <param name="writer"></param>
public override void Render(System.IO.TextWriter writer)
{
VariableTag tag = this;
object value = this.VarExpression.GetValue();
//调用自定函数处理此变量的值
if (this.CallFunctions.Count > 0)
{
foreach (var exp in this.CallFunctions)
{
object method = exp.GetValue();
if (!Utility.IsNothing(method))
{
UserDefinedFunction func;
if (this.OwnerTemplate.UserDefinedFunctions.TryGetValue(method.ToString(), out func))
{
value = func(new object[] { value });
}
}
}
}
if (Utility.IsNothing(value))
{
return;
}
bool formated = false;
string text = string.Empty;
string format = this.Format == null ? string.Empty : this.Format.GetTextValue();
if (value is string)
{
//字符串
text = (string)value;
}
else
{
//非字符串.则判断处理format
if (!string.IsNullOrEmpty(format))
{
IFormattable iformat = value as IFormattable;
if (iformat != null)
{
text = iformat.ToString(format, CultureInfo.InvariantCulture);
formated = true;
}
}
//非IFormattable接口.则直接取字符串处理
if (!formated)
{
//如果数据是IEnumerable,IEnumerator接口则进行数据拼凑
IEnumerator ie = null;
if (value is IEnumerable)
{
ie = ((IEnumerable)value).GetEnumerator();
}
else if (value is IEnumerator)
{
ie = (IEnumerator)value;
}
if (ie != null)
{
StringBuilder buffer = new StringBuilder();
ie.Reset();
while (ie.MoveNext())
{
if (buffer.Length != 0)
{
buffer.Append(",");
}
buffer.Append(ie.Current);
}
text = buffer.ToString();
}
else
{
text = value.ToString();
}
}
}
if (text.Length > 0)
{
bool removeHtml = this.RemoveHtml == null ? false : Utility.ConverToBoolean(this.RemoveHtml.GetTextValue());
bool textEncode = this.TextEncode == null ? false : Utility.ConverToBoolean(this.TextEncode.GetTextValue());
bool htmlEncode = this.HtmlEncode == null ? false : Utility.ConverToBoolean(this.HtmlEncode.GetTextValue());
bool xmlEncode = this.XmlEncode == null ? false : Utility.ConverToBoolean(this.XmlEncode.GetTextValue());
bool jsEncode = this.JsEncode == null ? false : Utility.ConverToBoolean(this.JsEncode.GetTextValue());
bool urlEncode = this.UrlEncode == null ? false : Utility.ConverToBoolean(this.UrlEncode.GetTextValue());
bool compressText = this.CompressText == null ? false : Utility.ConverToBoolean(this.CompressText.GetTextValue());
int length = this.Length == null ? 0 : Utility.ConverToInt32(this.Length.GetTextValue());
string appendText = this.AppendText == null ? string.Empty : this.AppendText.GetTextValue();
Encoding charset = this.Charset == null ? this.OwnerTemplate.Charset : Utility.GetEncodingFromCharset(this.Charset.GetTextValue(), this.OwnerTemplate.Charset);
if (removeHtml)
{
text = Utility.RemoveHtmlCode(text);
}
if (length > 0)
{
text = Utility.CutString(text, length, charset, appendText);
}
if (textEncode)
{
text = Utility.TextEncode(text);
}
else if (htmlEncode)
{
text = HttpUtility.HtmlEncode(text);
}
if (xmlEncode)
{
text = Utility.XmlEncode(text);
}
if (jsEncode)
{
text = Utility.JsEncode(text);
}
if (urlEncode)
{
text = HttpUtility.UrlEncode(text, charset);
}
if (compressText)
{
text = Utility.CompressText(text);
}
if (!formated && !string.IsNullOrEmpty(format))
{
text = string.Format(format, text);
}
writer.Write(text);
}
}
public virtual void xmlSerializeRootOpen(TextWriter outWriter)
{
StringBuilder buf = new StringBuilder(100);
buf.Append("<");
buf.Append(GetType().FullName + " ");
buf.Append("text=\"" + encode(getText()) + "\" type=\"" + Type + "\">\n");
outWriter.Write(buf.ToString());
}
protected static void Indent(TextWriter Out, uint Depth)
{
for (uint i = 0; i < Depth; i++) {
Out.Write(" ");
}
}
/// <summary>
/// Runs the test.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="testMethod">Test method.</param>
/// <param name="output">Output.</param>
public static void RunTest(string name, Action testMethod, TextWriter output = null)
{
if (output == null)
output = Console.Out;
string _oldNL = output.NewLine;
try
{
output.WriteLine(_runTestFormatStart, name);
testMethod();
output.WriteLine(_runTestFormatSuccess, name);
}
catch (FaultException<ExceptionDetail> ex)
{
output.WriteLine(_runTestFormatError, name);
output.WriteLine(_runTestFormatException, ex.GetType().FullName, ex.Message, ex.StackTrace);
foreach (DictionaryEntry de in ex.Data)
output.Write("\t{0} = {1}\n", de.Key.ToString(), de.Value.ToString());
int indent = 0;
for (ExceptionDetail detail = ex.Detail; detail != null; detail = detail.InnerException)
output.WriteLine(string.Concat(" ------ Inner Exception ------\n",
string.Format(_runTestFormatException, detail.Type, detail.Message, detail.StackTrace))
.Replace("\n", string.Concat("\n", new string(' ', ++indent * 2))).TrimStart('\n'));
}
catch (Exception ex)
{
output.WriteLine(_runTestFormatError, name);
output.WriteLine(_runTestFormatException, ex.GetType().FullName, ex.Message, ex.StackTrace);
foreach (DictionaryEntry de in ex.Data)
output.Write("\t{0} = {1}\n", de.Key.ToString(), de.Value.ToString());
int indent = 0;
for (Exception innerEx = ex.InnerException; innerEx != null; innerEx = innerEx.InnerException)
output.WriteLine(string.Concat("\n ------ Inner Exception ------\n",
string.Format(_runTestFormatException, innerEx.GetType().FullName, innerEx.Message, innerEx.StackTrace))
.Replace("\n", string.Concat("\n", new string(' ', ++indent * 2))).TrimStart('\n'));
}
finally
{
output.NewLine = _oldNL; // you COULD wrap this in a using() if you write a class implementing IDisposable with this line in Dispose()
}
}
public void Write(string s)
{
output.Write(s);
}
public override void WriteText(Assembler aAssembler, System.IO.TextWriter aOutput)
{
aOutput.Write("; ");
aOutput.Write(Text);
}
public static void Generate(List <Extraction.Doctest> doctests, System.IO.TextWriter writer)
{
var blocks = new List <string>();
string nl = Environment.NewLine;
blocks.Add(
$"// This file was automatically generated by doctest-csharp.{nl}" +
$"// !!! DO NOT EDIT OR APPEND !!!{nl}");
// Header blocks
string header = Style.MergeHeaders(doctests);
if (header.Length > 0)
{
blocks.Add(header);
}
blocks.Add($"using NUnit.Framework;{nl}");
// Doctests
List <Style.NamespacedDoctests> groupedDoctests = Style.GroupConsecutiveDoctestsByNamespace(doctests);
var namespaceCount = new Dictionary <string, int>();
foreach (var namespacedDoctests in groupedDoctests)
{
if (!namespaceCount.ContainsKey(namespacedDoctests.Namespace))
{
namespaceCount[namespacedDoctests.Namespace] = 0;
}
namespaceCount[namespacedDoctests.Namespace]++;
var block = new System.IO.StringWriter();
block.WriteLine(
namespacedDoctests.Namespace == ""
? "namespace Tests"
: $"namespace {namespacedDoctests.Namespace}.Tests");
block.WriteLine("{"); // namespace opening
block.WriteLine(
namespaceCount[namespacedDoctests.Namespace] > 1
? $" public class DocTests{namespaceCount[namespacedDoctests.Namespace]}"
: " public class DocTests");
block.WriteLine(" {"); // class opening
for (var i = 0; i < namespacedDoctests.Doctests.Count; i++)
{
if (i > 0)
{
block.WriteLine();
}
var doctest = namespacedDoctests.Doctests[i];
block.WriteLine(" [Test]");
block.WriteLine($" public void AtLine{doctest.Line}AndColumn{doctest.Column}");
block.WriteLine(" {"); // method opening
block.WriteLine(
doctest.Body == ""
? Style.Indent("// Empty doctest", 3)
: Style.Indent(doctest.Body, 3));
block.WriteLine(" }"); // method closing
}
block.WriteLine(" }"); // class closing
block.WriteLine("}"); // namespace closing
blocks.Add(block.ToString());
}
blocks.Add(
$"// This file was automatically generated by doctest-csharp.{nl}" +
$"// !!! DO NOT EDIT OR APPEND !!!{nl}");
// Join blocks
foreach (string block in blocks)
{
if (!block.EndsWith(Environment.NewLine))
{
throw new InvalidOperationException(
$"Expected block to end with a new line, but got: {block}");
}
}
for (var i = 0; i < blocks.Count; i++)
{
if (i > 0)
{
writer.WriteLine();
}
// All block must end with a new-line character, so do not add a new line here.
writer.Write(blocks[i]);
}
}
public void Write(ContentItem item, string propertyName, System.IO.TextWriter writer)
{
writer.Write(item[propertyName]);
}
public override void WriteId(System.IO.TextWriter trapFile)
{
trapFile.Write(TransformedPath.DatabaseId);
trapFile.Write(";sourcefile");
}
