public void Utf32Test()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <String name=\"TheString\" type=\"utf32\" value=\"abc\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.String str = dom.dataModels[0][0] as Dom.String;
Assert.AreNotEqual(null, str);
Assert.AreEqual(Dom.StringType.utf32, str.stringType);
Assert.AreEqual("abc", (string)str.DefaultValue);
BitwiseStream value = str.Value;
Assert.AreEqual(Encoding.UTF32.GetBytes("abc"), value.ToArray());
}
public void StringDefaults()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <Defaults>"+
" <String lengthType=\"chars\" padCharacter=\"z\" nullTerminated=\"true\" type=\"utf8\"/>"+
" </Defaults>"+
" <DataModel name=\"TheDataModel\">"+
" <String name=\"TheNumber\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.String str = dom.dataModels[0][0] as Dom.String;
Assert.IsTrue(str.nullTerminated);
Assert.IsTrue(str.stringType == StringType.utf8);
Assert.IsTrue(str.lengthType == LengthType.Chars);
Assert.IsTrue(str.padCharacter == 'z');
}
protected Dom.XmlElement handleXmlNode(XmlNode node, string name)
{
Dom.XmlElement elem = null;
if (name != null)
{
elem = new Dom.XmlElement(name);
}
else
{
elem = new Dom.XmlElement();
}
elem.elementName = node.Name;
elem.ns = node.NamespaceURI;
foreach (System.Xml.XmlAttribute attrib in node.Attributes)
{
elem.Add(handleXmlAttribute(attrib));
}
foreach (XmlNode child in node.ChildNodes)
{
if (child.Name == "#text")
{
var str = new Dom.String();
str.DefaultValue = new Variant(child.Value);
elem.Add(str);
}
else if (!child.Name.StartsWith("#"))
{
elem.Add(handleXmlNode(child, null));
}
}
return(elem);
}
public override void asDataElement(DataElement parent, Dictionary <DataElement, Position> positions)
{
if (!(parent is Dom.Blob))
{
throw new PeachException("Error, Binary analyzer only operates on Blob elements!");
}
var blob = parent as Dom.Blob;
var data = blob.Value;
if (data.Length == 0)
{
return;
}
var block = new Block(blob.name);
var bs = new BitStream();
long chars = 0;
while (true)
{
int value = data.ReadByte();
if (value == -1)
{
break;
}
//if (isGzip(b, data))
//{
// throw new NotImplementedException("Handle Gzip data stream");
//}
if (isAsciiChar(value))
{
++chars;
}
else
{
if (chars >= MINCHARS)
{
long len = bs.LengthBits;
// Only treat this as a string if MINCHARS were found
bs.Seek(-chars, SeekOrigin.End);
var bits = bs.SliceBits(bs.LengthBits - bs.PositionBits);
var str = new Dom.String();
str.DefaultValue = new Variant(bits);
bs.Seek(-chars, SeekOrigin.End);
bs.SetLength(bs.Position);
// Save off any data before the string 1st
bs = saveData(block, bs, positions, data.PositionBits - 8 - len);
// Add the string 2nd
block.Add(str);
long end = data.PositionBits - 8;
long begin = end - (8 * chars);
if (positions != null)
{
positions[str] = new Position(begin, end);
}
// Potentially analyze the string further
if (analyzeStrings)
{
var other = positions != null ? new Dictionary <DataElement, Position>() : null;
new StringTokenAnalyzer(args).asDataElement(str, other);
if (other != null)
{
foreach (var kv in other)
{
positions[kv.Key] = new Position(kv.Value.begin + begin, kv.Value.end + begin);
}
}
}
}
chars = 0;
}
bs.WriteByte((byte)value);
}
bs = saveData(block, bs, positions, data.LengthBits - bs.LengthBits);
if (logger.IsDebugEnabled)
{
int count = block.EnumerateAllElements().Count();
logger.Debug("Created {0} data elements from binary data.", count);
}
parent.parent[parent.name] = block;
if (positions != null)
{
positions[block] = new Position(0, data.LengthBits);
}
}
public override void asDataElement(DataElement parent, object dataBuffer)
{
if (!(parent is Dom.Blob))
{
throw new PeachException("Error, Binary analyzer only operates on Blob elements!");
}
var blob = parent as Dom.Blob;
var data = blob.Value;
Block block = new Block(blob.name);
if (data.LengthBytes == 0)
{
return;
}
List <byte> currentBlob = new List <byte>();
while (data.TellBytes() < data.LengthBytes)
{
byte b = data.ReadByte();
//if (isGzip(b, data))
//{
// throw new NotImplementedException("Handle Gzip data stream");
//}
if (isAsciiChar(b))
{
List <byte> possibleString = new List <byte>();
while (isAsciiChar(b))
{
possibleString.Add(b);
b = data.ReadByte();
}
if (possibleString.Count >= MINCHARS)
{
Blob newBlob = new Blob();
newBlob.DefaultValue = new Variant(currentBlob.ToArray());
currentBlob.Clear();
block.Add(newBlob);
Dom.String str = new Dom.String();
str.DefaultValue = new Variant(ASCIIEncoding.ASCII.GetString(possibleString.ToArray()));
block.Add(str);
if (analyzeStrings)
{
new StringTokenAnalyzer(args).asDataElement(str, str.DefaultValue);
}
}
else
{
currentBlob.AddRange(possibleString);
}
// Backup so we don't use that last byte
data.SeekBytes(-1, SeekOrigin.Current);
}
else
{
currentBlob.Add(b);
}
}
if (currentBlob.Count > 0)
{
blob = new Blob();
blob.DefaultValue = new Variant(currentBlob.ToArray());
currentBlob.Clear();
block.Add(blob);
}
if (logger.IsDebugEnabled)
{
int count = block.EnumerateAllElements().Count();
logger.Debug("Created {0} data elements from binary data.", count);
}
parent.parent[parent.name] = block;
}
public void Test7()
{
// Test that the random strategy is reproducable when starting at an
// arbitrary iteration when configured to cycles through data models
// with multiple actions
string temp1 = Path.GetTempFileName();
string temp2 = Path.GetTempFileName();
string temp3 = Path.GetTempFileName();
string temp4 = Path.GetTempFileName();
File.WriteAllBytes(temp1, Encoding.ASCII.GetBytes("Foo1"));
File.WriteAllBytes(temp2, Encoding.ASCII.GetBytes("Foo2Bar2"));
File.WriteAllBytes(temp3, Encoding.ASCII.GetBytes("Foo3Bar3Baz3"));
File.WriteAllBytes(temp4, Encoding.ASCII.GetBytes("Foo4Bar4Baz4Qux4"));
// Test loading a dataset from a file
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" +
"<Peach>" +
" <DataModel name=\"TheDataModel1\">" +
" <String name=\"str1\" value=\"Init\" maxOccurs=\"100\" lengthType=\"chars\" length=\"4\"/>" +
" </DataModel>" +
" <DataModel name=\"TheDataModel2\">" +
" <String name=\"str1\" value=\"Init\" maxOccurs=\"100\" lengthType=\"chars\" length=\"4\"/>" +
" </DataModel>" +
" <StateModel name=\"TheState\" initialState=\"Initial\">" +
" <State name=\"Initial\">" +
" <Action type=\"output\">" +
" <DataModel ref=\"TheDataModel1\"/>" +
" <Data fileName=\"" + temp1 + "\"/>" +
" <Data fileName=\"" + temp2 + "\"/>" +
" </Action>" +
" <Action type=\"output\">" +
" <DataModel ref=\"TheDataModel2\"/>" +
" <Data fileName=\"" + temp3 + "\"/>" +
" <Data fileName=\"" + temp4 + "\"/>" +
" </Action>" +
" </State>" +
" </StateModel>" +
" <Test name=\"Default\">" +
" <StateModel ref=\"TheState\"/>" +
" <Publisher class=\"Null\"/>" +
" <Strategy class=\"RandomStrategy\">" +
" <Param name=\"SwitchCount\" value=\"10\"/>" +
" </Strategy>" +
" </Test>" +
"</Peach>";
RunSwitchTest(xml, 1, 100);
// 2 actions, 100 mutations, switch every 10
Assert.AreEqual((100 + 10) * 2, dataModels.Count);
Assert.AreEqual(100 * 2, mutatedDataModels.Count);
var oldDataModels = dataModels;
var oldMutations = mutatedDataModels;
ResetContainers();
Assert.AreEqual(0, dataModels.Count);
Assert.AreEqual(0, mutatedDataModels.Count);
RunSwitchTest(xml, 48, 100);
// 2 actions, 53 mutations, control iterations at 48, 51, 61, 71, 81, 91
Assert.AreEqual((53 + 6) * 2, dataModels.Count);
Assert.AreEqual(53 * 2, mutatedDataModels.Count);
oldDataModels.RemoveRange(0, oldDataModels.Count - dataModels.Count);
Assert.AreEqual(dataModels.Count, oldDataModels.Count);
oldMutations.RemoveRange(0, oldMutations.Count - mutatedDataModels.Count);
Assert.AreEqual(oldMutations.Count, mutatedDataModels.Count);
// Because there are two actions, the first two entries in dataModels are the 0th iteration
var oldDm = oldMutations;
var newDm = mutatedDataModels;
for (int i = 2; i < oldDm.Count; ++i)
{
Assert.AreEqual(1, oldDm[i].Count);
Assert.AreEqual(1, newDm[i].Count);
Dom.Array item = newDm[i][0] as Dom.Array;
Dom.Array oldItem = oldDm[i][0] as Dom.Array;
Assert.AreNotEqual(null, item);
Assert.AreNotEqual(null, oldItem);
Assert.AreEqual(item.Count, oldItem.Count);
for (int j = 0; j < item.Count; ++j)
{
Dom.String str = item[j] as Dom.String;
Dom.String oldStr = oldItem[j] as Dom.String;
Assert.AreNotEqual(null, str);
Assert.AreNotEqual(null, oldStr);
Assert.AreEqual(str.InternalValue, oldStr.InternalValue);
}
}
}
/// <summary>
/// Split on token recursively
/// </summary>
/// <param name="el"></param>
/// <param name="token"></param>
/// <param name="offset"></param>
protected void splitOnToken(DataElement el, char token, ref long offset)
{
if (el is Dom.String)
{
var strEl = (Dom.String)el;
var str = (string)el.DefaultValue;
var tokenIndex = str.IndexOf(token);
if (tokenIndex == -1)
{
if (positions != null)
{
offset = positions[el].end;
}
return;
}
var preString = new Dom.String()
{
stringType = strEl.stringType
};
var tokenString = new Dom.String()
{
stringType = strEl.stringType
};
var postString = new Dom.String()
{
stringType = strEl.stringType
};
preString.stringType = encodingType;
tokenString.stringType = encodingType;
postString.stringType = encodingType;
preString.DefaultValue = new Variant(str.Substring(0, tokenIndex));
tokenString.DefaultValue = new Variant(token.ToString());
postString.DefaultValue = new Variant(str.Substring(tokenIndex + 1));
var block = new Dom.Block(el.name);
block.Add(preString);
block.Add(tokenString);
block.Add(postString);
el.parent[el.name] = block;
if (positions != null)
{
var lenPre = 8 * encoding.GetByteCount((string)preString.DefaultValue);
var lenToken = 8 * encoding.GetByteCount((string)tokenString.DefaultValue);
var lenPost = 8 * encoding.GetByteCount((string)postString.DefaultValue);
var prePos = new Position()
{
begin = offset, end = offset + lenPre
};
var tokenPos = new Position()
{
begin = prePos.end, end = prePos.end + lenToken
};
var postPos = new Position()
{
begin = tokenPos.end, end = tokenPos.end + lenPost
};
var blockPos = new Position()
{
begin = prePos.begin, end = postPos.end
};
positions.Remove(el);
positions[block] = blockPos;
positions[preString] = prePos;
positions[tokenString] = tokenPos;
positions[postString] = postPos;
offset = postPos.begin;
}
splitOnToken(postString, token, ref offset);
}
else if (el is Dom.Block)
{
List <DataElement> children = new List <DataElement>();
foreach (DataElement child in ((Block)el))
{
children.Add(child);
}
foreach (DataElement child in children)
{
splitOnToken(child, token, ref offset);
}
}
}
