while (iterator.hasNext()) {

            ASTEntry entry = iterator.next();

            Assert ass = (Assert) entry.node;

            if (ass.test instanceof Call) {

                String rep = NodeUtils.getFullRepresentationString(call.func);

                if (rep == null) {

                    continue;

                }

                Integer classIndex = ISINSTANCE_POSSIBILITIES.get(FullRepIterable.getLastPart(rep).toLowerCase());

        while (ast2 instanceof Attribute || ast2 instanceof Call) {

            if (ast2 instanceof Attribute) {

                ast2 = ((Attribute) ast2).value;

            } else {

                if (c.func != null) {

                    ast2 = c.func;

                } else {

                    break;

                }

        }

        if (node instanceof Attribute) {

            exprType value = ((Attribute) node).value;

            if (value instanceof Call) {

                node = c.func;

            }

        }

        beginLine = node.beginLine;

        beginCol = node.beginColumn;

    }

    private void processFoundNameTok(SimpleNode root, List<ASTEntry> ret, NameTok name) {

        if (name.ctx == NameTok.Attrib) {

            processCall(ret, call);

        }

    }

    }

    private void processFoundName(SimpleNode root, List<ASTEntry> ret, Name name) {

        if (name.ctx == Name.Load) {

            processCall(ret, call);

        }

    }

                "Method1(param1=10, param2=20)\n" +

                "";

        Module root = (Module) parseLegalDocStr(s);

        Expr expr = (Expr) root.body[1];

        Name name = (Name) call.func;

        FindCallVisitor visitor = new FindCallVisitor(name);

        visitor.traverse(root);

        assertSame(call, visitor.getCall());

        assertSame(call, FindCallVisitor.findCall(name, root));

        Module root = (Module) parseLegalDocStr(s);

        ClassDef classDef = (ClassDef) root.body[0];

        FunctionDef funcDef = (FunctionDef) classDef.body[0];

        Expr expr = (Expr) funcDef.body[1];

        Name name = (Name) call.func;

        FindCallVisitor visitor = new FindCallVisitor(name);

        visitor.traverse(root);

        assertSame(call, visitor.getCall());

        assertSame(call, FindCallVisitor.findCall(name, root));

    public Call createCall(String call, List<exprType> params, keywordType[] keywords, exprType starargs,

            exprType kwargs) {

        exprType[] array = params != null ? params.toArray(new Name[params.size()]) : new exprType[0];

        if (call.indexOf(".") != -1) {

        }

    }

                Integer pop = removePositions.pop();

                params.remove((int) pop);

            }

        }

        if (isClassMethod && params.size() > 0) {

            //We need to use the super() construct

            //Something as:

            //Expr[value=

            //    Call[func=

            //        Attribute[value=

            //            Call[func=Name[id=super, ctx=Load, reserved=false], args=[Name[id=Current, ctx=Load, reserved=false], Name[id=cls, ctx=Load, reserved=false]], keywords=[], starargs=null, kwargs=null],

            //        attr=NameTok[id=test, ctx=Attrib], ctx=Load],

            //    args=[], keywords=[], starargs=null, kwargs=null]

            //]

            exprType firstParam = params.remove(0);

            Attribute attr = new Attribute(innerCall, new NameTok(NodeUtils.getRepresentationString(functionDef),

                    NameTok.Attrib), Attribute.Load);

                    .size()]), starargs, kwargs);

        } else {

            call = createCall(parentClassName + "." + NodeUtils.getRepresentationString(functionDef), params,

                    keywords.toArray(new keywordType[keywords.size()]), starargs, kwargs);