public void CrackLeftovers()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Number name=\"count\" size=\"8\">"+
" <Relation type=\"count\" of=\"num\" />"+
" </Number>"+
" <Number name=\"num\" size=\"8\" minOccurs=\"2\"/>"+
" <String name=\"str\" length=\"9\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
var data = Bits.Fmt("{0}", "\x06QWERTYleftoversextrajunk");
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(3, dom.dataModels[0].Count);
Dom.Array array = (Dom.Array)dom.dataModels[0][1];
Assert.AreEqual(6, array.Count);
Assert.AreEqual("leftovers", (string)dom.dataModels[0][2].DefaultValue);
}
public void CrackArrayBlobZeroMore()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob length=\"1\" minOccurs=\"0\" maxOccurs=\"100\" />"+
" <Blob name=\"Rest\" length=\"6\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
var data = Bits.Fmt("{0}", new byte[] { 1, 2, 3, 4, 5, 6 });
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(0, array.Count);
Blob rest = (Blob)dom.dataModels[0].find("Rest");
Assert.AreEqual(new byte[] { 1, 2, 3, 4, 5, 6 }, rest.InternalValue.BitsToArray());
}
// PERFORM_MUTATION
//
public void performMutation(DataElement obj, int num)
{
logger.Debug("performMutation(num=" + num + ")");
Dom.Array objAsArray = (Dom.Array)obj;
//if (num == 0)
// return;
if (num < objAsArray.Count)
{
// remove some items
for (int i = objAsArray.Count - 1; i >= num; --i)
{
if (objAsArray[i] == null)
{
break;
}
objAsArray.RemoveAt(i);
}
}
else if (num > objAsArray.Count)
{
// add some items, but do it by replicating
// the last item over and over to save memory
objAsArray.ExpandTo(num);
}
}
public void CrackZeroArray()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <String value=\"Item\" minOccurs=\"0\" token=\"true\" />"+
" <Blob name=\"Rest\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(new byte[] { 1, 2, 3, 4, 5, 6 });
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(0, array.Count);
Blob rest = (Blob)dom.dataModels[0].find("Rest");
Assert.AreEqual(new byte[] { 1, 2, 3, 4, 5, 6 }, (byte[])rest.InternalValue);
}
public void CrackArrayBlob1()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob length=\"1\" minOccurs=\"1\" maxOccurs=\"100\" />"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(new byte[] { 1, 2, 3, 4, 5, 6 });
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(6, array.Count);
Assert.AreEqual(new byte[] { 1 }, (byte[])array[0].InternalValue);
Assert.AreEqual(new byte[] { 6 }, (byte[])array[5].InternalValue);
}
public void CrackArrayOfZeroOrOne()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <String name=\"str1\" nullTerminated=\"true\" minOccurs=\"0\" maxOccurs=\"1\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(Encoding.ASCII.GetBytes("Hello\x00"));
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(1, dom.dataModels[0].Count);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(1, array.Count);
string str = (string)array[0].InternalValue;
Assert.AreEqual("Hello", str);
}
public void CrackArrayRelation()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Number size=\"8\">"+
" <Relation type=\"count\" of=\"TheArray\"/>"+
" </Number>"+
" <Blob name=\"TheArray\" length=\"1\" minOccurs=\"0\" maxOccurs=\"100\" />"+
" <Blob name=\"Rest\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(new byte[] { 3, 1, 2, 3, 4, 5, 6 });
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Dom.Array array = (Dom.Array)dom.dataModels[0][1];
Blob blob = (Blob)dom.dataModels[0][2];
Assert.AreEqual(3, array.Count);
Assert.AreEqual(new byte[] { 1 }, (byte[])array[0].InternalValue);
Assert.AreEqual(new byte[] { 2 }, (byte[])array[1].InternalValue);
Assert.AreEqual(new byte[] { 3 }, (byte[])array[2].InternalValue);
Assert.AreEqual(new byte[] { 4, 5, 6 }, (byte[])blob.InternalValue);
}
public void ExpressionSetTest()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Number name=\"TheNumber\" size=\"8\">"+
" <Relation type=\"count\" of=\"Array\" expressionSet=\"count + 1\" />"+
" </Number>"+
" <String name=\"Array\" value=\"1\" maxOccurs=\"100\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Number num = dom.dataModels[0][0] as Number;
Dom.Array array = dom.dataModels[0][1] as Dom.Array;
array.origionalElement = array[0];
array.hasExpanded = true;
array.Add(new Dom.String("Child2")
{
DefaultValue = new Variant("2")
});
array.Add(new Dom.String("Child3")
{
DefaultValue = new Variant("3")
});
Assert.AreEqual(4, (int)num.InternalValue);
Assert.AreEqual("123", ASCIIEncoding.ASCII.GetString(array.Value.ToArray()));
}
public void CrackArrayWithTokenSibling()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Block minOccurs=\"0\">"+
" <Number name=\"num1\" size=\"8\" constraint=\"str(element.DefaultValue) != '0'\" />"+
" </Block>"+
" <Number name=\"zero\" size=\"8\" valueType=\"hex\" value=\"0\" token=\"true\" />"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(new byte[] { 0x01, 0x02, 0x03, 0x00 });
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(2, dom.dataModels[0].Count);
Dom.Array blockArray = dom.dataModels[0][0] as Dom.Array;
Assert.NotNull(blockArray);
Assert.AreEqual(3, blockArray.Count);
}
public void CrackArrayParentName()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <String name=\"str1\" nullTerminated=\"true\" minOccurs=\"1\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(Encoding.ASCII.GetBytes("Hello\x00World\x00"));
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(1, dom.dataModels[0].Count);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(2, array.Count);
Assert.AreEqual("TheDataModel.str1", array.fullName);
Assert.AreEqual("TheDataModel.str1.str1", array.origionalElement.fullName);
Assert.AreEqual("TheDataModel.str1.str1", array[0].fullName);
Assert.AreEqual("TheDataModel.str1.str1_1", array[1].fullName);
}
public void CrackArrayWithinArray()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Block occurs=\"3\">"+
" <Number name=\"num1\" size=\"8\" minOccurs=\"0\" constraint=\"str(element.DefaultValue) != '0'\" />"+
" <Number name=\"num2\" size=\"8\" valueType=\"hex\" value=\"00\" />"+
" </Block>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
var data = Bits.Fmt("{0}", new byte[] { 0x01, 0x02, 0x03, 0x00, 0x04, 0x00, 0x00 });
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(1, dom.dataModels[0].Count);
Dom.Array blockArray = dom.dataModels[0][0] as Dom.Array;
Assert.NotNull(blockArray);
Assert.AreEqual(3, blockArray.Count);
Block firstBlock = blockArray[0] as Block;
Assert.NotNull(firstBlock);
Dom.Array numArray = firstBlock[0] as Dom.Array;
Assert.NotNull(numArray);
Assert.AreEqual(3, numArray.Count);
}
public void CrackArrayOfOne()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <String name=\"str1\" nullTerminated=\"true\" minOccurs=\"1\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
var data = Bits.Fmt("{0}", "Hello\x00");
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(1, dom.dataModels[0].Count);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(1, array.Count);
string str = (string)array[0].InternalValue;
Assert.AreEqual("Hello", str);
}
public void TestArrayClone()
{
// If an array is cloned with a new name, the 1st element in the array needs
// to have its name updated as well
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob name=\"Data\" value=\"Hello World\" minOccurs=\"100\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.Array array = dom.dataModels[0][0] as Dom.Array;
Assert.NotNull(array);
Assert.AreEqual(100, array.Count);
Assert.AreEqual("Data", array.name);
Assert.AreEqual("Data", array[0].name);
var clone = array.Clone("NewData") as Dom.Array;
Assert.NotNull(clone);
Assert.AreEqual(100, clone.Count);
Assert.AreEqual("NewData", clone.name);
Assert.AreEqual("NewData", clone[0].name);
}
public void CrackArrayEmptyElementMin()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Block minOccurs=\"0\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.WriteByte(0);
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(1, dom.dataModels[0].Count);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(0, array.Count);
}
public void CrackCountOfLayers()
{
string xml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Peach>
<DataModel name=""TheDataModel"">
<Number size=""8"">
<Relation type=""count"" of=""x1""/>
</Number>
<Number size=""8"">
<Relation type=""count"" of=""y1""/>
</Number>
<Block name=""x1"" minOccurs=""0"">
<Block name=""y1"" minOccurs=""0"">
<String length=""1""/>
</Block>
</Block>
</DataModel>
</Peach>" ;
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.WriteBytes(new byte[] { 0x02, 0x03, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37 });
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(2, (int)dom.dataModels[0][0].DefaultValue);
Assert.AreEqual(3, (int)dom.dataModels[0][1].DefaultValue);
Dom.Array ArrayX1 = (Dom.Array)dom.dataModels[0][2];
Assert.AreEqual(2, ArrayX1.Count);
Dom.Array ArrayY1 = (Dom.Array)((Dom.Block)ArrayX1[0])[0];
Assert.AreEqual(3, ArrayY1.Count);
Assert.AreEqual("0", (string)((Dom.String)((Dom.Block)ArrayY1[0])[0]).DefaultValue);
Assert.AreEqual("1", (string)((Dom.String)((Dom.Block)ArrayY1[1])[0]).DefaultValue);
Assert.AreEqual("2", (string)((Dom.String)((Dom.Block)ArrayY1[2])[0]).DefaultValue);
Dom.Array ArrayY2 = (Dom.Array)((Dom.Block)ArrayX1[1])[0];
Assert.AreEqual(3, ArrayY2.Count);
Assert.AreEqual("3", (string)((Dom.String)((Dom.Block)ArrayY2[0])[0]).DefaultValue);
Assert.AreEqual("4", (string)((Dom.String)((Dom.Block)ArrayY2[1])[0]).DefaultValue);
Assert.AreEqual("5", (string)((Dom.String)((Dom.Block)ArrayY2[2])[0]).DefaultValue);
}
// PERFORM_MUTATION
//
public void performMutation(DataElement obj, int num)
{
logger.Debug("performMutation(num=" + num + ")");
Dom.Array objAsArray = (Dom.Array)obj;
//if (num == 0)
// return;
if (num < objAsArray.Count)
{
// remove some items
for (int i = objAsArray.Count - 1; i >= num; --i)
{
if (objAsArray[i] == null)
{
break;
}
objAsArray.RemoveAt(i);
}
}
else if (num > objAsArray.Count)
{
try
{
// We are not actually going to make this array thousands of items long. Instead
// we are going to override the count and copy the last element many times simulating a
// very long array.
var elemValue = objAsArray[objAsArray.Count - 1].Value;
objAsArray.overrideCount = num;
var newValue = new BitStream();
newValue.Write(elemValue);
for (int i = objAsArray.Count; i < num; i++)
{
newValue.Write(elemValue);
}
objAsArray[objAsArray.Count - 1].MutatedValue = new Variant(newValue);
objAsArray[objAsArray.Count - 1].mutationFlags = DataElement.MUTATE_DEFAULT | DataElement.MUTATE_OVERRIDE_TYPE_TRANSFORM;
}
catch (Exception ex)
{
logger.Error("Eating exception: " + ex.ToString());
//throw new OutOfMemoryException("ArrayNumericalEdgeCasesMutator -- Out of memory", ex);
}
}
}
public void ChoiceCountRelations()
{
string xml = @"
<Peach>
<DataModel name=""DM"">
<Choice>
<Block name=""C1"">
<Number name=""version"" size=""8"" value=""1"" token=""true""/>
<Number name=""LengthBig"" size=""16"">
<Relation type=""count"" of=""data""/>
</Number>
</Block>
<Block name=""C2"">
<Number name=""version"" size=""8"" value=""2"" token=""true""/>
<Number name=""LengthSmall"" size=""8"">
<Relation type=""count"" of=""data""/>
</Number>
</Block>
</Choice>
<Number size=""8"" minOccurs=""0"" name=""data""/>
<Blob />
</DataModel>
</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
BitStream data = new BitStream();
data.LittleEndian();
data.WriteBytes(new byte[] { 0x02, 0x03, 0x33, 0x44, 0x55 });
data.SeekBits(0, SeekOrigin.Begin);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(3, dom.dataModels[0].Count);
Assert.IsTrue(dom.dataModels[0][0] is Dom.Choice);
Assert.IsTrue(dom.dataModels[0][1] is Dom.Array);
Assert.IsTrue(dom.dataModels[0][2] is Dom.Blob);
Dom.Array array = dom.dataModels[0][1] as Dom.Array;
Assert.AreEqual(3, array.Count);
Assert.AreEqual(0, dom.dataModels[0][2].Value.LengthBytes);
}
// PERFORM_MUTATION
//
private void performMutation(DataElement obj)
{
Dom.Array objAsArray = (Dom.Array)obj;
List <DataElement> items = new List <DataElement>();
for (int i = 0; i < objAsArray.Count; ++i)
{
items.Add(objAsArray[i]);
}
items.Reverse();
objAsArray.Clear();
for (int i = 0; i < items.Count; ++i)
{
objAsArray.Add(items[i]);
}
}
// PERFORM_MUTATION
//
private void performMutation(DataElement obj)
{
Dom.Array objAsArray = (Dom.Array)obj;
List <DataElement> items = new List <DataElement>();
for (int i = 0; i < objAsArray.Count; ++i)
{
items.Add(objAsArray[i]);
}
var shuffledItems = context.Random.Shuffle(items.ToArray());
objAsArray.Clear();
for (int i = 0; i < shuffledItems.Length; ++i)
{
objAsArray.Add(shuffledItems[i]);
}
}
public void ArrayNameTest()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob name=\"stuff\" value=\"Hello World\" minOccurs=\"100\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.Array array = dom.dataModels[0][0] as Dom.Array;
Assert.NotNull(array);
Assert.AreEqual(100, array.Count);
Assert.AreEqual("TheDataModel.stuff", array.fullName);
Assert.AreEqual("TheDataModel.stuff.stuff", array[0].fullName);
Assert.AreEqual("TheDataModel.stuff.stuff_1", array[1].fullName);
Assert.AreEqual(array, array[0].parent);
}
public void ArrayFromRelationTest()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob name=\"Data\" value=\"Hello World\"/>"+
" <Number name=\"Length\" size=\"32\" minOccurs=\"100\">"+
" <Relation type=\"size\" of=\"Data\" />"+
" </Number>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.Array array = dom.dataModels[0][1] as Dom.Array;
Assert.NotNull(array);
Assert.AreEqual(100, array.Count);
Assert.AreEqual(0, array.relations.Count);
Assert.AreEqual(1, array[0].relations.Count);
}
public void CrackArrayEmptyElement()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Block minOccurs=\"10\"/>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
var data = Bits.Fmt("{0}", (byte)0);
DataCracker cracker = new DataCracker();
cracker.CrackData(dom.dataModels[0], data);
Assert.AreEqual(1, dom.dataModels[0].Count);
Dom.Array array = (Dom.Array)dom.dataModels[0][0];
Assert.AreEqual(10, array.Count);
}
public void TestArrayRelationClone()
{
// If an array is cloned wih a new name, and the array element contains a relation,
// the relation's Of or From names need to be updated
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob name=\"Data\" value=\"Hello World\"/>"+
" <Number name=\"Length\" size=\"32\" minOccurs=\"100\">"+
" <Relation type=\"size\" of=\"Data\" />"+
" </Number>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.Array array = dom.dataModels[0][1] as Dom.Array;
Assert.NotNull(array);
Assert.AreEqual("Length", array.name);
Assert.AreEqual(100, array.Count);
Assert.AreEqual("Length", array[0].name);
Assert.AreEqual(0, array.relations.Count);
Assert.AreEqual(1, array[0].relations.Count);
Assert.AreEqual(100, array[0].relations[0].Of.relations.Count);
Dom.Array clone = array.Clone("NewLength") as Dom.Array;
Assert.NotNull(clone);
Assert.AreEqual("NewLength", clone.name);
Assert.AreEqual(100, clone.Count);
Assert.AreEqual("NewLength", clone[0].name);
Assert.AreEqual(0, clone.relations.Count);
Assert.AreEqual(1, clone[0].relations.Count);
Assert.AreEqual("Data", clone[0].relations[0].OfName);
Assert.AreEqual("NewLength", clone[0].relations[0].FromName);
Assert.AreEqual(200, clone[0].relations[0].Of.relations.Count);
Assert.True(clone[0].relations[0].Of.relations.Contains(clone[0].relations[0]));
}
public void ArrayHintsTest()
{
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Peach>\n" +
" <DataModel name=\"TheDataModel\">"+
" <Blob value=\"Hello World\" minOccurs=\"100\">"+
" <Hint name=\"Hello\" value=\"World\"/>"+
" </Blob>"+
" </DataModel>"+
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.Array array = dom.dataModels[0][0] as Dom.Array;
Assert.NotNull(array);
Assert.AreEqual(100, array.Count);
Assert.NotNull(array.Hints);
Assert.AreEqual(1, array.Hints.Count);
Assert.AreEqual("World", array.Hints["Hello"].Value);
}
bool?scanArray(Dom.Array array, ref long pos, List <Mark> tokens, Until until)
{
logger.Debug("scanArray: {0}", array.debugName);
int tokenCount = tokens.Count;
long arrayPos = 0;
var ret = scan(array.origionalElement, ref arrayPos, tokens, null, until);
for (int i = tokenCount; i < tokens.Count; ++i)
{
tokens[i].Optional = array.Count >= array.minOccurs;
tokens[i].Position += pos;
}
if (ret.HasValue && ret.Value)
{
if (until == Until.FirstSized)
{
ret = false;
}
var relations = array.relations.Of <CountRelation>();
if (relations.Any())
{
var rel = relations.Where(HasCracked).FirstOrDefault();
if (rel != null)
{
arrayPos *= rel.GetValue();
pos += arrayPos;
logger.Debug("scanArray: {0} -> Count Relation: {1}, Size: {2}",
array.debugName, rel.GetValue(), arrayPos);
return(ret);
}
else
{
logger.Debug("scanArray: {0} -> Count Relation: ???", array.debugName);
return(null);
}
}
else if (array.minOccurs == 1 && array.maxOccurs == 1)
{
arrayPos *= array.occurs;
pos += arrayPos;
logger.Debug("scanArray: {0} -> Occurs: {1}, Size: {2}",
array.debugName, array.occurs, arrayPos);
return(ret);
}
else
{
// If the count is unknown, treat the array unsized
ret = null;
// If no tokens were found in the array, we are done
if (tokenCount == tokens.Count)
{
logger.Debug("scanArray: {0} -> Count Unknown", array.debugName);
return(ret);
}
}
}
// If we are looking for the first sized element, try cracking our first element
if (until == Until.FirstSized)
{
logger.Debug("scanArray: {0} -> FirstSized", array.debugName);
return(false);
}
if (tokenCount == tokens.Count)
{
logger.Debug("scanArray: {0} -> No Tokens", array.debugName);
//ret.HasValue ? "Deterministic" : "Unsized");
return(false);
}
// If we have tokens, keep scanning thru the dom.
logger.Debug("scanArray: {0} -> Tokens", array.debugName);
return(true);
}
public void Test6()
{
// Test that the random strategy properly cycles through data models on the specified switch count
string temp1 = Path.GetTempFileName();
string temp2 = Path.GetTempFileName();
File.WriteAllBytes(temp1, Encoding.ASCII.GetBytes("Hello\x00World\x00"));
File.WriteAllBytes(temp2, Encoding.ASCII.GetBytes("Foo\x00"));
// Test loading a dataset from a file
string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n" +
"<Peach>" +
" <DataModel name=\"TheDataModel\">" +
" <String name=\"str1\" value=\"Initial\" maxOccurs=\"100\" nullTerminated=\"true\"/>" +
" </DataModel>" +
" <StateModel name=\"TheState\" initialState=\"Initial\">" +
" <State name=\"Initial\">" +
" <Action type=\"output\">" +
" <DataModel ref=\"TheDataModel\"/>" +
" <Data fileName=\"" + temp1 + "\"/>" +
" <Data fileName=\"" + temp2 + "\"/>" +
" </Action>" +
" </State>" +
" </StateModel>" +
" <Test name=\"Default\">" +
" <StateModel ref=\"TheState\"/>" +
" <Publisher class=\"Null\"/>" +
" <Strategy class=\"RandomStrategy\">" +
" <Param name=\"SwitchCount\" value=\"10\"/>" +
" </Strategy>" +
" </Test>" +
"</Peach>";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
dom.tests[0].includedMutators = new List <string>();
dom.tests[0].includedMutators.Add("StringCaseMutator");
RunConfiguration config = new RunConfiguration();
config.rangeStart = 1;
config.rangeStop = 50;
config.range = true;
config.randomSeed = 12345;
Engine e = new Engine(null);
e.startFuzzing(dom, config);
Assert.AreEqual(50, mutations.Count);
// 50 mutations, control on 1, 11, 21, 31, 41
Assert.AreEqual(50 + 5, dataModels.Count);
int lastSize = 0;
// Skip data model 0, its the magical 1st pass w/o mutations
for (int i = 0; i < 55; ++i)
{
Assert.AreEqual(1, dataModels[i].Count);
Dom.Array item = dataModels[i][0] as Dom.Array;
// Its either an array of 1 or an array of 2
Assert.GreaterOrEqual(item.Count, 1);
Assert.LessOrEqual(item.Count, 2);
if (lastSize != item.Count)
{
// Change of data model should only occur at iteration 1, 11, 21, 31, 41
// which is the 0, 11, 22, 33, 44 indices
Assert.AreEqual(i / 10, i % 10);
lastSize = item.Count;
}
}
}
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);
}
}
}
public void SlurpArray()
{
string xml = @"
<Peach>
<DataModel name='TheDataModel'>
<String name='str' value='Hello'/>
<Block name='blk' minOccurs='1'>
<String name='val'/>
</Block>
</DataModel>
<StateModel name='TheState' initialState='State1'>
<State name='State1'>
<Action type='output'>
<DataModel ref='TheDataModel'/>
</Action>
</State>
</StateModel>
<Test name='Default'>
<StateModel ref='TheState'/>
<Publisher class='Console'/>
</Test>
</Peach>
";
PitParser parser = new PitParser();
Dom.Dom dom = parser.asParser(null, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(xml)));
Dom.Array array = dom.tests[0].stateModel.states["State1"].actions[0].dataModel[1] as Dom.Array;
array.ExpandTo(50);
PeachXPathNavigator navi = new PeachXPathNavigator(dom);
var iter = navi.Select("//str");
if (!iter.MoveNext())
{
Assert.Fail();
}
DataElement valueElement = ((PeachXPathNavigator)iter.Current).currentNode as DataElement;
if (valueElement == null)
{
Assert.Fail();
}
if (iter.MoveNext())
{
Assert.Fail();
}
iter = navi.Select("//val");
if (!iter.MoveNext())
{
Assert.Fail();
}
int count = 0;
do
{
var setElement = ((PeachXPathNavigator)iter.Current).currentNode as DataElement;
if (setElement == null)
{
Assert.Fail();
}
setElement.DefaultValue = valueElement.DefaultValue;
++count;
}while (iter.MoveNext());
// When Array.ExpandTo() is used, it duplicates the element and adds that
// same element over and over, so there are really only 2 unique elements in the array...
Assert.AreEqual(2, count);
Assert.AreEqual(50, array.Count);
int hash = 0;
for (int i = 0; i < array.Count; ++i)
{
if (i <= 1)
{
hash = array[i].GetHashCode();
}
Assert.AreEqual(hash, array[i].GetHashCode());
var b = array[i] as Block;
Assert.NotNull(b);
Assert.AreEqual("Hello", (string)b[0].DefaultValue);
}
}
