public void AddEnumConstantsToPlanDB(Collection <Type> types)
{
foreach (Type t in types)
{
if (t.IsEnum)
{
Array array = Enum.GetValues(t);
for (int i = 0; i < array.Length; i++)
{
AddPlan(Plan.Constant(t, array.GetValue(i)));
}
}
}
}
/// <summary>
/// 0 for primitive types, null for reference types.
/// for enum types/value types, the first member is returned
///
/// The returned plan is valid if success is true
/// </summary>
public static Plan DefaultPlan(Type t, out bool success)
{
success = true;
if (t.Equals(typeof(void)))
{
return(Plan.DummyVoidPlan);
}
if (t.IsEnum)
{
Array array = Enum.GetValues(t);
return(Plan.Constant(t, array.GetValue(0) as ValueType));
}
//special care for chars as the default value is ^@ unreadable in the output
if (t.Name.Equals("Char"))
{
return(Plan.Constant(t, '0'));
}
if (t.IsValueType)
{
try
{
Array array = Array.CreateInstance(t, 1);
return(Plan.Constant(t, array.GetValue(0) as ValueType));
}
catch (Exception)
{
success = false;
//the plan does not even make sense
return(Plan.DummyVoidPlan);
}
}
else if (t.IsPointer)
{
// Cannot handle pointers.
success = false;
return(Plan.DummyVoidPlan);
}
else
{
return(Plan.Constant(t, null));
}
}
// Add some non-zero constants to the mix.
public void AddConstantsToTDB(RandoopConfiguration config)
{
foreach (SimpleTypeValues vs in config.simpleTypeValues)
{
Type type = Type.GetType(vs.simpleType);
if (type == null)
{
throw new Common.RandoopBareExceptions.InternalError("invalid simple type in XML config file.");
}
foreach (FileName fn in vs.fileNames)
{
string fileName = fn.fileName;
if (!File.Exists(fileName))
{
throw new Common.RandoopBareExceptions.InvalidUserParamsException("Configuration file does not exist: " + fileName);
}
if (type.Equals(typeof(sbyte)))
{
SByteReader r = new SByteReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(sbyte), o));
}
}
else if (type.Equals(typeof(byte)))
{
ByteReader r = new ByteReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(byte), o));
}
}
else if (type.Equals(typeof(short)))
{
ShortReader r = new ShortReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(short), o));
}
}
else if (type.Equals(typeof(ushort)))
{
UshortReader r = new UshortReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(ushort), o));
}
}
else if (type.Equals(typeof(int)))
{
IntReader r = new IntReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(int), o));
}
}
else if (type.Equals(typeof(uint)))
{
UintReader r = new UintReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(uint), o));
}
}
else if (type.Equals(typeof(long)))
{
LongReader r = new LongReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(long), o));
}
}
else if (type.Equals(typeof(ulong)))
{
UlongReader r = new UlongReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(ulong), o));
}
}
else if (type.Equals(typeof(char)))
{
CharReader r = new CharReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(char), o));
}
}
else if (type.Equals(typeof(float)))
{
FloatReader r = new FloatReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(float), o));
}
}
else if (type.Equals(typeof(double)))
{
DoubleReader r = new DoubleReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(double), o));
}
}
else if (type.Equals(typeof(bool)))
{
BoolReader r = new BoolReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(bool), o));
}
}
else if (type.Equals(typeof(decimal)))
{
DecimalReader r = new DecimalReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(decimal), o));
}
}
else
{
if (!type.Equals(typeof(string)))
{
throw new Common.RandoopBareExceptions.InternalError("invalid simple type in XML config file.");
}
Common.StringReader r = new Common.StringReader();
foreach (object o in r.Read(fileName))
{
this.AddPlan(Plan.Constant(typeof(string), o));
}
}
}
}
}
// resultTuple can be null.
private bool AddplanInternal(Plan p, ResultTuple resultTuple)
{
totalAttemptedAdditions++;
bool addSuccessful = false;
if (planSet.ContainsKey(p))
{
totalFailedAdditions++;
return(false);
}
else
{
planSet[p] = true;
NumPlans++;
Dictionary <Type, bool> processedTypes = new Dictionary <Type, bool>();
for (int i = 0; i < p.transformer.TupleTypes.Length; i++)
{
if (!p.IsActiveTupleElement(i))
{
continue;
}
Type t = p.transformer.TupleTypes[i];
Collection <Plan> l = null;
if (plansByType.ContainsKey(t))
{
l = plansByType[t];
}
else
{
l = new Collection <Plan>();
// Always add 0 to the list of plans for a type.
bool success;
Plan pl = DefaultPlan(t, out success);
if (success)
{
l.Add(pl);
typeMap.AddTypeWithPlans(t);
}
plansByType[t] = l;
}
//we don't allow chars because the it can create unreadable chars
if (/*t.IsValueType && */ t.IsPrimitive && !t.ToString().StartsWith("System.Char"))
{
if (p.transformer is PrimitiveValueTransformer)
{
l.Add(p);
typeMap.AddTypeWithPlans(t);
}
else
{
if (resultTuple != null)
{
object pValue = resultTuple.tuple[i];
Util.Assert(pValue != null && pValue.GetType().Equals(t));
bool alreadyInDB = false;
foreach (Plan existingPlan in l)
{
Util.Assert(existingPlan.transformer is PrimitiveValueTransformer);
object existingPlanValue = (existingPlan.transformer as PrimitiveValueTransformer).fvalue;
Util.Assert(existingPlanValue != null &&
existingPlanValue.GetType().Equals(pValue.GetType()));
if (pValue.Equals(existingPlanValue))
{
alreadyInDB = true;
}
}
if (!alreadyInDB)
{
Plan constantPlan = Plan.Constant(t, pValue);
l.Add(constantPlan);
typeMap.AddTypeWithPlans(t);
}
}
}
}
else
{
if (processedTypes.ContainsKey(t))
{
continue;
}
processedTypes[t] = true;
bool success;
Plan pl = DefaultPlan(t, out success);
// Util.Assert(l.Contains(p) && success ? p.Equals(pl) : true);
typeMap.AddTypeWithPlans(t);
l.Add(p);
}
}
addSuccessful = true;
}
return(addSuccessful);
}