public void TestAddUnknownArguments() { MethodDeclarationNode mdn = new MethodDeclarationNode("MyMethod"); Node[] args = new Node[] { new TypeNode("int", true), new VariableDeclarationNode("bar") }; mdn.AddUnknownArguments(args); Assert.IsNotNull(mdn.UnknownArguments); Assert.AreEqual(args.Length, mdn.UnknownArguments.Count); for (int i = 0; i < args.Length; i++) { Assert.AreEqual(args[i], mdn.UnknownArguments[i]); } List <Node> args2 = new List <Node>() { new VariableDeclarationNode("xyzzy"), new VariableDeclarationNode("myParam") }; mdn.AddUnknownArguments(args2); Assert.AreEqual(args.Length + args2.Count, mdn.UnknownArguments.Count); for (int i = 0; i < mdn.UnknownArguments.Count; i++) { if (i < args.Length) { Assert.AreEqual(args[i], mdn.UnknownArguments[i]); } else { Assert.AreEqual(args2[i - args.Length], mdn.UnknownArguments[i]); } } }
public void TestCreateEquivalenceFromUnknownArguments_NullNode() { var arg1 = new VariableDeclarationNode("arg1"); var mdn = new MethodDeclarationNode("MyMethod"); mdn.AddUnknownArguments(new VariableDeclarationNode[] { arg1 }); EquivalenceNode equiv = mdn.CreateEquivalenceFromUnknownArguments(null, new bool[] { true }); }
public void TestCreateEquivalenceFromUnknownArguments_MissizedArray() { var arg1 = new VariableDeclarationNode("arg1"); var mdn = new MethodDeclarationNode("MyMethod"); mdn.AddUnknownArguments(new VariableDeclarationNode[] { arg1 }); EquivalenceNode equiv = mdn.CreateEquivalenceFromUnknownArguments(new PhraseNode(), new bool[] { true, false }); }
public void TestClearUnknownArguments_ExistingArgs() { MethodDeclarationNode mdn = new MethodDeclarationNode("MyMethod"); Node[] args = new Node[] { new TypeNode("int", true), new VariableDeclarationNode("bar") }; mdn.AddUnknownArguments(args); Assert.AreEqual(2, mdn.UnknownArguments.Count); mdn.ClearUnknownArguments(); Assert.AreEqual(0, mdn.UnknownArguments.Count); }
/// <summary> /// Sets the UnknownArguments list to its default state. This includes all the formal parameters, the declaring class, and the return type (if not primitive). /// </summary> /// <param name="mdn">The MethodDeclarationNode to set UnknownArguments on.</param> protected void SetDefaultUnknownArguments(MethodDeclarationNode mdn) { mdn.ClearUnknownArguments(); mdn.AddUnknownArguments(mdn.FormalParameters); if (mdn.DeclaringClass != null) { mdn.AddUnknownArgument(mdn.DeclaringClass); } if (mdn.ReturnType != null && !mdn.ReturnType.IsPrimitive) { mdn.AddUnknownArgument(mdn.ReturnType); } }
/// <summary> /// Constructs the Software Word Use Model for the given node. /// This method assumes that the node has already been tested to satisfy this Rule, using the InClass method. /// </summary> /// <param name="node">The node to construct SWUM for.</param> public override void ConstructSwum(ProgramElementNode node) { if (node is MethodDeclarationNode) { MethodDeclarationNode mdn = (MethodDeclarationNode)node; mdn.Parse(this.Splitter); this.PosTagger.TagNounPhrase(mdn.ParsedName); mdn.AssignStructuralInformation(this.Splitter, this.PosTagger); mdn.Theme = mdn.ParsedName; mdn.AddUnknownArguments(mdn.FormalParameters); //TODO: from Emily, how to fill in Action? mdn.IsDestructor = true; mdn.SwumRuleUsed = this; } else { //TODO: return error? } }
public void TestAddUnknownArguments() { MethodDeclarationNode mdn = new MethodDeclarationNode("MyMethod"); Node[] args = new Node[] { new TypeNode("int", true), new VariableDeclarationNode("bar") }; mdn.AddUnknownArguments(args); Assert.IsNotNull(mdn.UnknownArguments); Assert.AreEqual(args.Length, mdn.UnknownArguments.Count); for(int i = 0; i < args.Length; i++) { Assert.AreEqual(args[i], mdn.UnknownArguments[i]); } List<Node> args2 = new List<Node>() { new VariableDeclarationNode("xyzzy"), new VariableDeclarationNode("myParam") }; mdn.AddUnknownArguments(args2); Assert.AreEqual(args.Length + args2.Count, mdn.UnknownArguments.Count); for(int i = 0; i < mdn.UnknownArguments.Count; i++) { if(i < args.Length) { Assert.AreEqual(args[i], mdn.UnknownArguments[i]); } else { Assert.AreEqual(args2[i - args.Length], mdn.UnknownArguments[i]); } } }
public void TestCreateEquivalenceFromUnknownArguments() { var arg1 = new VariableDeclarationNode("arg1"); var arg2 = new VariableDeclarationNode("arg2"); var arg3 = new VariableDeclarationNode("arg3"); var arg4 = new VariableDeclarationNode("arg4"); var mdn = new MethodDeclarationNode("MyMethod"); mdn.AddUnknownArguments(new VariableDeclarationNode[] { arg1, arg2, arg3, arg4 }); Assert.AreEqual(4, mdn.UnknownArguments.Count); var themeNode = new PhraseNode(new string[] { "Relevent", "Args" }); EquivalenceNode equiv = mdn.CreateEquivalenceFromUnknownArguments(themeNode, new bool[] { true, false, true, false }); Assert.AreEqual(3, equiv.EquivalentNodes.Count); Assert.IsTrue(equiv.EquivalentNodes.Contains(themeNode)); Assert.IsTrue(equiv.EquivalentNodes.Contains(arg1)); Assert.IsTrue(equiv.EquivalentNodes.Contains(arg3)); Assert.AreEqual(2, mdn.UnknownArguments.Count); Assert.IsTrue(mdn.UnknownArguments.Contains(arg2)); Assert.IsTrue(mdn.UnknownArguments.Contains(arg4)); }
/// <summary> /// Sets the Theme, SecondaryArguments and UnknownArguments properties of the given MethodDeclarationNode. /// </summary> /// <param name="node">The node to set the properties for.</param> private void SetPrepositionThemeAndArguments(MethodDeclarationNode node) { List <VariableDeclarationNode> unusedArgs = new List <VariableDeclarationNode>(); //populate UnknownArgs if (node.ParsedName.Size() > 0 && BooleanArgumentVerbs.Contains(node.ParsedName[0].Text)) { node.AddUnknownArguments(node.FormalParameters); } else { //only add non-boolean arguments foreach (VariableDeclarationNode arg in node.FormalParameters) { if (arg.Type.Name.ToLower().Contains("bool")) { unusedArgs.Add(arg); } else { node.AddUnknownArgument(arg); } } } int prepIndex = FindFirstPreposition(node.ParsedName, 0); PhraseNode nameTheme = GetNounPhrase(node.ParsedName); bool checkDO = false; //check Direct Object in name for overlap bool checkIO = false; //check Indirect Object in name for overlap //Assign args if (prepIndex > -1) { //There's a preposition in the name WordNode prep = node.ParsedName[prepIndex]; PhraseNode indirectObject = GetNounPhrase(node.ParsedName, prepIndex + 1); //set IO or P->NM if (!indirectObject.IsEmpty()) //IO in name { node.AddSecondaryArgument(indirectObject, prep); checkIO = true; } else if (node.UnknownArguments != null && node.UnknownArguments.Count() > 0) //or IO = f { node.AddSecondaryArgument(node.UnknownArguments[0], prep); } else { //The preposition doesn't seem to have an object, so change it to a NounModifier prep.Tag = PartOfSpeechTag.NounModifier; nameTheme = GetNounPhrase(node.ParsedName); //reset name theme after changing prep POS tag } //set Theme if (!nameTheme.IsEmpty()) { //theme is in the name nameTheme.SetLocation(Location.Name); node.Theme = nameTheme; checkDO = true; } else //use class as theme { node.Theme = node.DeclaringClass; } } else { //no prep in name, so set Theme only if (!nameTheme.IsEmpty()) { //theme is in the name nameTheme.SetLocation(Location.Name); node.Theme = nameTheme; checkDO = true; } else { //theme is first UnknownArg, or class name //also, potentially leaves class on list of unknown args, which is intentional if (node.DeclaringClass != null) { node.AddUnknownArgument(node.DeclaringClass); } if (node.UnknownArguments != null && node.UnknownArguments.Count > 0) { node.Theme = node.UnknownArguments[0]; node.UnknownArguments.RemoveAt(0); } } } //find equivalences if ((checkDO || checkIO) && node.UnknownArguments != null && node.UnknownArguments.Count > 0) { CheckOverlap(node, checkDO, checkIO); } //do cleanup node.AddUnknownArguments(unusedArgs); if (node.ReturnType != null && node.ReturnType.Name.ToLower() != "void") { //TODO: should this be done for primitive return types? SetDefaultUnknownArguments() excludes them node.AddUnknownArgument(node.ReturnType); } // Note: adding class as unknown arg indep of checkIO // if checkIO = true, and not checkDO, then DO will be class // if check IO = true and checkDO, then this will be executed // if no prep & DO not in name, class will already be on unused args // list for finding theme. if (checkDO && node.DeclaringClass != null) { node.AddUnknownArgument(node.DeclaringClass); } }