public void CountWithMinParserTest()
{
CountWithMin countWithMinOf1 = new CountWithMin(1);
CountWithMin countWithMinOf99999 = new CountWithMin(99999);
TestUtil.TestPropertyParser("1-*", countWithMinOf1);
TestUtil.TestPropertyParser("\t\t 1-* \n\n \t", countWithMinOf1);
TestUtil.TestPropertyParser("99999-*", countWithMinOf99999);
TestUtil.TestPropertyParser("\t\t 99999-* \n\n \t", countWithMinOf99999);
//
// Test that it disallows CountWithMin(0)
//
#if DEBUG
try
{
CountWithMin countWithMin = new CountWithMin(0);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine(String.Format("Caught expected exception {0}", e));
}
#endif
//
// Test some larger Count with min
//
for (UInt32 i = 1; i < 1000000; i += 95416)
{
CountWithMin countWithMin = (CountWithMin)CountProperty.Parse(i.ToString() + "-*");
Assert.AreEqual(i, countWithMin.min);
}
}
public void CountWithMinAndMaxParserTest()
{
CountWithMinAndMax countWithMinAndMaxA = new CountWithMinAndMax(1, 2);
CountWithMinAndMax countWithMinAndMaxB = new CountWithMinAndMax(4, 9938);
TestUtil.TestPropertyParser("1-2", countWithMinAndMaxA);
TestUtil.TestPropertyParser("\t\t 1-2 \n\n \t", countWithMinAndMaxA);
TestUtil.TestPropertyParser("4-9938", countWithMinAndMaxB);
TestUtil.TestPropertyParser("\t\t 4-9938 \n\n \t", countWithMinAndMaxB);
//
// Test that it disallows certain min/max pairs
//
try
{
CountWithMinAndMax countWithMinAndMax = new CountWithMinAndMax(2, 1);
Assert.Fail();
}
catch (ArgumentException e)
{
Console.WriteLine(String.Format("Caught expected exception {0}", e));
}
try
{
CountWithMinAndMax countWithMinAndMax = new CountWithMinAndMax(999, 999);
Assert.Fail();
}
catch (ArgumentException e)
{
Console.WriteLine(String.Format("Caught expected exception {0}", e));
}
//
// Test some larger values
//
for (UInt32 i = 1; i < 1000000; i += 95416)
{
for (UInt32 j = i + 1; j < 1000000; j += 95416)
{
CountWithMinAndMax countWithMinAndMax = (CountWithMinAndMax)CountProperty.Parse(String.Format("{0}-{1}", i, j));
Assert.AreEqual(i, countWithMinAndMax.min);
Assert.AreEqual(j, countWithMinAndMax.max);
}
}
}
public void CountWithMaxParserTest()
{
CountWithMax countWithMaxOf1 = new CountWithMax(1);
CountWithMax countWithMaxOf83729 = new CountWithMax(83729);
TestUtil.TestPropertyParser("0-1", countWithMaxOf1);
TestUtil.TestPropertyParser("\t\t 0-1 \n\n \t", countWithMaxOf1);
TestUtil.TestPropertyParser("0-83729", countWithMaxOf83729);
TestUtil.TestPropertyParser("\t\t 0-83729 \n\n \t", countWithMaxOf83729);
//
// Test that it disallows CountWithMax(0)
//
#if DEBUG
try
{
CountWithMax countWithMax = new CountWithMax(0);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine(String.Format("Caught expected exception {0}", e));
}
#endif
//
// Test some larger Count with max
//
for (UInt32 i = 1; i < 1000000; i += 95416)
{
CountWithMax countWithMax = (CountWithMax)CountProperty.Parse("0-" + i.ToString());
Assert.AreEqual(i, countWithMax.max);
}
}
public void StaticCountParserTest()
{
StaticCount static0Count = new StaticCount(0);
StaticCount static939Count = new StaticCount(939);
StaticCount static65535Count = new StaticCount(65535);
TestUtil.TestPropertyParser("0", static0Count);
TestUtil.TestPropertyParser("\t\t 0 \n\n \t", static0Count);
TestUtil.TestPropertyParser("939", static939Count);
TestUtil.TestPropertyParser("\t\t 939 \n\n \t", static939Count);
TestUtil.TestPropertyParser(" 65535", static65535Count);
TestUtil.TestPropertyParser(" \t\t 65535 \n \n \t", static65535Count);
//
// Test some larger static counts
//
for (UInt32 i = 0; i < 1000000; i += 95416)
{
StaticCount staticCount = (StaticCount)CountProperty.Parse(i.ToString());
Assert.AreEqual(i, staticCount.count);
}
}
public static void ParseAndOverrideBlockProperties(HmdBlockIDProperties blockIDProperties, String props)
{
if (blockIDProperties == null)
{
throw new ArgumentNullException("blockIDProperties");
}
ICountProperty countPropertyOverride = null;
HmdParentReference[] parentOverrideList = null;
Int32 offset = 0, saveOffset;
//
// TODO: To save on memory, maybe I'll add some type of hash lookup so I don't have to instantiate multiple HmdType classes?
//
while (true)
{
while (true)
{
if (offset >= props.Length)
{
if (countPropertyOverride != null)
{
blockIDProperties.OverrideCountProperty(countPropertyOverride);
}
if (parentOverrideList != null)
{
blockIDProperties.SetParentOverrideList(parentOverrideList);
}
return;
}
if (!Char.IsWhiteSpace(props[offset]))
{
break;
}
offset++;
}
if (props[offset] >= '0' && props[offset] <= '9')
{
saveOffset = offset;
// keep going while you see 0-9, '-' or '*'
do
{
offset++;
if (offset >= props.Length)
{
break;
}
} while ((props[offset] >= '0' && props[offset] <= '9') || props[offset] == '-' || props[offset] == '*');
//
// Check that the 'count' property has not been specified Twice
//
if (countPropertyOverride != null)
{
throw new FormatException("You've specified the 'count' property twice!");
}
countPropertyOverride = CountProperty.Parse(props.Substring(saveOffset, offset - saveOffset));
}
else if (props[offset] == '(')
{
if (parentOverrideList != null)
{
throw new FormatException("You've specified the 'parents' property twice!");
}
parentOverrideList = ParseParentList(props, ref offset);
}
else
{
throw new FormatException(String.Format("Could not recognize first character of property '{0}', of the props string \"{1}\"",
props[offset], props));
}
}
}
//
// Maybe change to pass in the string offset and length?
//
public static HmdValueIDProperties ParseValueProperties(String idString, String props, HmdBlockIDProperties definitionParent, HmdProperties hmdProperties)
{
if (idString == null)
{
throw new ArgumentNullException("idString");
}
Boolean defaultCountPropertyOverriden = false;
Boolean defaultHmdTypeOverriden = false;
ICountProperty countProperty = hmdProperties.defaultCountProperty;
HmdType hmdType = hmdProperties.defaultHmdType;
HmdEnumReference enumReference = null;
HmdParentReference[] parentOverrideList = null;
Int32 offset = 0, saveOffset;
//
// TODO: To save on memory, maybe I'll add some type of hash lookup so I don't have to instantiate multiple HmdType classes?
//
while (true)
{
while (true)
{
if (offset >= props.Length)
{
return(new HmdValueIDProperties(idString, countProperty, hmdType, enumReference,
definitionParent, parentOverrideList));
}
if (!Char.IsWhiteSpace(props[offset]))
{
break;
}
offset++;
}
if (props[offset] >= '0' && props[offset] <= '9')
{
saveOffset = offset;
// keep going while you see 0-9, '-' or '*'
do
{
offset++;
if (offset >= props.Length)
{
break;
}
} while ((props[offset] >= '0' && props[offset] <= '9') || props[offset] == '-' || props[offset] == '*');
//
// Check that the 'count' property has not been specified Twice
//
if (defaultCountPropertyOverriden)
{
throw new FormatException("You've specified the 'count' property twice!");
}
defaultCountPropertyOverriden = true;
countProperty = CountProperty.Parse(props.Substring(saveOffset, offset - saveOffset));
}
else if (props[offset] == 's')
{
if (offset + 6 > props.Length) // 6 = "string".Length
{
throw new FormatException(String.Format("Found character '{0}', expected to become \"{1}\", but there are some characters missing",
HmdTypeClass.String[0], HmdTypeClass.String));
}
if (props[offset + 1] != 't' ||
props[offset + 2] != 'r' ||
props[offset + 3] != 'i' ||
props[offset + 4] != 'n' ||
props[offset + 5] != 'g')
{
throw new FormatException(String.Format("Expected 'string', but got '{0}'", props.Substring(offset, 6)));
}
offset += 6;
//
// Check that the 'type' property has not been specified Twice
//
if (defaultHmdTypeOverriden)
{
throw new FormatException("You've specified the 'type' property twice!");
}
defaultHmdTypeOverriden = true;
hmdType = HmdType.String;
}
else if (props[offset] == HmdTypeClass.Boolean[0])
{
if (offset + HmdTypeClass.Boolean.Length > props.Length)
{
throw new FormatException(
String.Format("Found character '{0}', expected to become \"{1}\", but there are some characters missing",
HmdTypeClass.Boolean[0], HmdTypeClass.Boolean));
}
offset++;
for (int i = 1; i < HmdTypeClass.Boolean.Length; i++)
{
if (props[offset] != HmdTypeClass.Boolean[i])
{
throw new FormatException(String.Format("Expected \"{0}\", but got \"{1}\"", HmdTypeClass.Boolean, props.Substring(offset - i, HmdTypeClass.Boolean.Length)));
}
offset++;
}
//
// Check that the 'type' property has not been specified Twice
//
if (defaultHmdTypeOverriden)
{
throw new FormatException("You've specified the 'type' property twice!");
}
defaultHmdTypeOverriden = true;
hmdType = HmdType.Boolean;
}
else if (props[offset] == 'i' || props[offset] == 'u')
{
Byte byteSize;
Boolean isUnsigned = false;
if (props[offset] == 'u')
{
isUnsigned = true;
offset++;
if (props[offset] != 'i')
{
throw new FormatException(
String.Format("Found character 'u', expected to become \"uint\", but the next character was '{0}'", props[offset]));
}
}
if (offset + 3 > props.Length)
{
throw new FormatException(
String.Format("Found character '{0}', expected to become \"{1}\", but there are some characters missing",
isUnsigned ? 'u' : 'i', isUnsigned ? "uint" : "int"));
}
if (props[offset + 1] != 'n' || props[offset + 2] != 't')
{
throw new FormatException(String.Format("Expected \"{0}\", but got \"{1}\"",
isUnsigned ? "uint" : "int", isUnsigned ? props.Substring(offset - 1, 4) : props.Substring(offset, 3)));
}
offset += 3;
if (offset < props.Length && props[offset] >= '0' && props[offset] <= '9')
{
saveOffset = offset;
do
{
offset++;
} while (offset < props.Length && props[offset] >= '0' && props[offset] <= '9');
byteSize = Byte.Parse(props.Substring(saveOffset, offset - saveOffset));
}
else
{
byteSize = 0;
}
//
// Check that the 'type' property has not been specified Twice
//
if (defaultHmdTypeOverriden)
{
throw new FormatException("You've specified the 'type' property twice!");
}
defaultHmdTypeOverriden = true;
hmdType = HmdTypeClass.GetIntegerType(isUnsigned, byteSize);
}
else if (props[offset] == 'e')
{
offset++;
if (offset >= props.Length)
{
throw new FormatException("Found character 'e', expected to become \"enum\" or \"empty\" but the string abrubtly ended");
}
if (props[offset] == HmdTypeClass.Empty[1])
{
if (offset + HmdTypeClass.Empty.Length - 1 > props.Length)
{
throw new FormatException("Found \"em\", expected to become \"empty\", but there are some characters missing");
}
offset++;
for (int i = 2; i < HmdTypeClass.Empty.Length; i++)
{
if (props[offset] != HmdTypeClass.Empty[i])
{
throw new FormatException(String.Format("Expected \"{0}\", but got \"{1}\"", HmdTypeClass.Empty, props.Substring(offset - i, HmdTypeClass.Empty.Length)));
}
offset++;
}
//
// Check that the 'type' property has not been specified Twice
//
if (defaultHmdTypeOverriden)
{
throw new FormatException("You've specified the 'type' property twice!");
}
defaultHmdTypeOverriden = true;
hmdType = HmdType.Empty;
}
else if (props[offset] == HmdTypeClass.Enumeration[1])
{
if (offset + HmdTypeClass.Enumeration.Length + 1 > props.Length)
{
throw new FormatException(
String.Format("Found \"en\", expected to become \"{0}\", but there are some characters missing",
HmdTypeClass.Enumeration));
}
offset++;
for (int i = 2; i < HmdTypeClass.Enumeration.Length; i++)
{
if (props[offset] != HmdTypeClass.Enumeration[i])
{
throw new FormatException(String.Format("Expected \"{0}\", but got \"{1}\"", HmdTypeClass.Enumeration, props.Substring(offset - i, HmdTypeClass.Enumeration.Length)));
}
offset++;
}
// skip whitespace
while (true)
{
if (offset >= props.Length)
{
throw new FormatException("Expected '(' or 'a-zA-Z', but got EOF");
}
if (!Char.IsWhiteSpace(props[offset]))
{
break;
}
offset++;
}
if (props[offset] == '(')
{
saveOffset = offset + 1;
// skip to the next whitespace or ';'
while (true)
{
offset++;
if (offset >= props.Length)
{
throw new FormatException("Expected ')' but reached end of string");
}
if (props[offset] == ')')
{
break;
}
}
String enumReferenceName = (definitionParent == null || definitionParent.definitionContext == null) ?
idString.ToLower() : HmdIDProperties.CombineIDContext(definitionParent.idWithContext, idString.ToLower());
HmdEnum newInlineEnum = new HmdEnum(enumReferenceName, props.Substring(saveOffset, offset - saveOffset));
enumReference = newInlineEnum;
if (hmdProperties != null)
{
hmdProperties.AddEnum(newInlineEnum);
}
offset++;
if (defaultHmdTypeOverriden)
{
throw new FormatException("You've specified the 'type' property twice!");
}
defaultHmdTypeOverriden = true;
hmdType = HmdType.Enumeration;
}
else if ((props[offset] >= 'a' && props[offset] <= 'z') || (props[offset] >= 'A' && props[offset] <= 'Z'))
{
saveOffset = offset;
// skip to the next whitespace or ';'
while (true)
{
offset++;
if (offset >= props.Length)
{
break;
}
if (Char.IsWhiteSpace(props[offset]))
{
break;
}
}
if (offset - saveOffset <= 0)
{
throw new FormatException("Unable to parse enum type, the \"enum\" keyword must be either \"enum <type>\" (with only one space before <type>) or \"enum(<value> <value> ...)\"");
}
enumReference = new HmdEnumReferenceByString(props.Substring(saveOffset, offset - saveOffset));
if (defaultHmdTypeOverriden)
{
throw new FormatException("You've specified the 'type' property twice!");
}
defaultHmdTypeOverriden = true;
hmdType = HmdType.Enumeration;
}
else
{
throw new FormatException(String.Format("Expected '(' or 'a-zA-Z' after \"enum\", but got '{0}'", props[offset]));
}
}
else
{
throw new FormatException(String.Format(
"Found character 'e', expected to become \"enum\" or \"empty\" but the second character is '{0}'", props[offset]));
}
}
else if (props[offset] == '(')
{
if (parentOverrideList != null)
{
throw new FormatException("You've specified the 'parents' property twice!");
}
parentOverrideList = ParseParentList(props, ref offset);
}
else
{
throw new FormatException(
String.Format("Could not recognize first character of property '{0}', of the props string \"{1}\"", props[offset], props));
}
}
}