public void Encode_RightNameValueContainFrameSeparator()
{
string nom = "blue";
string value = ";200";
string actual = FrameParser.Encode(nom, value);
}
public void Encode_RightNameValueContainValueSeparator_ValueContentException()
{
string nom = "blue";
string value = "=";
string actual = FrameParser.Encode(nom, value);
}
private static Response GetResponse(byte[] body, ProtocolVersion version = Version)
{
var header = FrameHeader.ParseResponseHeader(version, GetHeaderBuffer(body.Length), 0);
return(FrameParser.Parse(new Frame(
header, new MemoryStream(body), new SerializerManager(version).GetCurrentSerializer(), null)));
}
public void Encode_NameContainFrameSeparatorRightValue()
{
string nom = "bl;ue";
string value = "200";
string actual = FrameParser.Encode(nom, value);
}
public void Encode_NameContainValueSeparatorRightValue_ValueContentException()
{
string nom = "bl=ue";
int value = 100;
string actual = FrameParser.Encode(nom, value);
}
public void Merge_S1Wrong_ArgumentNullException()
{
string s1 = null;
string s0 = "RED=120";
FrameParser.Merge(s0, s1);
}
/// <summary>
/// This function parses the next frame from the stream and returns it.
/// </summary>
/// <param name="stream">The stream to parse the Frame from.</param>
/// <param name="version">The ID3 v2 Major version of the ID3 tag that the stream is reading.</param>
/// <param name="parserFactory">A FrameParserFactory to use to create FrameParsers based on Frame IDs.</param>
/// <param name="frameID">Output: outputs the frameID of the frame just parsed.</param>
/// <returns>The parsed Frame object.</returns>
/// <exception cref="ID3Utils.NoFrameParserProvidedException">
/// Thrown if the FrameParserFactory object passed did not recognize the Frame ID for the given version.
/// </exception>
public static Frame Parse(System.IO.Stream stream, ID3v2MajorVersion version, FrameParserFactory parserFactory, out string frameID)
{
FrameHeaderParser headerParser = FrameHeaderParser.CreateFrameHeaderParser(version);
FrameHeader header = headerParser.Parse(stream);
frameID = "";
if (header == null) // have reached the padding, no more frames.
{
return(null);
}
frameID = header.FrameID;
if (header.Length > 128 * 128 * 128 * 128)
{
throw new FatalException("Invalid frame length for frame with frame ID '" + frameID + "'.");
}
byte[] frameData = new byte[header.Length];
stream.Read(frameData, 0, frameData.Length);
FrameParser parser = parserFactory.CreateFrameParser(version, header.FrameID);
if (parser == null)
{
throw new NoFrameParserProvidedException(frameID, version, "No frame parser object is provided to parse this type of frame in this implementation.");
}
return(parser.ParseFrame(frameData));
}
public void Decode_RightNameAndValue_DecodedFrame()
{
string frame = "BLUE=200";
DataWrapper actual = FrameParser.Decode(frame);
Assert.IsTrue(actual.Name == "BLUE" && actual.Value.ToString() == "200");
}
public void TryToParse4WayHandshake_WithValidInput_ShouldGiveNonNullEAPOLKeyFormat(int i)
{
// Arrange and Act
FrameParser.TryToParse4WayHandshake(_4WHSDataFrames[i], out EAPOLKeyFormat keyFormat);
// Assert
Assert.IsNotNull(keyFormat);
}
protected SocketServer(ISocketManager socketManager, FrameParser <TMeta> frameParser,
Action <Exception> onError = default)
{
_cts = new CancellationTokenSource();
_onError = onError;
_socketManager = socketManager;
_frameParser = frameParser ?? throw new ArgumentNullException(nameof(frameParser));
}
public void Merge_S1Empty_EncodedFrame()
{
string s0 = "RED=120";
string s1 = "";
string merged = FrameParser.Merge(s0, s1);
Assert.AreEqual(s0, merged);
}
public void Merge_RightParameters_MergedFrame()
{
string s0 = "BLUE=210";
string s1 = "RED=120";
string merged = FrameParser.Merge(s0, s1);
Assert.AreEqual("BLUE=210;RED=120", merged);
}
public void Should_Parse_ErrorResponse_Of_Syntax_Error()
{
var body = GetErrorBody(0x2000, "Test syntax error");
var header = FrameHeader.ParseResponseHeader(Version, GetHeaderBuffer(body.Length), 0);
var response = FrameParser.Parse(new Frame(header, new MemoryStream(body), Serializer.GetCurrentSerializer()));
var ex = IsErrorResponse <SyntaxError>(response);
Assert.AreEqual("Test syntax error", ex.Message);
}
public void Encode_RightNameAndValue_NormalResult()
{
string rightName = "blue";
string rightValue = "200";
string excepted = "BLUE=200";
string actual = FrameParser.Encode(rightName, rightValue);
Assert.AreEqual(excepted, actual);
}
public void TryToParse4WayHandshake_WithValidInput_ShouldReturnCorrect4WHSNumber(int i)
{
// Arrange and Act
int handshakeNum = FrameParser.TryToParse4WayHandshake(
_4WHSDataFrames[i], out EAPOLKeyFormat _);
// Assert
Assert.AreEqual(i + 1, handshakeNum);
}
public override FrameParser CreateFrameParser(ID3v2MajorVersion version, string frameID)
{
FrameParser parser = LastPlayedOnFrame.CreateParser(version, frameID);
if (parser == null)
{
return(base.CreateFrameParser(version, frameID));
}
return(parser);
}
public void Encode_ArrayWithOneElement_EncodedFrame()
{
string excepted = "BLUE=100";
DataWrapper[] dws = new DataWrapper[] { new DataWrapper("BLUE", 100) };
string actual = FrameParser.Encode(dws);
Assert.AreEqual(excepted, actual);
}
static void Main(string[] args)
{
var from = StripQuotes(args[0]);
var to = StripQuotes(args[1]);
var parser = new FrameParser();
var romData = parser.Parse(from);
FrameSerializer.Export(to, romData);
}
public void Encode_RightDataWrapperArray_EncodedFrame()
{
DataWrapper[] dw = new DataWrapper[] {
new DataWrapper("BLUE", 200),
new DataWrapper("RED", 120)
};
string frame = FrameParser.Encode(dw);
Assert.AreEqual("BLUE=200;RED=120", frame);
}
public void Encode_RightDataWrapperList_ArgumentNullException()
{
System.Collections.Generic.List <DataWrapper> dw = new System.Collections.Generic.List <DataWrapper>()
{
new DataWrapper("BLUE", 200),
new DataWrapper("RED", 120)
};
string frame = FrameParser.Encode(dw);
Assert.AreEqual("BLUE=200;RED=120", frame);
}
static void Main(string[] args)
{
while (true)
{
Console.WriteLine("Enter un nom:");
string nom = Console.ReadLine();
Console.WriteLine("Entrer une valeur:");
string v = Console.ReadLine();
Console.WriteLine("Résultat: {0}", FrameParser.Encode(nom, v));
}
}
public void Should_Parse_ErrorResponse_With_Warnings()
{
// Protocol warnings are [string list]: A [short] n, followed by n [string]
var warningBuffers = BeConverter.GetBytes((ushort)1).Concat(GetProtocolString("Test warning"));
var body = warningBuffers.Concat(GetErrorBody(0x2000, "Test syntax error")).ToArray();
var header = FrameHeader.ParseResponseHeader(Version, GetHeaderBuffer(body.Length, HeaderFlags.Warning), 0);
var response = FrameParser.Parse(new Frame(header, new MemoryStream(body), Serializer.GetCurrentSerializer()));
var ex = IsErrorResponse <SyntaxError>(response);
Assert.AreEqual("Test syntax error", ex.Message);
}
public string Encode()
{
Color toColor = ToColor();
return(FrameParser.Encode(new List <DataWrapper>()
{
new DataWrapper("red", toColor.R),
new DataWrapper("green", toColor.G),
new DataWrapper("blue", toColor.B)
}));
}
static void Main(string[] args)
{
do
{
Console.WriteLine("Choisir option: \n1: Construire\n2: Déconstuire");
int choice = -1;
int.TryParse(Console.ReadLine(), out choice);
switch (choice)
{
case 1:
try
{
Console.WriteLine("Choisir un nom (ne doit pas contenir {0} {1})", FrameParser.FrameSeparator, FrameParser.NameValueSeparator);
string name = Console.ReadLine();
Console.WriteLine("Choisir une valeur (ne doit pas contenir {0} {1})", FrameParser.FrameSeparator, FrameParser.NameValueSeparator);
string value = Console.ReadLine();
Console.WriteLine("Trame contruite: {0}", FrameParser.Encode(name, value));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case 2:
try
{
Console.WriteLine("Entrer une trame (exemple: NOM{0}valeur):", FrameParser.NameValueSeparator);
string frame = Console.ReadLine();
Console.WriteLine("Trame décodée: {0}", FrameParser.Decode(frame).ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
case -1:
Console.WriteLine("Erreur");
break;
}
Console.WriteLine("Continuez? (O/N)");
}while (Console.ReadKey().Key != ConsoleKey.N);
}
private ID3v2MajorVersion Read(Stream stream, FrameParserFactory frameParserFactory)
{
TagHeader header = TagHeader.FromStream(stream);
if (header == null)
{
throw new FatalException("No ID3 v2 tag is attached to this file.");
}
if (!Enum.IsDefined(typeof(ID3v2MajorVersion), header.MajorVersion))
{
throw new FatalException("Reading this major version of ID3 v2 is not supported.");
}
if (header.Flags != TagHeaderFlags.None)
{
throw new FatalException("Reading tags with with any set flags are not supported in this version.");
}
long startingPosition = stream.Position;
while (stream.Position - startingPosition < header.TagSize)
{
long beginPosition = stream.Position;
Frame frame = null;
string frameID = "";
try
{
frame = FrameParser.Parse(stream, (ID3v2MajorVersion)header.MajorVersion, frameParserFactory, out frameID);
if (frame == null)
{
break;
}
}
catch (NonFatalException ex)
{
RaiseReadingWarning(ex, frameID);
}
if (beginPosition == stream.Position) // Probably stuck in an infinite loop because of corrupt data in file. Exit the loop.
{
break;
}
if (frame != null)
{
this.Frames.Add(frame);
}
}
return((ID3v2MajorVersion)header.MajorVersion);
}
private void HandleDataFrame(DataFrame dataFrame)
{
GetDestinationAndSource(
dataFrame, out AccessPoint accessPoint, out Station station);
int handshakeNum =
FrameParser.TryToParse4WayHandshake(dataFrame, out EAPOLKeyFormat keyFormat);
switch (handshakeNum)
{
case 1:
System.Console.WriteLine("Setting ANonce");
station.ANonce = keyFormat.KeyNonce;
break;
case 2:
System.Console.WriteLine("Setting SNonce");
station.SNonce = keyFormat.KeyNonce;
if ((station.ANonce != null) && (accessPoint.PairwiseMasterKey != null))
{
byte[] ptk = WPA2CryptographyTools.GeneratePairwiseTransientKey(
accessPoint.PairwiseMasterKey,
dataFrame.DestinationAddress.GetAddressBytes(),
dataFrame.SourceAddress.GetAddressBytes(),
station.ANonce,
station.SNonce);
System.Console.WriteLine("Setting ptk");
station.PairwiseTransientKey = ptk;
}
break;
case 3:
System.Console.WriteLine("4whs case 3");
break;
case 4:
System.Console.WriteLine("4whs case 4");
break;
default:
break;
}
}
public void Parse_ValidFrame()
{
string deviceId = "Device1";
object frame = new
{
DevEUI = deviceId,
Data = new List <object>
{
new
{
ts = 1517911845000,
temperature = 14.5,
humidity = 45,
pressure = 97300,
battery = 3.5
},
new
{
ts = 1517913645000,
temperature = 14.5,
humidity = 45,
pressure = 97300,
battery = 3.5
},
new
{
ts = 1517915445000,
temperature = 14.5,
humidity = 45,
pressure = 97300,
battery = 3.5
}
}
};
IEnumerable <Telemetry> telemetries = FrameParser.Parse(JsonConvert.SerializeObject(frame));
Check.That(telemetries).HasSize(3);
Check.That(telemetries).ContainsOnlyElementsThatMatch(e => e.DeviceId == deviceId);
}
public static void Run([EventHubTrigger("EventHubProcessing", Connection = "EventHubConnectionString")] string myEventHubMessage, TraceWriter log)
{
log.Info($"C# Event Hub trigger function processed a message: {myEventHubMessage}");
var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnectionString"].ConnectionString;
var dbName = ConfigurationManager.AppSettings["DatabaseName"];
var context = new DbContext(connectionString, dbName);
try
{
IEnumerable <Telemetry> message = FrameParser.Parse(myEventHubMessage);
foreach (var msg in message)
{
context.Database.GetCollection <Telemetry>(nameof(Telemetry)).InsertOne(msg);
}
}
catch (FormatException formatEx)
{
log.Error(formatEx.Message);
}
}
private void TestTextFrame(TextFrame frame, EncodingScheme encoding, ID3v2MajorVersion version)
{
string frameId;
FrameParserFactory factory = new FrameParserFactory();
FrameWriter writer = frame.CreateWriter(version, encoding);
if (writer == null)
{
return;
}
MemoryStream stream = new MemoryStream();
writer.WriteToStream(stream);
stream.Seek(0, SeekOrigin.Begin);
Frame writtenFrame = FrameParser.Parse(stream, version, factory, out frameId);
Assert.IsInstanceOfType(frame, writtenFrame.GetType());
TextFrame textFrame = (TextFrame)writtenFrame;
Assert.AreEqual(textFrame.Text, frame.Text);
}
/// <summary>
/// Returns an action that capture the parameters closure
/// </summary>
private Action <MemoryStream> CreateResponseAction(FrameHeader header, Action <Exception, Response> callback)
{
var compressor = Compressor;
void DeserializeResponseStream(MemoryStream stream)
{
Response response = null;
Exception ex = null;
var nextPosition = stream.Position + header.BodyLength;
try
{
Stream plainTextStream = stream;
if (header.Flags.HasFlag(FrameHeader.HeaderFlag.Compression))
{
plainTextStream = compressor.Decompress(new WrappedStream(stream, header.BodyLength));
plainTextStream.Position = 0;
}
response = FrameParser.Parse(new Frame(header, plainTextStream, _serializer));
}
catch (Exception catchedException)
{
ex = catchedException;
}
if (response is ErrorResponse)
{
//Create an exception from the response error
ex = ((ErrorResponse)response).Output.CreateException();
response = null;
}
//We must advance the position of the stream manually in case it was not correctly parsed
stream.Position = nextPosition;
callback(ex, response);
}
return(DeserializeResponseStream);
}
