public void CreateIllustrationUsingTheFrameBuilder()
{
TextDocument document = new TextDocument();
document.New();
//Create a standard pargraph for the illustration
Paragraph paragraphStandard = ParagraphBuilder.CreateStandardTextParagraph(document);
//Create Illustration Frame using the FrameBuilder
Frame frameIllustration = FrameBuilder.BuildIllustrationFrame(
document,
"illustration_frame_1",
"graphic1",
new DiskFile(_imagefile),
"This is a Illustration",
1);
//Add the Illustration Frame to the Paragraph
paragraphStandard.Content.Add(frameIllustration);
Assert.IsTrue(frameIllustration.Content[0] is DrawTextBox, "Must be a DrawTextBox!");
Assert.IsTrue(((DrawTextBox)frameIllustration.Content[0]).Content[0] is Paragraph, "Must be a Paragraph!");
Paragraph paragraph = ((DrawTextBox)frameIllustration.Content[0]).Content[0] as Paragraph;
Assert.IsTrue(paragraph.TextContent[1] is TextSequence, "Must be a TextSequence!");
//Add Paragraph to the document
document.Content.Add(paragraphStandard);
//Save the document
using (IPackageWriter writer = new OnDiskPackageWriter())
{
document.Save(AARunMeFirstAndOnce.outPutFolder + "illustration.odt", new OpenDocumentTextExporter(writer));
}
}
// No need for these to be public!
public void SendSubscribeRequest(string channel)
{
FrameBuilder blder = new FrameBuilder();
blder.WriteString(channel);
socket.Send(blder.Build(FrameType.Subscribe));
}
public async Task <PostResult> PostMessage(string topic, byte[] data, QoS qos)
{
FrameBuilder bld = new FrameBuilder();
bld.WriteByte((byte)(qos == QoS.BestEffort ? 0x00 : 0x01));
// ToDo: Generate Frame Number to receive ACK.
currentPacketId++;
bld.WriteArray(BitConverter.GetBytes(currentPacketId));
bld.WriteString(topic);
bld.WriteMultiByte(data.Length);
bld.WriteArray(data);
if (qos == QoS.GuaranteedDelivery)
{
if (!syncSendInProcess.WaitOne(3000))
{
return(PostResult.DispatchError);
}
waitForPacketId = currentPacketId;
}
socket.Send(bld.Build(FrameType.ChannelEvent));
if (qos == QoS.GuaranteedDelivery)
{
var replyReceived = waitQosEvent.WaitOne(3000);
syncSendInProcess.ReleaseMutex();
return(replyReceived ? PostResult.Delivered
: PostResult.DeliveryError);
}
return(PostResult.Dispatched);
}
public void SendPublishReply(UInt32 messageId, PublishStatus status)
{
FrameBuilder bld = new FrameBuilder();
bld.WriteArray(BitConverter.GetBytes(messageId));
bld.WriteByte((byte)status);
socket.Send(bld.Build(FrameType.PubReply));
}
public virtual void SendUnsubReply(string channel)
{
FrameBuilder theBuilder = new FrameBuilder();
theBuilder.WriteString(channel);
socket.Send(theBuilder.Build(FrameType.UnsubReply));
}
public virtual void SendConnectionReply(ConnectionAttemptStatus status)
{
FrameBuilder theBuilder = new FrameBuilder();
theBuilder.WriteByte((byte)status);
socket.Send(theBuilder.Build(FrameType.ConReply));
}
protected override async Task <bool> OnStart()
{
_frameBuilderHighEnergy = new FrameBuilder();
_frameBuilderLowEnergy = new FrameBuilder();
var success = await base.OnStart();
return(success);
}
public virtual void SendSubscribeReply(string channel, SubscribeStatus status)
{
FrameBuilder theBuilder = new FrameBuilder();
theBuilder.WriteString(channel);
theBuilder.WriteByte((byte)status);
socket.Send(theBuilder.Build(FrameType.SubReply));
}
public void Frame_ReadAsync_FrameletTooLarge_Throws()
{
var frameletTooLargeStream =
new FrameBuilder().Count(1)
.Type(FrameletType.PayloadData)
.Size((UInt32)Int32.MaxValue + 1)
.TakeStream();
Assert.Throws <EpoxyProtocolErrorException>(async() => await Frame.ReadAsync(frameletTooLargeStream, CancellationToken.None, LoggerTests.BlackHole));
}
public void Subscribe_SendsSubscriptionRequest()
{
FrameBuilder blder = new FrameBuilder();
blder.WriteString("Fnord");
var theFrame = blder.Build(FrameType.Subscribe);
client.SendSubscribeRequest("Fnord");
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(theFrame))).MustHaveHappened();
}
internal Http2Protocol(SecureSocket socket, IStreamStore streamsStore, ProtocolOptions options)
{
this.options = options;
this.streamsStore = streamsStore;
this.serializer = new FrameSerializer(this.options);
this.builder = new FrameBuilder();
this.socket = socket;
this.isServer = true;
this.handshakeFinishedEventRaised = new ManualResetEvent(false);
}
public async Task Frame_ReadAsync_CancellationRequested_ReturnsNull()
{
var cts = new CancellationTokenSource();
cts.Cancel();
var goodStream = new FrameBuilder().Count(1).Type(FrameletType.ProtocolError).Size(4).Content(AnyContents).TakeStream();
Frame frame = await Frame.ReadAsync(goodStream, cts.Token, LoggerTests.BlackHole);
Assert.IsNull(frame);
}
public void SendConnectReply_ConRefused_SendsConnectionReply()
{
FrameBuilder bld = new FrameBuilder();
bld.WriteByte((byte)ConnectionAttemptStatus.Refused);
var expectedFrame = bld.Build(FrameType.ConReply);
p.SendConnectionReply(ConnectionAttemptStatus.Refused);
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(expectedFrame))).MustHaveHappened();
}
public void SendPublishReply_SendsMessageToPeer()
{
FrameBuilder bld = new FrameBuilder();
bld.WriteArray(BitConverter.GetBytes((UInt32)112233));
bld.WriteByte((byte)PublishStatus.Ack);
var expected = bld.Build(FrameType.PubReply);
p.SendPublishReply(112233, PublishStatus.Ack);
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(expected))).MustHaveHappened();
}
/// <summary>
/// Initializes a new instance of the <see cref="Http2Protocol"/> class.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="streamsStore">The streams store.</param>
/// <param name="options">Protocol options</param>
internal Http2Protocol(Uri uri, IStreamStore streamsStore, ProtocolOptions options)
{
this.options = options;
this.streamsStore = streamsStore;
this.serializer = new FrameSerializer(this.options);
this.builder = new FrameBuilder();
this.uri = uri;
this.isServer = false;
this.handshakeFinishedEventRaised = new ManualResetEvent(false);
}
public IFrame ToFrame()
{
var builder = new FrameBuilder();
builder.WriteByte((byte)MessageType);
builder.WriteString(ClientHostAddress.IpAddress);
builder.WriteInt(ClientHostAddress.Port);
WriteInternal(builder);
return(builder.ToFrame());
}
private void appendScanlinesToFrameBuilder(IEnumerable <IScanline> scanLines, Queue <IFrame> queueOfCommittedFrames, ref FrameBuilder frameBuilder)
{
foreach (var scanLine in scanLines)
{
frameBuilder.Lines.Add(scanLine);
if (frameBuilder.Lines.Count == SCANLINES_PER_FRAME)
{
queueOfCommittedFrames.Enqueue(frameBuilder.Commit());
frameBuilder = new FrameBuilder();
}
}
}
public void SendSubscribeReply_SendsSubscribeReply()
{
FrameBuilder bld = new FrameBuilder();
bld.WriteString("Test");
bld.WriteByte((byte)SubscribeStatus.Success);
var expectedFrame = bld.Build(FrameType.SubReply);
p.SendSubscribeReply("Test", SubscribeStatus.Success);
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(expectedFrame))).MustHaveHappened();
}
protected override async Task <bool> OnStop()
{
var success = await base.OnStop();
_frameBuilderHighEnergy.Dispose();
_frameBuilderHighEnergy = null;
_frameBuilderLowEnergy.Dispose();
_frameBuilderLowEnergy = null;
return(success);
}
public FireBallAnimation(Coord pt1, Coord pt2, Color color, string symbol = "*")
{
var line = new Line(pt1, pt2);
var fB = new FrameBuilder();
foreach (Coord pt in line)
{
fB.Clear();
fB.AddFrameItem(symbol, color, pt);
AddFrame(fB.Build());
}
}
private async Task FlashSector(object o, DynamicEventArgs dynamicEventArgs)
{
var sector = dynamicEventArgs.Arg0;
// When building center, we only need the v and h sectors.
var dims = new[]
{ _systemData.VSectors, _systemData.VSectors, _systemData.HSectors, _systemData.HSectors };
var builder = new FrameBuilder(dims, true, _systemData.UseCenter);
var col = Color.FromArgb(255, 255, 0, 0);
var emptyColors = ColorUtil.EmptyColors(_systemData.LedCount);
var emptySectors = ColorUtil.EmptyColors(_systemData.SectorCount);
emptySectors[sector - 1] = col;
var tMat = builder.Build(emptySectors);
foreach (var dev in _sDevices)
{
if (dev.Enable)
{
dev.Testing = true;
}
}
_splitter.DoSend = false;
await _splitter.Update(tMat);
var colors = _splitter.GetColors().ToArray();
var sectors = _splitter.GetSectors().ToArray();
await SendColors(colors, sectors, 0, true);
await Task.Delay(500);
await SendColors(emptyColors, emptySectors, 0, true);
await Task.Delay(500);
await SendColors(colors, sectors, 0, true);
await Task.Delay(1000);
await SendColors(emptyColors, emptySectors, 0, true);
foreach (var dev in _sDevices)
{
if (dev.Enable)
{
dev.Testing = false;
}
}
_splitter.DoSend = true;
}
public void Publish_SendsPublishframe()
{
FrameBuilder blder = new FrameBuilder();
blder.WriteByte((byte)QoS.BestEffort);
blder.WriteArray(new byte[] { 0x00, 0x00, 0x00, 0x00 });
blder.WriteString("What a great channel!");
blder.WriteString("This is my data!");
var theFrame = blder.Build(FrameType.Publish);
client.PostMessage("What a great channel!", Encoding.UTF8.GetBytes("This is my data!"), QoS.BestEffort);
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(theFrame))).MustHaveHappened();
}
public FireBallAnimation(Coord pt1, Coord pt2, Color color, string symbol = "*")
{
var line = new Line(pt1, pt2);
var fB = new FrameBuilder();
foreach (Coord pt in line)
{
fB.Clear();
fB.AddFrameItem(symbol, color, pt);
AddFrame(fB.Build());
}
}
public Task <PostResult> PostMessage(string topic, byte[] data, QoS qos)
{
FrameBuilder blder = new FrameBuilder();
blder.WriteByte((byte)qos);
// Empty packet id for now!
blder.WriteArray(new byte[] { 0x00, 0x00, 0x00, 0x00 });
blder.WriteString(topic);
blder.WriteMultiByte(data.Length);
blder.WriteArray(data);
var theFrame = blder.Build(FrameType.Publish);
socket.Send(theFrame);
return(new Task <PostResult>(() => PostResult.Dispatched));
}
/// <summary>
/// Initializes a new instance of the <see cref="SMProtocol"/> class.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="streamsStore">The streams store.</param>
/// <param name="options">Protocol options</param>
internal SMProtocol(Uri uri, IStreamStore streamsStore, SMProtocolOptions options)
{
this.streamsStore = streamsStore;
this.webSocket = new WebSocket(uri.ToString());
this.webSocket.OnOpen += this.OnSocketOpen;
this.webSocket.OnPing += this.OnSocketPing;
this.webSocket.OnClose += this.OnSocketClose;
if (options != null)
{
this.options = options;
}
this.serializer = new FrameSerializer(this.options);
this.builder = new FrameBuilder();
}
public void UnsubscribeFrame_CallsSubscriptionManager()
{
FrameBuilder fb = new FrameBuilder();
var bytes = Encoding.UTF8.GetBytes("Test");
fb.WriteMultiByte(bytes.Length);
fb.WriteArray(bytes);
var data = fb.GetData();
var frm = new Frame();
frm.payload = data;
frm.frameType = FrameType.Unsub;
peerMan.FrameReceived(frm, rpFake);
A.CallTo(() => subManFake.Unsubscribe(rpFake, "Test")).MustHaveHappened();
A.CallTo(() => rpFake.SendUnsubReply("Test")).MustHaveHappened();
}
public void PostMessage_QosGuaranteedDelivery_Fails_If_No_Reply_Arrives()
{
FrameBuilder bld = new FrameBuilder();
bld.WriteByte(0x01); // Reply Flag
bld.WriteArray(new byte[] { 0x01, 0x00, 0x00, 0x00 });
bld.WriteString("Fnord");
bld.WriteString("I am a payload");
var expected = bld.Build(FrameType.ChannelEvent);
var result = p.PostMessage("Fnord", Encoding.UTF8.GetBytes("I am a payload"), QoS.GuaranteedDelivery);
result.Wait();
Assert.Equal(PostResult.DeliveryError, result.Result);
}
public void PostMessage_SendsMessageToPeer()
{
FrameBuilder bld = new FrameBuilder();
bld.WriteByte(0x00); // No Flags!
bld.WriteArray(new byte[] { 0x01, 0x00, 0x00, 0x00 });
bld.WriteString("Fnord");
bld.WriteString("I am a payload");
var expected = bld.Build(FrameType.ChannelEvent);
var result = p.PostMessage("Fnord", Encoding.UTF8.GetBytes("I am a payload"), QoS.BestEffort);
result.Wait();
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(expected))).MustHaveHappened();
}
public AdaptationFunction(TransportTerminalFunction ttf)
{
Ttf = ttf;
Builder = new FrameBuilder();
Ttf.HandleInputFrame += new HandleInputFrame(GetDataFromFrame);
this.Streams = new List <StreamData>();
Dictionary <int, StmLevel> portsLevels = Ttf.GetPorts();
OutputCredentials = new Dictionary <int, IFrame>();
foreach (int portNumber in portsLevels.Keys)
{
OutputCredentials.Add(portNumber, new Frame(portsLevels[portNumber]));
}
}
public void CanExtract_FrameBuilderOutput()
{
FrameBuilder blder = new FrameBuilder();
blder.WriteByte(0x44); //Protocol Version 1
// empty client id for now
blder.WriteArray(new byte[16]);
blder.WriteMultiByte(0); // no secdata
blder.WriteMultiByte(0); // no lastwill channel
blder.WriteMultiByte(0); // no lastwill data
var theFrame = blder.Build(FrameType.Connect);
FrameExtractor fex = new FrameExtractor();
Assert.True(fex.TryExtract(theFrame, 23).success == FrameExtractor.ResultState.Ok);
}
public void PostMessage_QosGuaranteedDelivery_SetsReplyRequestBit()
{
FrameBuilder bld = new FrameBuilder();
bld.WriteByte(0x01); // Reply Flag
bld.WriteArray(new byte[] { 0x01, 0x00, 0x00, 0x00 });
bld.WriteString("Fnord");
bld.WriteString("I am a payload");
var expected = bld.Build(FrameType.ChannelEvent);
var result = p.PostMessage("Fnord", Encoding.UTF8.GetBytes("I am a payload"), QoS.GuaranteedDelivery);
result.Wait();
A.CallTo(() => socket.Send(A <byte[]> .That.IsSameSequenceAs(expected))).MustHaveHappened();
}
public GlowingAnimation(Atom atomToGlow, Color[] colors = null, int framePerColors = 7)
{
if(colors == null)
{
colors = new Color[]
{
Color.Yellow,
Color.Blue,
};
}
var symbol = atomToGlow.Symbol;
var pt = atomToGlow.Position;
var fB = new FrameBuilder();
foreach (Color color in colors)
{
fB.Clear();
fB.AddFrameItem(symbol, color, pt);
AddFrame(fB.Build());
}
}
public BlobsAnimation( List<Coord> centers,
int maxRadius,
Color color,
string symbol = "*")
{
var fB = new FrameBuilder();
for (int r = 2; r < Math.Max(3, maxRadius); r++)
{
var circles = centers.Select(c => new SimpleCircle(c, r));
fB.Clear();
foreach (var circle in circles)
{
foreach (Coord pt in circle)
{
fB.AddFrameItem(symbol, color, pt);
}
}
AddFrame(fB.Build());
}
}
/// <summary>
/// Initializes a new instance of the FrameDirector class.
/// </summary>
/// <param name="frameBuilder">An object of type FrameBuilder.</param>
public FrameDirector(FrameBuilder frameBuilder)
{
Validator.ValidateIsNotNull(frameBuilder, "frameBuilder");
this.frameBuilder = frameBuilder;
}
public async Task Frame_ReadAsync_CancellationRequested_ReturnsNull()
{
var cts = new CancellationTokenSource();
cts.Cancel();
var goodStream = new FrameBuilder().Count(1).Type(FrameletType.ProtocolError).Size(4).Content(AnyContents).TakeStream();
Frame frame = await Frame.ReadAsync(goodStream, cts.Token, LoggerTests.BlackHole);
Assert.IsNull(frame);
}
public void Frame_ReadAsync_EndOfStreamInContent_ReturnsNull()
{
var tooShortStream = new FrameBuilder().Count(1).Type(FrameletType.ProtocolError).Size(4).Content(AnyContents).TakeTooShortStream();
Assert.Null(Frame.ReadAsync(tooShortStream, CancellationToken.None, LoggerTests.BlackHole).Result);
}
public void Frame_ReadAsync_EndOfStreamInCount_ReturnsNull()
{
var tooShortStream = new FrameBuilder().Count(1).TakeTooShortStream();
Assert.Null(Frame.ReadAsync(tooShortStream, CancellationToken.None, LoggerTests.BlackHole).Result);
}
public void Frame_ReadAsync_FrameletTooLarge_Throws()
{
var frameletTooLargeStream =
new FrameBuilder().Count(1)
.Type(FrameletType.PayloadData)
.Size((UInt32) Int32.MaxValue + 1)
.TakeStream();
Assert.Throws<EpoxyProtocolErrorException>(async () => await Frame.ReadAsync(frameletTooLargeStream, CancellationToken.None, LoggerTests.BlackHole));
}
public void Frame_ReadAsync_UnknownFramelet_Throws()
{
var unknownFrameletStream = new FrameBuilder().Count(1).Type((FrameletType) UnknownFramelet).TakeStream();
Assert.Throws<EpoxyProtocolErrorException>(async () => await Frame.ReadAsync(unknownFrameletStream, CancellationToken.None, LoggerTests.BlackHole));
}
public void Frame_ReadAsync_ZeroFramelets_Throws()
{
var zeroFrameletsStream = new FrameBuilder().Count(0).TakeStream();
Assert.Throws<EpoxyProtocolErrorException>(async () => await Frame.ReadAsync(zeroFrameletsStream, CancellationToken.None, LoggerTests.BlackHole));
}
