public void Classe_complexe_retourne_prediction_si_a_constructeur()
{
classId = registry.AddCustomClass("custom");
registry.GetClassById(classId).AddConstructor();
var visitor = new AutocompleteVisitor(ref registry, new List<OperandeVariable>());
Assert.AreEqual(2, visitor.GetPredictions().Count);
}
internal MethodClass(string name, IClassIdentifier parent, IClassIdentifier output = null, List<IArgument> inputs = null, bool isStatic = false)
: base(name, parent, output, inputs)
{
Name = name;
Output = output;
this.isStatic = isStatic;
}
public void Init()
{
registry = RegistrySingleton.Instance;
registry.ClearClasses();
classId = registry.AddPrimitiveClass("numeric", DATA_TYPE.NUMERIC);
cla = registry.GetClassById(classId);
}
public void Init()
{
registry = RegistrySingleton.Instance;
registry.ClearClasses();
classId = registry.AddPrimitiveClass("numeric", DATA_TYPE.NUMERIC);
cla = registry.GetClassById(classId);
cla.AddMethod("staticMethod", classId, new List<IArgument>() { registry.CreateArgument(classId) }, true);
cla.AddMethod("method", classId, new List<IArgument>() { registry.CreateArgument(classId) });
}
public bool CanReturn(IClassIdentifier classToCheck, IClassIdentifier classToFind, bool staticMethod = false)
{
if (staticMethod)
{
return GetClassById(classToCheck).StaticMethods.Where(m => m.Output == classToFind).Any();
}
else
{
return GetClassById(classToCheck).Methods.Where(m => m.Output == classToFind).Any();
}
}
public void Init()
{
registry = RegistrySingleton.Instance;
registry.ClearClasses();
intId = registry.AddPrimitiveClass("numeric", DATA_TYPE.NUMERIC);
intClass = registry.GetClassById(intId);
intClass.AddMethod("method", intId, new List<IArgument>() { registry.CreateArgument(intId), registry.CreateArgument(intId) });
intVar = new OperandeVariable(intId, "num");
}
protected AbstractMethod(string name, IClassIdentifier parent, IClassIdentifier output = null, List<IArgument> inputs = null)
{
Name = name;
Parent = parent;
Output = output;
if (inputs == null)
{
Inputs = new List<IArgument>();
}
else
{
Inputs = inputs;
}
}
public TestInit()
{
registry = RegistrySingleton.Instance;
registry.ClearClasses();
boolId = registry.AddPrimitiveClass("boolean", DATA_TYPE.BOOLEAN);
strId = registry.AddPrimitiveClass("string", DATA_TYPE.STRING);
dbId = registry.AddCustomClass("database");
List<IArgument> inputs;
registry
.GetClassById(strId)
.AddMethod("method", strId, new List<IArgument>() { registry.CreateArgument(strId) });
registry
.GetClassById(strId)
.AddMethod("staticMethod", strId, new List<IArgument>() { registry.CreateArgument(strId) }, true);
registry
.GetClassById(dbId)
.AddConstructor();
registry
.GetClassById(dbId)
.AddConstructor(new List<IArgument>() { registry.CreateArgument(strId) });
inputs = new List<IArgument>() { registry.CreateArgument(strId), registry.CreateArgument(strId) };
registry
.GetClassById(dbId)
.AddMethod("method", strId, inputs);
inputs = new List<IArgument>() { registry.CreateArgument(strId), registry.CreateArgument(strId) };
registry
.GetClassById(dbId)
.AddMethod("staticMethod", strId, inputs, true);
builder = ExpressionBuilder.GetBuilder(ref registry);
}
internal MethodConstructor(string name, IClassIdentifier output, List<IArgument> inputs)
: base(name, output, output, inputs)
{
}
internal Argument(IClassIdentifier customClass)
{
ClassIdentifier = customClass;
}
public void Init()
{
registry = RegistrySingleton.Instance;
registry.ClearClasses();
intClass = registry.AddPrimitiveClass("numeric", DATA_TYPE.NUMERIC);
}
public bool AddMethod(string name, IClassIdentifier output = null, List<IArgument> list = null, bool isStatic = false)
{
var method = new MethodClass(name, Identifier, output, list, isStatic);
foreach (AbstractMethod tmp in methods.Where(el => !el.IsConstructor))
{
if (name == tmp.Name && tmp.HasConflictualSignature(method))
{
return false;
}
}
methods.Add(method);
return true;
}
public void Doit_retourner_un_constructeur_si_primitive()
{
classId = registry.AddPrimitiveClass("numeric", DATA_TYPE.NUMERIC);
cla = registry.GetClassById(classId);
Assert.AreEqual(1, cla.Constructors.Count);
}
public void Doit_retourner_toute_les_methodes()
{
classId = registry.AddCustomClass("complexe");
cla = registry.GetClassById(classId);
Assert.AreEqual(0, cla.Methods.Count);
}
public void Doit_pas_avoir_de_constructeur_si_complexe()
{
classId = registry.AddCustomClass("complexe");
cla = registry.GetClassById(classId);
Assert.AreEqual(0, cla.Constructors.Count);
}
public int CompareTo(IClassIdentifier other)
{
throw new NotImplementedException();
}
public IClass GetClassById(IClassIdentifier id)
{
return Classes.Where(el=>el.Identifier == id).FirstOrDefault();
}
public IArgument CreateArgument(IClassIdentifier id)
{
return new Argument(id);
}
public void Init()
{
registry = RegistrySingleton.Instance;
registry.ClearClasses();
classId = registry.AddPrimitiveClass("numeric", DATA_TYPE.NUMERIC);
cla = registry.GetClassById(classId);
newVar = new OperandeVariable(classId, "myVar", true);
}
