private MethodSignature overRiddenMethod(List <ClassGenerator> classList, int loc) { List <MethodSignature> superClassMethodSignatures = this.superClass.methodSignatures; MethodSignature methodToOverride = superClassMethodSignatures[rand.Next(superClassMethodSignatures.Count)]; int counter = this.superClass.numberOfMethods; while ((overriddenMethods.Contains(methodToOverride) || methodSignatures.Contains(methodToOverride)) && counter > 0) { methodToOverride = superClassMethodSignatures[rand.Next(superClassMethodSignatures.Count)]; counter--; } if (counter == 0) { Console.WriteLine("overriddenMethod()::returning null due to lack of methods in super class."); return(null); } overriddenMethods.Add(methodToOverride); Type.Primitives returnType = methodToOverride.ReturnType; if (returnType != Type.Primitives.OBJECT) { returnTypeSet.Add(returnType); } return(methodToOverride); }
private static Variable getVariable(List <Variable> variables, Type.Primitives primitive) { List <Variable> typedVariableList = new List <Variable>(); foreach (Variable @var in variables) { if (@var.Name.Equals("recursionCounter")) { continue; } if (@var.Type.Type == primitive) { typedVariableList.Add(@var); } } if (typedVariableList.Count == 0) { return(null); } int index = (new Random()).Next(typedVariableList.Count); return(typedVariableList[index]); }
private void generateMethodSignatures(List <ClassGenerator> classList) { for (int i = 0; i < numberOfMethods; i++) { if (this.superClass != null) { //flip a coin(1 out of 3) to decide for method override int choiceOverride = rand.Next(3); if (choiceOverride == 0) { MethodSignature overridenMethod = overRiddenMethod(classList, locPerMethod); if (overridenMethod != null) { methodSignatures.Add(overridenMethod); continue; } //else fallthrough and generate normal class method } } //Basically creating MethodSignature Method method = Method.generateMethod(this, ProgGenUtil.maxNoOfParameters, classList, this.fileName + "method" + i, locPerMethod, this.maxNestedIfs, this.maxAllowedMethodCalls, false); methodSignatures.Add(method.MethodSignature); Type.Primitives returnType = method.ReturnType; if (returnType != Type.Primitives.OBJECT) { returnTypeSet.Add(returnType); } } }
/// <summary> /// returns a random field of a given type for a generated class. /// </summary> /// <param name="generator"> </param> /// <param name="primitive"> </param> /// <param name="isStatic"> /// @return </param> public static Operand getRandomField(ClassGenerator generator, Type.Primitives primitive, bool isStatic) { Field field; field = getField(generator.Fields, primitive, isStatic); if (field == null) { return(new Literal(primitive)); } generator.UsedFields.add(field); return(field); }
public static Operand getRandomizedVariable(Method method, Type.Primitives primitive) { Variable variable; variable = getVariable(method.ParameterList, primitive); if (variable == null) { return(new Literal(primitive)); } method.UsedParameterList.Add(variable); return(variable); }
private void overrideInterfaceMethods(List <ClassGenerator> classList) { foreach (InterfaceGenerator interfaceGen in interfaceList) { foreach (MethodSignature signature in interfaceGen.MethodSignatures) { Type.Primitives returnType = signature.ReturnType; if (returnType != Type.Primitives.OBJECT) { returnTypeSet.Add(returnType); } } methodSignatures.AddRange(interfaceGen.MethodSignatures); } }
private static Field getField(List <Field> fields, Type.Primitives primitive, bool isStatic) { List <Field> typedFieldList = new List <Field>(); foreach (Field @var in fields) { if (@var.Type.Type == primitive && @var.Static == isStatic) { typedFieldList.Add(@var); } } if (typedFieldList.Count == 0) { return(null); } int index = (new Random()).Next(typedFieldList.Count); return(typedFieldList[index]); }
public static HashSet <Type.Primitives> getPrimitivesOfVariables(Method method) { HashSet <Type.Primitives> primitiveSet = new HashSet <Type.Primitives>(); List <Variable> parameterList = method.ParameterList; foreach (Variable @var in parameterList) { //ignore the recursionCounter if (@var.Name.Equals("recursionCounter")) { continue; } Type.Primitives primitive = @var.Type.getType(); //we don't want expressions based on Object type if (!(primitive == Type.Primitives.OBJECT)) { primitiveSet.Add(primitive); } } return(primitiveSet); }
public static Statement getRandomizedStatement(Method method, List <ClassGenerator> classList) { Statement stmt = new Statement(); Random rand = new Random(); int option = 0; option = rand.Next(100) % 3; switch (option) { case 0: // Assignment statement stmt.stmt = (new AssignmentExpression(method)).ToString(); //FIXME: if there is no local variable available to assign, it will simply use print statement. // following line will add an extra line to the LOC method.Loc = method.Loc + 1; break; case 1: // Print statements: Max. 5 lines in a block stmt.stmt = (new PrintStatement(method)).ToString(); break; case 2: // method calls: restrict it to MAX_ALLOWED_METH_CALL int methCalledCounterValue = method.MethodCallCounter + 1; method.MethodCallCounter = methCalledCounterValue; if (methCalledCounterValue < method.MaxAllowedMethodCalls) { if (ProgGenUtil.coinFlip()) { stmt.stmt += ProgGenUtil.getMethodCall(method, classList); } else { //wire it to variables in scope Operand lhs; Random random = new Random(); HashSet <Type.Primitives> validPrimitivesInScope = ProgGenUtil.getValidPrimitivesInScope(method); //Pick a type object[] primitivesArray = validPrimitivesInScope.ToArray(); if (primitivesArray.Length == 0) { stmt.stmt += ProgGenUtil.getMethodCall(method, classList); break; } Type.Primitives selectedPrimitive = (Type.Primitives)primitivesArray[random.Next(primitivesArray.Length)]; // Introducing any variable lhs = VariableGenerator.getRandomizedVariable(method, selectedPrimitive); string methodCall = ProgGenUtil.getMethodCallForReturnType(method, classList, new Type(selectedPrimitive, ""), lhs); stmt.stmt += methodCall + "\n"; } } else { stmt.stmt = (new PrintStatement(method)).ToString(); } break; default: stmt.stmt = (new IfStmtIfStmt(method, classList)).ToString(); break; } return(stmt); }