public void HasMoreShouldBeTrue_WhenIndex_IsLowerThanLength()
{
ParseStream stream = new ParseStream("/text");
stream.Next();
Assert.True(stream.HasMore);
}
public void Forward_ShouldReturnNullChar_When_LastCharacterIsReached()
{
ParseStream stream = new ParseStream("/t");
stream.Forward();
Assert.AreEqual('\0', stream.Forward());
}
public void NextShouldIncrementIndex()
{
ParseStream stream = new ParseStream("/text");
stream.Next();
Assert.AreEqual(stream.Index.Index, 1);
}
public void CurrentCharShouldTheCharOfTheIndex()
{
ParseStream stream = new ParseStream("/text");
stream.Next();
Assert.AreEqual(stream.Current, 't');
}
/// <summary>
/// Static method to build the correct AuthorityPath obj from a String
/// </summary>
/// <param name="sPath"></param>
/// <returns></returns>
public static AuthorityPath buildAuthorityPath(string sPath)
{
ParseStream oStream = new ParseStream(sPath);
AuthorityPath oPath = scanAuthority(oStream);
// only return the path if the entire stream was consumed
return (oStream.getData().Length == 0) ? oPath : null;
}
public void NextCantMove_When_LastCharacterIsReached()
{
ParseStream stream = new ParseStream("/t");
stream.Next();
stream.Next();
stream.Next();
Assert.AreEqual(stream.Index.Index, 1);
}
public void ShouldThrowError_WhenTheSecondCharIsNot_Letter()
{
ParseStream parseStream = new ParseStream("/1ab");
TagParser parser = new TagParser(parseStream);
UnexpectedTokenException ex = Assert.Throws <UnexpectedTokenException>(() => parser.Parse());
Assert.AreEqual(1, ex.TokenIndex.Index);
Assert.AreEqual('1', ex.Character);
}
public void Create(string codeText, string value, string tagName, int index)
{
ParseStream parseStream = new ParseStream(codeText);
TagParser parser = new TagParser(parseStream);
TagToken token = parser.Parse();
Assert.AreEqual(value, token.Value);
Assert.AreEqual(tagName, token.TagName);
Assert.AreEqual(index, parseStream.Index.Index);
}
public void Create()
{
ParseStream stream = new ParseStream("/text");
Assert.AreEqual(stream.Text, "/text");
Assert.AreEqual(stream.Index.Line, 0);
Assert.AreEqual(stream.Index.Index, 0);
Assert.AreEqual(stream.Current, '/');
Assert.False(stream.Launched);
}
public void HasMoreShouldBeFalse_WhenIndex_IsAtTheLastCharacter()
{
ParseStream stream = new ParseStream("/text");
stream.Next();
stream.Next();
stream.Next();
stream.Next();
Console.WriteLine(stream.Text.Length + "=" + stream.Index.Index);
Assert.AreEqual(stream.Current, 't');
Assert.False(stream.HasMore);
}
bool doScan(ParseStream oStream)
{
if (oStream.empty() || oStream.getData()[0] != '#')
return false;
oStream.consume(1);
// read the characters, it is ok if they are empty
int n = scanIFragmentChars(oStream.getData());
oStream.consume(n);
return true;
}
/// <summary>
/// Parses the input stream into the obj
/// </summary>
/// <param name="oStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed into the obj</returns>
bool doScan(ParseStream oStream)
{
// NOTE: A RelativePath can be empty
if (oStream.empty())
{
return true;
}
// doesn't matter if this works or not, will consume what it needs to
scanXRISegments(oStream);
return true;
}
public void Unfiltered2()
{
Parser p = new Parser(StringToStream("1 0 obj<</Length 2>>stream\rde\nendstream\nendobj"));
ParseIndirectObject i = p.ParseIndirectObject() as ParseIndirectObject;
Assert.NotNull(i);
Assert.True(i.Id == 1);
Assert.True(i.Gen == 0);
Assert.NotNull(i.Object);
ParseStream o = i.Object as ParseStream;
Assert.NotNull(o);
Assert.True(o.Value == "de");
}
public void DeserializationMultipleMessageEntrepriseApplication()
{
Message message = new Message(0, 1, "Serialization - Message dans le bon format", "21/03/2015");
User user = new User("Vincent", "Couvignou", "*****@*****.**", "19/03/2015", "masculin", true, null, null, null);
DataContractJsonSerializer jsMessage = new DataContractJsonSerializer(typeof(Message));
DataContractJsonSerializer jsUser = new DataContractJsonSerializer(typeof(User));
MemoryStream m = new MemoryStream();
jsUser.WriteObject(m, user);
jsMessage.WriteObject(m, message);
m.Position = 0;
StreamReader s = new StreamReader(m, Encoding.UTF8);
List <string> listJson = ParseStream.ParseStreamToString(s);
Assert.IsTrue(listJson.Count == 2);
Message me = null;
User u = null;
foreach (var jsonItem in listJson)
{
StreamReader itemStream = new StreamReader(ParseStream.GenerateStreamFromString(jsonItem), Encoding.UTF8);
var userObject = JsonValue.Load(itemStream) as JsonObject;
Assert.IsNotNull(userObject);
MemoryStream mItem = new MemoryStream(Encoding.ASCII.GetBytes(jsonItem));
if ((int)userObject["message_type"] == (int)MessageType.USER_INFORMATION)
{
u = jsUser.ReadObject(mItem) as User;
Assert.IsTrue(true);
}
else if ((int)userObject["message_type"] == (int)MessageType.MESSAGE)
{
me = jsMessage.ReadObject(mItem) as Message;
Assert.IsTrue(true);
}
else
{
Assert.IsTrue(false);
}
}
Assert.IsNotNull(u);
Assert.IsNotNull(me);
Assert.IsTrue(me.Equals(message));
Assert.IsTrue(u.Equals(user) && me.Equals(message));
}
static XRIPath scanXRIPath(ParseStream oStream)
{
// check for a local path regardless of scanAuthority outcome
XRIAbsolutePath oPath = new XRIAbsolutePath();
if (oPath.scan(oStream))
{
return oPath;
}
else
{
XRINoSchemePath oRelativePath = new XRINoSchemePath();
if (oRelativePath.scan(oStream))
{
return oRelativePath;
}
}
return null;
}
internal static AuthorityPath scanAuthority(ParseStream oParseStream)
{
GCSAuthority oGCSAuthority = new GCSAuthority();
if (oGCSAuthority.scan(oParseStream))
{
return oGCSAuthority;
}
XRefAuthority oXRefAuthority = new XRefAuthority();
if (oXRefAuthority.scan(oParseStream))
{
return oXRefAuthority;
}
IRIAuthority oIRIAuthority = new IRIAuthority();
if (oIRIAuthority.scan(oParseStream))
{
return oIRIAuthority;
}
return null;
}
public void ParseStreamToStringTest_1()
{
StreamReader s = new StreamReader("UserCorrectFormat_1.json", Encoding.UTF8);
List <string> listJson = ParseStream.ParseStreamToString(s);
Assert.IsTrue(listJson.Count == 1);
MemoryStream memory = new MemoryStream();
StreamWriter streamWriter = new StreamWriter(memory);
streamWriter.Write(listJson[0]);
streamWriter.Flush();
memory.Position = 0;
var user = JsonValue.Load(memory) as JsonObject;
Assert.IsNotNull(user);
Assert.IsTrue((int)user["message_type"] == (int)MessageType.USER_INFORMATION);
s.Close();
s = new StreamReader("UserCorrectFormat_1.json", Encoding.UTF8);
DataContractJsonSerializer jsonUser = new DataContractJsonSerializer(typeof(User));
MemoryStream m = new MemoryStream(Encoding.ASCII.GetBytes(s.ReadToEnd()));
User userClass = jsonUser.ReadObject(m) as User;
}
/// <summary>
/// Parses the input stream into the obj
/// </summary>
/// <param name="oStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed into the obj</returns>
bool doScan(ParseStream oStream)
{
// make sure we start with a slash
if (oStream.empty() || (oStream.getData()[0] != '/'))
{
return false;
}
// consume the slash
oStream.consume(1);
// now scan the XRI segments as we are supposed to
base.scanXRISegments(oStream);
// return true no matter what, we got the slash
return true;
}
/// <summary>
/// Scans the Stream for a valid IRI-Authority
/// </summary>
/// <param name="oStream"></param>
/// <returns></returns>
bool doScan(ParseStream oStream)
{
bool bVal = false;
int n = scanChars(oStream.getData());
string sData = oStream.getData().Substring(0, n);
try
{
moURI = new Uri("http", sData, null, null, null);
String sHost = moURI.Host;
if ((sHost != null) && (sHost.Length > 0))
{
char cFirst = sHost[0];
bool bCheckIP = char.IsDigit(cFirst) ||
(cFirst == '[');
bVal = bCheckIP ? verifyIP(sHost) : verifyDNS(sHost);
}
}
catch (UriFormatException e)
{ }
// consume and return true if valid
if (bVal)
{
oStream.consume(n);
return true;
}
return false;
}
public CommentParser(ParseStream stream) : base(stream)
{
}
/// <summary>
/// Parses the input stream into the obj
/// </summary>
/// <param name="oStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed into the obj</returns>
bool doScan(ParseStream oStream)
{
if (!scanGCSChar(oStream))
{
return false;
}
// read in a segment, but bail if it isn't persistent in the ! namespace
XRISegment oSegment = new XRISegment(true, true, !msGCSRoot.Equals("!"));
if (oSegment.scan(oStream))
{
moSegment = oSegment;
}
return true;
}
/// <summary>
/// Parses the input stream into XRISegmentVals
/// </summary>
/// <param name="oPathStream">The input stream to scan from</param>
protected void scanXRISegments(ParseStream oPathStream)
{
// sets whether colons are allowed
bool bAllowColon = mbAllowColon;
// loop through the XRI segments as long as we are consuming something
bool bConsumed = true;
while (!oPathStream.empty() && bConsumed)
{
bConsumed = false;
ParseStream oStream = oPathStream.begin();
bool bStartsWithSlash = (oStream.getData()[0] == '/');
// if this is the first segment, it must not start with slash
if ((bStartsWithSlash) && (moSegments.Count == 0))
{
break;
}
// if this is not the first segment, we expect a slash
if ((!bStartsWithSlash) && (moSegments.Count > 0))
{
break;
}
// consume the slash if necessary
if (bStartsWithSlash)
{
bConsumed = true;
oStream.consume(1);
}
// if there is actually a segment, add it to the list
XRISegment oSegment = new XRISegment(true, bAllowColon, true);
if (oSegment.scan(oStream))
{
bConsumed = true;
moSegments.Add(oSegment);
}
// consume whatever we used (even if the segment was empty)
oPathStream.end(oStream);
// after the first segment, colons are allowed
bAllowColon = true;
}
}
/// <summary>
/// Parses the set value.
/// </summary>
/// <remarks>
/// Throws XRIParseException if entire value could not be parsed into the
/// obj
/// </remarks>
protected void parse()
{
string value = msValue;
// only do work if the value isn't already parsed
if (!mbParsed)
{
ParseStream oStream = new ParseStream(msValue);
if (scan(oStream))
{
// Did we consume the entire string?
mbParseResult = oStream.getData().Length == 0;
}
// Set to true even if we fail, no need to fail over and over again.
mbParsed = true;
}
// throw an exception if things failed
if (!mbParseResult)
{
throw new XRIParseException(
"Not a valid " + this.GetType().Name +
" class: \"" + value + "\"");
}
}
/// <summary>
/// Parses the input stream into the GCS Character String
/// </summary>
/// <param name="oParseStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed</returns>
private bool scanGCSChar(ParseStream oParseStream)
{
if (oParseStream.empty())
{
return false;
}
switch (oParseStream.getData()[0])
{
case '+':
case '=':
case '@':
case '$':
case '!':
{
// this way provides a clean copy, whereas substring does not
msGCSRoot = char.ToString(oParseStream.getData()[0]);
oParseStream.consume(1);
return true;
}
}
return false;
}
/// <summary>
/// Parses the input stream into the obj
/// </summary>
/// <param name="oStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed into the obj</returns>
bool doScan(ParseStream oStream)
{
if (oStream.getData()[0] == XRI.PDELIM)
{
this.mbPersistant = true;
oStream.consume(1);
}
else if (oStream.getData()[0] == XRI.RDELIM)
{
oStream.consume(1);
}
else if (!mbAllowImpliedDelimiter)
{
return false;
}
// if there is a cross-reference, it has priority in scanning
XRef oXRef = new XRef();
if (oXRef.scan(oStream))
{
moXRef = oXRef;
return true;
}
// read the characters, it is ok if they are empty
int n = scanPChars(oStream.getData());
oStream.consume(n);
return true;
}
public AttributeListParser(ParseStream stream) : base(stream)
{
}
public void BeforeEach()
{
stream = new ParseStream(text);
}
/// <summary>
/// Scans the stream for parts that can be parsed into the obj
/// </summary>
/// <param name="oParseStream">The input stream to read from</param>
/// <returns>Returns true if all or part of the stream could be
/// parsed into the obj</returns>
public bool scan(ParseStream oParseStream)
{
if (oParseStream == null)
{
return false;
}
ParseStream oStream = oParseStream.begin();
if (doScan(oStream))
{
setParsedValue(oParseStream.getConsumed(oStream));
oParseStream.end(oStream);
return true;
}
return false;
}
/// <summary>
/// Parses the input stream into the obj
/// </summary>
/// <param name="oStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed into the obj</returns>
bool doScan(ParseStream oStream)
{
moXRIPath = scanXRIPath(oStream);
return true;
}
/// <summary>
/// Returns a non-null String if an IRI is consumed from the stream
/// </summary>
/// <param name="oStream"></param>
/// <returns></returns>
static string scanIRI(ParseStream oStream)
{
int n = scanIRIChars(oStream.getData());
string data = oStream.getData().Substring(0, n);
try
{
// try parsing to check validity, Java's URI parser may not be IRI compliant so
// this is a TODO
Uri u = new Uri(data);
if (!u.IsAbsoluteUri)
{
return null;
}
}
catch (UriFormatException)
{
return null;
}
oStream.consume(n);
return data;
}
public HtmlCodeParser(ParseStream stream) : base(stream)
{
}
public Parser(ParseStream stream)
{
this.stream = stream;
}
public void Forward_ShouldReturn_TheCurrentCharacter()
{
ParseStream stream = new ParseStream("/text");
Assert.AreEqual('t', stream.Forward());
}
/// <summary> /// Scans the stream for parts that can be parsed into the obj /// </summary> /// <param name="oParseStream">The input stream to read from</param> /// <returns>Returns true if all or part of the stream could be /// parsed into the obj</returns> protected abstract bool doScan(ParseStream oParseStream);
public TagParser(ParseStream stream) : base(stream)
{
}
bool doScan(ParseStream oStream)
{
if (oStream.empty())
{
return false;
}
ParseStream oTempStream = oStream.begin();
// make sure we have a valid XRI Value
XRef oXRef = new XRef();
if (!oXRef.scan(oTempStream))
{
return false;
}
// at this point, we know we have enough for a valid xref
oStream.end(oTempStream);
moXRoot = oXRef;
// the cross-reference MAY be followed by an XRI Segment
// where the star cannot be assumed
XRISegment oSegment = new XRISegment(false, true, true);
if (oSegment.scan(oStream))
{
moSegment = oSegment;
}
return true;
}
/// <summary>
/// Returns a non-null XRIReference if an XRIReference is consumed from the
/// stream
/// </summary>
/// <param name="oStream"></param>
/// <returns></returns>
static XRIReference scanXRIReference(ParseStream oStream)
{
// make sure we have a valid XRI Value
XRI oXRI = new XRI();
if (oXRI.scan(oStream))
{
return oXRI;
}
// try parsing it as a relative XRI
RelativeXRI oRelXRI = new RelativeXRI();
if (oRelXRI.scan(oStream))
{
return oRelXRI;
}
return null;
}
bool doScan(ParseStream oStream)
{
if (oStream.empty())
{
return false;
}
if (oStream.getData()[0] != '(')
{
return false;
}
ParseStream oTempStream = oStream.begin();
oTempStream.consume(1);
String sIRI = null;
// make sure we have a valid XRI reference
XRIReference oRef = scanXRIReference(oTempStream);
if (oRef == null || oTempStream.empty() || (oTempStream.getData()[0] != ')'))
{
// if we got a reference, but the resulting temp stream is empty or does not begin with ')'
// it got parsed wrongly (happens if the XRef is an IRI). Retry parsing with an IRI
if (oRef != null)
{
oTempStream = oStream.begin();
oTempStream.consume(1);
}
// if there is no XRI Reference, see if it is an IRI
sIRI = scanIRI(oTempStream);
if (sIRI == null)
{
return false;
}
}
// make sure we have the trailing ')'
if (oTempStream.empty() || (oTempStream.getData()[0] != ')'))
{
return false;
}
// at this point, complete consumption and return true
oTempStream.consume(1);
oStream.end(oTempStream);
moXRIRef = oRef;
msIRI = sIRI;
return true;
}
public HtmlEntityParser(ParseStream stream) : base(stream)
{
}
/// <summary>
/// Parses the input stream into the obj
/// </summary>
/// <param name="oXRISegStream">The input stream to scan from</param>
/// <returns>True if part of the Stream was consumed into the obj</returns>
bool doScan(ParseStream oXRISegStream)
{
moSubSegments = new List<XRISubSegment>();
bool bAllowImpliedDelimiter = mbAllowImpliedDelimiter;
bool bAllowReassignable = mbAllowReassignable;
// loop through the stream, but don't consume the real string unless
// we are successful
while (!oXRISegStream.empty())
{
// determine if we have a delimiter for the next subsegment
char c = oXRISegStream.getData()[0];
// break out if the first character has to be persistent and isn't
if ((!bAllowReassignable) && (c != XRI.PDELIM))
{
break;
}
// check if we have a valid non-null subsegment
XRISubSegment oSubSegment = new XRISubSegment(bAllowImpliedDelimiter, mbAllowColon);
if (oSubSegment.scan(oXRISegStream))
{
// if we had a valid sub-segment, consume it and add it to the list
moSubSegments.Add(oSubSegment);
}
else
{
break;
}
bAllowImpliedDelimiter = false;
bAllowReassignable = true;
}
// if we have subsegments, we are good. Otherwise, it is an error
if (moSubSegments.Count > 0)
{
return true;
}
moSubSegments = null;
return false;
}