/*
 * This file is part of Modelica Development Tooling.
 *
 * Copyright (c) 2005, Link�pings universitet, Department of
 * Computer and Information Science, PELAB
 *
 * All rights reserved.
 *
 * (The new BSD license, see also
 * http://www.opensource.org/licenses/bsd-license.php)
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * * Neither the name of Link�pings universitet nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.modelica.mdt.test;

import java.util.Iterator;

import org.modelica.mdt.core.Element;
import org.modelica.mdt.core.List;
import org.modelica.mdt.core.ListElement;
import org.modelica.mdt.core.ModelicaParserException;
import org.modelica.mdt.core.compiler.ModelicaParser;

import junit.framework.TestCase;

/**
 * test org.modelica.mdt.core.compiler.ModelicaParser class' code 
 */
public class TestModelicaParser extends TestCase 
{
	/*
	 * the output of the getElements() function to test parsing
	 */
	private static final String GET_ELEMENTS_OUTPUT =
		
	"{ { elementvisibility=public, " +
     "elementfile=\"/home/x05andre/ex/Modelica Library/Modelica/package.mo\", "+
	 "elementline=2, elementcolumn=1, final=false, replaceable=false, "+
	 "inout=\"none\", elementtype=extends, path=Icons.Library },\n"+
	"{ elementvisibility=public, elementtype=annotation },\n"+
	"{ elementvisibility=public, " +
	 "elementfile=\"/home/x05andre/ex/Modelica Library/Modelica/package.mo\", " +
	 "elementline=127, elementcolumn=1, final=false, replaceable=false, " +
	 "inout=\"none\", elementtype=classdef, classname=UsersGuide, " +
	 "classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/package.mo\", " +
	 "classline=127, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Media, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica" +
	            " Library/Modelica/Media/package.mo\", " +
	 "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Utilities, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica " +
	            "Library/Modelica/Utilities/package.mo\", " +
	            "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Mechanics, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/" +
	             "Modelica/Mechanics/package.mo\", " +
	 "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Electrical, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/" +
	            "Modelica/Electrical/package.mo\"," +
	 " classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Math, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/Math/package.mo\","+
	 " classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Blocks, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica " +
	            "Library/Modelica/Blocks/package.mo\", " +
	            "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Thermal, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica " +
	            "Library/Modelica/Thermal/package.mo\", classline=1, " +
	            "classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Icons, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/Icons.mo\", " +
	 "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=Constants, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/Constants.mo\", " +
	 "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=SIunits, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/SIunits.mo\", " +
	 "classline=1, classcolumn=1 },\n"+
	"{ elementvisibility=public, elementfile=\"\", elementline=0, " +
	 "elementcolumn=0, final=false, replaceable=false, inout=\"none\", " +
	 "elementtype=classdef, classname=StateGraph, classrestriction=PACKAGE, " +
	 "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/StateGraph.mo\", " +
	 "classline=1, classcolumn=1 }\n"+
	"}\n";
	
	/*
	 * the output of the getElements() function to test parsing
	 */

	private static final String GET_CLASS_INFO1 = 
	"{\"model\",\"Chua's circuit, ns, V, A\",\"/home/x05andre/ex/Modelica " +
	"Library/Modelica/Electrical/Analog/Examples/ChuaCircuit.mo\",{false,f" +
	"alse,true},{\"writable\",1,1,65,16}}";
	/*
	 * The expected results when getElements() output is parsed 
	 */
	private static final String[][] GET_ELEMENTS_RES =
	{
	  {"elementvisibility=public",
	   "elementfile=\"/home/x05andre/ex/Modelica Library/Modelica/package.mo\"",
	   "elementline=2", "elementcolumn=1", "final=false", "replaceable=false",
	   "inout=\"none\"", "elementtype=extends", "path=Icons.Library"},
	   
	  {"elementvisibility=public", "elementtype=annotation"},
	  
	  {"elementvisibility=public",
	   "elementfile=\"/home/x05andre/ex/Modelica Library/Modelica/package.mo\"",
	   "elementline=127","elementcolumn=1", "final=false", "replaceable=false",
	   "inout=\"none\"", "elementtype=classdef", "classname=UsersGuide",
	   "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/package.mo\"",
	   "classline=127", "classcolumn=1"},

	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Media", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/Media/package.mo\"",
	   "classline=1", "classcolumn=1"},
	   
	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Utilities", 
	   "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica " +
		            "Library/Modelica/Utilities/package.mo\"",
	   "classline=1", "classcolumn=1"},
	   
	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Mechanics", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica " +
	             "Library/Modelica/Mechanics/package.mo\"",
	   "classline=1", "classcolumn=1"},
	   
	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Electrical", 
	   "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica Library/" +
		            "Modelica/Electrical/package.mo\"",
	   "classline=1", "classcolumn=1" },
	   
	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Math", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica "+
	               "Library/Modelica/Math/package.mo\"",
	   "classline=1", "classcolumn=1" },
	   
	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
       "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
       "elementtype=classdef", "classname=Blocks", "classrestriction=PACKAGE",
       "classfile=\"/home/x05andre/ex/Modelica " +
		            "Library/Modelica/Blocks/package.mo\"",
	   "classline=1", "classcolumn=1" },

	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Thermal", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica " +
		            "Library/Modelica/Thermal/package.mo\"", "classline=1",
	   "classcolumn=1"},
	   
	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=Icons", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/Icons.mo\"",
	   "classline=1", "classcolumn=1" },

	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef","classname=Constants", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/Constants.mo\"",
	   "classline=1", "classcolumn=1" },

	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=SIunits", "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica Library/Modelica/SIunits.mo\"",
	   "classline=1", "classcolumn=1" },

	  {"elementvisibility=public", "elementfile=\"\"", "elementline=0",
	   "elementcolumn=0", "final=false", "replaceable=false", "inout=\"none\"",
	   "elementtype=classdef", "classname=StateGraph",
	   "classrestriction=PACKAGE",
	   "classfile=\"/home/x05andre/ex/Modelica " +
	               "Library/Modelica/StateGraph.mo\"",
	   "classline=1", "classcolumn=1" }
	};

	/**
	 * test parsing some simple unnested lists with ModelicaParser.parseList()
	 * @throws ModelicaParserException 
	 */
	public void testParseSimpleList() throws ModelicaParserException
	{
		/*
		 * some combinations of empty lists
		 */
		List res;
		
		res = ModelicaParser.parseList("{}");
		assertEquals(0, res.size());
	
		res = ModelicaParser.parseList("{ }");
		assertEquals(0, res.size());
		
		res = ModelicaParser.parseList("{    }");
		assertEquals(0, res.size());

		
		res = ModelicaParser.parseList("{ \n}");
		assertEquals(0, res.size());
		
		res = ModelicaParser.parseList("{   \n    }");
		assertEquals(0, res.size());

		/*
		 * single element lists
		 */
		res = ModelicaParser.parseList("{hej}");
		assertEquals(1, res.size());
		assertEquals("hej", res.elementAt(0).toString());
		
		res = ModelicaParser.parseList("{  muu}");
		assertEquals(1,res.size());
		assertEquals("muu", res.elementAt(0).toString());
		
		res = ModelicaParser.parseList("{  muu   }");
		assertEquals(1, res.size());
		assertEquals("muu", res.elementAt(0).toString());

		res = ModelicaParser.parseList("{muu   }");
		assertEquals(1, res.size());
		assertEquals("muu", res.elementAt(0).toString());


		/*
		 * two element lists
		 */
		res = ModelicaParser.parseList("{hej,peter}");
		assertEquals(2, res.size());
		assertEquals("hej", res.elementAt(0).toString());
		assertEquals("peter", res.elementAt(1).toString());
		
		res = ModelicaParser.parseList("{peter,  labb}");
		assertEquals("peter", res.elementAt(0).toString());
		assertEquals("labb", res.elementAt(1).toString());
		
		res = ModelicaParser.parseList("{peter ,labb}");
		assertEquals("peter", res.elementAt(0).toString());
		assertEquals("labb", res.elementAt(1).toString());
		
		res = ModelicaParser.parseList("{peter   ,labb}");
		assertEquals("peter", res.elementAt(0).toString());
		assertEquals("labb", res.elementAt(1).toString());
		
		/*
		 * tree elements list
		 */
		res = ModelicaParser.parseList("{alan, l, cox}");
		assertEquals(3, res.size());
		assertEquals("alan", res.elementAt(0).toString());
		assertEquals("l", res.elementAt(1).toString());
		assertEquals("cox", res.elementAt(2).toString());
		
		res = ModelicaParser.parseList("{alan,l,cox}");
		assertEquals(3, res.size());
		assertEquals("alan", res.elementAt(0).toString());
		assertEquals("l", res.elementAt(1).toString());
		assertEquals("cox",res.elementAt(2).toString());

	}
	
	/**
	 * test parsing some nested lists with ModelicaParser.parseList()
	 * @throws ModelicaParserException 
	 */
	public void testParseList() throws ModelicaParserException
	{
		List v = ModelicaParser.parseList("{{a    ,b   }  ,   c   }");
		assertTrue(v.elementAt(0) instanceof List);
		assertTrue(v.size() == 2);

		assertEquals("a", ((List)v.elementAt(0)).elementAt(0).toString());
		assertEquals("b", ((List)v.elementAt(0)).elementAt(1).toString());
		assertEquals("c", v.elementAt(1).toString());
		
		v = ModelicaParser.parseList("{a, b, c}");
		assertEquals(3, v.size());
		assertEquals("a", v.elementAt(0).toString());
		assertEquals("b", v.elementAt(1).toString());
		assertEquals("c", v.elementAt(2).toString());
		
		v = ModelicaParser.parseList("{a, b, c={a, b, c}}");
		assertEquals(3, v.size());
		assertEquals("a", v.elementAt(0).toString());
		assertEquals("b", v.elementAt(1).toString());
		assertEquals("c={a, b, c}", v.elementAt(2).toString());
		
		boolean failedParse = false;
		try
		{
			v = ModelicaParser.parseList("{,,}");
		}
		catch(ModelicaParserException e)
		{
			failedParse = true;
		}
		assertTrue("Parsing didn't fail on {,,}", failedParse);
		
		v = ModelicaParser.parseList("{foo={bar, gzonk}}");
		assertEquals(1, v.size());
		assertEquals("foo={bar, gzonk}", v.elementAt(0).toString());
	}
	
	/**
	 * Test actual input that omc have returned via getElementsInfo()
	 * function.
	 */
	public void testParseGetElementsOutput() throws ModelicaParserException
	{
		List parsedList = ModelicaParser.parseList(GET_ELEMENTS_OUTPUT);
		
		assertEquals(14, parsedList.size());
		
		/*
		 * each element in the res should be a list
		 */
		Iterator<ListElement> it = parsedList.iterator();
		for (String[] expectedList : GET_ELEMENTS_RES)
		{
			ListElement parsedElements = it.next();
			assertTrue("expected to find a list but found an element",
					 (parsedElements instanceof List));
			
			Iterator<ListElement> elementsIterator = ((List)parsedElements).iterator(); 
			for (String expectedElement : expectedList)
			{
				assertEquals("parsed list contains unexpected element",
						expectedElement, elementsIterator.next().toString()); 
			}
			assertFalse("more elements then expected in the parse results",
					elementsIterator.hasNext());
		}
	}
	
	/**
	 * Test actual input that omc have returned via getClassInformation()
	 * function.
	 */
	public void testParseGetClassInformationOutput() throws ModelicaParserException
	{
		List parsedList;
		ListElement listElement;
		List list;

		parsedList = ModelicaParser.parseList(GET_CLASS_INFO1);

		assertEquals("Parse resuls is of wrong length", 5, parsedList.size());
		
		listElement = parsedList.elementAt(0);
		assertTrue("Expected simple element found list",
				listElement instanceof Element);
		assertEquals("Wrong string", "\"model\"",
				((Element)listElement).toString());

		listElement = parsedList.elementAt(1);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("Wrong string",
				"\"Chua's circuit, ns, V, A\"",
				((Element)listElement).toString());
		
		listElement = parsedList.elementAt(2);
		assertTrue("Expected simple element found list",
				listElement instanceof Element);
		assertEquals("Wrong string",
				"\"/home/x05andre/ex/Modelica Library/Modelica/Electrical/Anal" +
				"og/Examples/ChuaCircuit.mo\"",
				((Element)listElement).toString());
		
		listElement = parsedList.elementAt(3);
		assertTrue("expected list found simple element",
				listElement instanceof List);
		list = (List)listElement;
		
		assertEquals("parse resuls if of wrong length", 3, list.size());
		
		listElement = list.elementAt(0);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "false",
				((Element)listElement).toString());
		
		listElement = list.elementAt(1);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "false",
				((Element)listElement).toString());
		
		listElement = list.elementAt(2);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "true",
				((Element)listElement).toString());


		listElement = parsedList.elementAt(4);
		assertTrue("expected list found simple element",
				listElement instanceof List);
		list = (List)listElement;
		
		assertEquals("parse resuls if of wrong length", 5, list.size());
		
		listElement = list.elementAt(0);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "\"writable\"",
				((Element)listElement).toString());
		
		listElement = list.elementAt(1);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "1",
				((Element)listElement).toString());
		
		listElement = list.elementAt(2);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "1",
				((Element)listElement).toString());
		
		listElement = list.elementAt(3);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "65",
				((Element)listElement).toString());

		listElement = list.elementAt(4);
		assertTrue("expected simple element found list",
				listElement instanceof Element);
		assertEquals("wrong string", "16",
				((Element)listElement).toString());
	}
}