/*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

  *

  * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

  * Other names may be trademarks of their respective owners.

  *

  * The contents of this file are subject to the terms of either the GNU

  * General Public License Version 2 only ("GPL") or the Common

  * Development and Distribution License("CDDL") (collectively, the

  * "License"). You may not use this file except in compliance with the

  * License. You can obtain a copy of the License at

  * http://www.netbeans.org/cddl-gplv2.html

  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

  * specific language governing permissions and limitations under the

  * License.  When distributing the software, include this License Header

  * Notice in each file and include the License file at

  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the GPL Version 2 section of the License file that

  * accompanied this code. If applicable, add the following below the

  * License Header, with the fields enclosed by brackets [] replaced by

  * your own identifying information:

  * "Portions Copyrighted [year] [name of copyright owner]"

  *

  * Contributor(s):

  *

  * The Original Software is NetBeans. The Initial Developer of the Original

  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2009 Sun

  * Microsystems, Inc. All Rights Reserved.

  *

  * If you wish your version of this file to be governed by only the CDDL

  * or only the GPL Version 2, indicate your decision by adding

  * "[Contributor] elects to include this software in this distribution

  * under the [CDDL or GPL Version 2] license." If you do not indicate a

  * single choice of license, a recipient has the option to distribute

  * your version of this file under either the CDDL, the GPL Version 2 or

  * to extend the choice of license to its licensees as provided above.

  * However, if you add GPL Version 2 code and therefore, elected the GPL

  * Version 2 license, then the option applies only if the new code is

  * made subject to such option by the copyright holder.

  */

 package org.netbeans.modules.ruby;

 import java.util.Map;

 import org.jrubyparser.ast.MethodDefNode;

 import org.jrubyparser.ast.Node;

 import org.netbeans.api.java.classpath.ClassPath;

 import org.netbeans.editor.BaseDocument;

 import org.netbeans.modules.csl.spi.ParserResult;

 import org.netbeans.modules.parsing.api.Source;

 import org.netbeans.modules.ruby.options.TypeInferenceSettings;

 import org.openide.filesystems.FileObject;

 /**

  * @todo Test compound assignment:  x = File::Stat.new

  *

  * @author Tor Norbye

  */

 public class RubyTypeAnalyzerTest extends RubyTestBase {

     public RubyTypeAnalyzerTest(String testName) {

         super(testName);

         RubyIndexer.userSourcesTest = true;

         TypeInferenceSettings.getDefault().setMethodTypeInference(true);

         TypeInferenceSettings.getDefault().setRdocTypeInference(true);

     }

     @Override

     protected Map<String, ClassPath> createClassPathsForTest() {

         return rubyTestsClassPath();

     }

     private RubyTypeInferencer getInferencer(String file, String caretLine, boolean findMethod) throws Exception {

         FileObject fo = getTestFile("testfiles/" + file);

         int caretOffset = -1;

         if (caretLine != null) {

             Source source = Source.create(fo);

             caretOffset = getCaretOffset(source.createSnapshot().getText().toString(), caretLine);

             enforceCaretOffset(source, caretOffset);

         }

         ParserResult parserResult = getParserResult(fo);

         Node root = AstUtilities.getRoot(parserResult);

         initializeRegistry();

         RubyIndex index = RubyIndex.get(parserResult);

         Node node = root.getNodeAt(caretOffset);

         if (findMethod) {

             MethodDefNode method = AstUtilities.findMethodAtOffset(root, caretOffset);

             assertNotNull(method);

             root = method;

         }

         ContextKnowledge knowledge = new ContextKnowledge(index, root, node, caretOffset, caretOffset, parserResult);

         return RubyTypeInferencer.create(knowledge);

     }

     private void assertTypes(final RubyType actualTypes, final String... expectedTypes) {

         assertTypes(null, actualTypes, expectedTypes);

     }

     private void assertTypes(final String message, final RubyType actualTypes, final String... expectedTypes) {

         assertTypes(message, actualTypes, false, expectedTypes);

     }

     private void assertTypes(final String message, final RubyType actualTypes,

             final boolean hasUnknownMember, final String... expectedTypes) {

         RubyType expected = new RubyType(expectedTypes);

         if (hasUnknownMember) {

             expected.append(RubyType.unknown());

         }

         assertTrue(message + ":" +

                 "\n  actualTypes:   " + actualTypes +

                 "\n  expectedTypes: " + expected, actualTypes.equals(expected));

     }

     private void assertTypes(String relFilePath, String matchingLine,

             String exprToInfer, String... expectedTypes) throws Exception {

         assertTypes(relFilePath, matchingLine, exprToInfer, false, expectedTypes);

     }

     private void assertTypes(String relFilePath, String matchingLine,

             String exprToInfer, boolean hasUnknownMember, String... expectedTypes) throws Exception {

         RubyTypeInferencer instance = getInferencer(relFilePath, matchingLine, false);

         assertTypes("Types correctly inferred", instance.inferType(exprToInfer), hasUnknownMember, expectedTypes);

     }

     public void testGetType() throws Exception {

         RubyTypeInferencer instance = getInferencer("types.rb", " l^oc = {", false);

         assertTypes(instance.inferType("x"), "Integer");

         // y is reassigned later in the file - make sure that at this

         // point in scope we have the right type

         assertTypes(instance.inferType("y"), "File");

         assertTypes(instance.inferType("$baz"), "Hash");

         assertTypes(instance.inferType("@bar"), "Fixnum");

         assertTypes(instance.inferType("@foo"), "Array");

     }

     public void testGetType2() throws Exception {

         RubyTypeInferencer instance = getInferencer("types.rb", " # d^one", false);

         // Y is assigned different types - make sure that at this position, it's a number

         assertTypes(instance.inferType("y"), "Fixnum");

         // Lots of reassignments - track types through vars, statics, fields, classvars

         assertTypes(instance.inferType("loc"), "Hash");

         assertTypes(instance.inferType("$glob"), "Hash");

         assertTypes(instance.inferType("@field"), "Hash");

         assertTypes(instance.inferType("@@clsvar"), "Hash");

         assertTypes(instance.inferType("loc2"), "Hash");

     }

     public void testMultipleAssigments() throws Exception {

         RubyTypeInferencer instance = getInferencer("types.rb", " # d^one", false);

         assertTypes(instance.inferType("q"), "Fixnum");

         assertTypes(instance.inferType("w"), "Fixnum");

         assertTypes(instance.inferType("e"), "String");

         assertTypes(instance.inferType("@r"), "String");

         assertTypes(instance.inferType("@t"), "Fixnum");

     }

     public void testNestedMultipleAssigments() throws Exception {

         RubyTypeInferencer instance = getInferencer("types.rb", " # d^one", false);

         assertTypes(instance.inferType("u"), "String");

         assertTypes(instance.inferType("i"), "Fixnum");

         assertTypes(instance.inferType("o"), "Float");

         assertTypes(instance.inferType("p"), "File");

     }

     public void testTypeAssertions() throws Exception {

         RubyTypeInferencer instance = getInferencer("types.rb", " l^oc = {", true);

         assertTypes(instance.inferType("param1"), "String");

         assertTypes(instance.inferType("param2"), "Hash");

     }

     public void testBegin() throws Exception {

         RubyTypeInferencer instance = getInferencer("types2.rb", " @f^iles = ARGV.dup", false);

         assertTypes(instance.inferType("go"), "GetoptLong");

     }

     public void testRailsController() throws Exception {

         assertTypes("type_controller.rb", "^end", "request", "ActionController::CgiRequest");

         RubyTypeInferencer instance = getInferencer("type_controller.rb", "^end", false);

         assertTypes(instance.inferType("request"), "ActionController::CgiRequest");

     }

 // This test doesn't work; the behavior works in the IDE but the

 // Lucene index isn't returning local symbols in the testing framework yet

 //    public void testComplex1() throws Exception {

 //        RubyTypeInferencer instance = getAnalyzer("types3.rb", "^caret", false);

 //        assertEquals("Product", instance.getType("@product"));

 //    }

 //    public void testComplex2() throws Exception {

 //        RubyTypeInferencer instance = getAnalyzer("types3.rb", "^caret", true);

 //        assertEquals("ActiveRecord::ConnectionAdapters::TableDefinition", instance.getType("t"));

 //    }

     //public void testComplex3() throws Exception {

     //    // XXX TODO

     //    assertFalse("Check that I do closures for each, collect, map, etc.", true);

     //    // also check to_s

     //}

     // TODO: Make sure I can handle compound expressions like this one:

     //  Product.find(params[:id]).destroy

     public void testMigrationType() throws Exception {

         RubyTypeInferencer instance = getInferencer("migrate/20080726182725_create_posts.rb", " t.^time", true);

         assertTypes(instance.inferType("t"), "ActiveRecord::ConnectionAdapters::TableDefinition");

     }

     public void testIfType() throws Exception {

         assertTypes("if_type.rb", "p va^r.in", "var", "String", "NilClass");

     }

     public void testIfElseType() throws Exception {

         assertTypes("if_else_type.rb", "p va^r.in", "var", "String", "Array");

     }

     public void testIfElseType2() throws Exception {

         assertTypes("if_else_type_2.rb", "p va^r.in", "var", "String", "NilClass");

     }

     public void testIfElseWithInBlockReassignmentType() throws Exception {

         assertTypes("if_else_with_block_reassignment_type.rb", "p va^r.in", "var", "Hash", "Array");

     }

     public void testIfElseIfElseType() throws Exception {

         assertTypes("if_elsif_else_type.rb", "p va^r.in", "var", "String", "Array", "Hash");

     }

     public void testUnlessType() throws Exception {

         assertTypes("unless_type.rb", "var.i^", "var", "Array", "Hash");

     }

     public void testForType() throws Exception {

         assertTypes("for_type.rb", "tmp^ = i", "i", false, "Fixnum");

         assertTypes("for_type.rb", "s^ = j", "j", false, "String");

     }

     public void testEqualsType() throws Exception {

         assertTypes("equals_type.rb", "var.t^", "var", "TrueClass", "FalseClass");

         assertTypes("equals_type.rb", "var2.t^", "var2", "TrueClass", "FalseClass");

     }

     public void testIfWithFailingInferenceInBranchType() throws Exception {

         assertTypes("if_with_failing_inference_in_branch_type.rb", "var.to_^", "var", true, "NilClass");

     }

     // TODO inference is still not able to do the below

     public void FIXME_testIfElseNestedSimpleType() throws Exception {

         assertTypes("if_else_nested_simple_type.rb", "var.^ifcond1b", "var", "Float");

         assertTypes("if_else_nested_simple_type.rb", "var.^aa", "var", "NilClass", "Float");

     }

     // TODO inference is still not able to do the below

     public void FIXME_testIfElseNestedType() throws Exception {

         assertTypes("if_else_nested_type.rb", "va^r.ifcond2", "var", "Hash");

         // XXX more, see the if_else_nested_type.rb

     }

     public void testConstant() throws Exception {

         assertTypes("constants.rb", "Colors::RED.byte^", "Colors::RED", "String");

         assertTypes("constants.rb", "puts b.down^case", "b", "String");

         // TODO fix and uncomment when reindexed

         // assertTypes("indexed constants type inference", "constants.rb", "REXML::COPY^RIGHT", "COPYRIGHT", "String");

     }

     public void testMethodType() throws Exception {

         assertTypes("method_type_inference.rb", "puts n^um.abs", "num", "Fixnum");

         assertTypes("method_type_inference.rb", "puts cons^t", "const", "Fixnum");

     }

 //    public void testCoreMethodType() throws Exception {

 //        assertTypes("core_methods.rb", "ance^stors.delete(String)", "ancestors", "Array");

 //        assertTypes("core_methods.rb", "puts has_^one.t", "has_one", "TrueClass", "FalseClass");

 //        assertTypes("core_methods.rb", "huh = a.eq^l?(123)", "a", "Fixnum", "Numeric");

 //    }

     public void testMethodsChaining() throws Exception {

         assertTypes("methods_chaining.rb", "puts gree^ting", "greeting", "String");

     }

 }