core/tests/org.eclipse.dltk.core.tests/src/org/eclipse/dltk/core/tests/util/ModelTestUtils.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2017 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  *******************************************************************************/
 package org.eclipse.dltk.core.tests.util;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.dltk.core.IField;
 import org.eclipse.dltk.core.IMethod;
 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.core.IModule;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.IType;
 import org.eclipse.dltk.core.ModelException;

 import junit.framework.TestCase;

 public class ModelTestUtils {

 	public static void assertParameterNames(IMethod method, String[] names)
 			throws Exception {
 		String[] params = method.getParameterNames();
 		TestCase.assertNotNull(params);
 		int index = 0;
 		for (int i = 0; i < params.length; ++i) {
 			TestCase.assertNotNull(params[i]);
 			TestCase.assertEquals(params[i], names[index]);
 			index++;
 		}
 	}

 	/**
 	 * Used to count classes, field and methods in collection. throws assert
 	 * expression if not equal to specified counts.
 	 *
 	 * @param moduleChildren
 	 * @param classCountNeed
 	 * @param fieldCountNeed
 	 * @param methodCountNeed
 	 * @throws Exception
 	 */
 	public static void counterAssert(IModelElement[] children,
 			int classCountNeed, int fieldCountNeed, int methodCountNeed)
 			throws Exception {
 		int classCount = 0;
 		int fieldCount = 0;
 		int methodCount = 0;

 		IModelElement parent = getElementsParent(children);
 		if (parent == null) {
 			TestCase.assertTrue("Can't get children's parent", false);
 		}

 		Collection<IModelElement> classes = new ArrayList<>(1);
 		Collection<IModelElement> methods = new ArrayList<>(1);
 		Collection<IModelElement> fields = new ArrayList<>(1);

 		getElementChildren(parent, classes, methods, fields);

 		classCount = classes.size();
 		methodCount = methods.size();
 		fieldCount = fields.size();

 		TestCase.assertEquals(classCountNeed, classCount);
 		TestCase.assertEquals(fieldCountNeed, fieldCount);
 		TestCase.assertEquals(methodCountNeed, methodCount);
 	}

 	/**
 	 * Assert check and return filed by name.
 	 *
 	 * @param elements
 	 * @param name
 	 * @return
 	 */

 	public static IField getAssertField(IModelElement[] elements, String name)
 			throws Exception {

 		IModelElement parent = getElementsParent(elements);
 		if (parent == null) {
 			TestCase.assertTrue("Can't get children's parent", false);
 		}

 		Collection<IModelElement> classes = new ArrayList<>(1);
 		Collection<IModelElement> methods = new ArrayList<>(1);
 		Collection<IModelElement> fields = new ArrayList<>(1);

 		getElementChildren(parent, classes, methods, fields);

 		Iterator<IModelElement> i = fields.iterator();
 		while (i.hasNext()) {
 			IModelElement element = i.next();

 			IField field = (IField) element;
 			TestCase.assertNotNull(field);
 			if (field.getElementName().equals(name)) {
 				return field;
 			}

 		}
 		TestCase.assertEquals("Field not exist", "", name);
 		return null;
 	}

 	/**
 	 * Assert check and return method by name. Also checks for arguments count
 	 * to determine method.
 	 */

 	public static IMethod getAssertMethod(IModelElement[] elements, String name,
 			int argCount) throws Exception {
 		IModelElement parent = getElementsParent(elements);
 		if (parent == null) {
 			TestCase.assertTrue("Can't get children's parent", false);
 		}

 		Collection<IModelElement> classes = new ArrayList<>(1);
 		Collection<IModelElement> methods = new ArrayList<>(1);
 		Collection<IModelElement> fields = new ArrayList<>(1);

 		getElementChildren(parent, classes, methods, fields);

 		Iterator<IModelElement> i = methods.iterator();
 		while (i.hasNext()) {
 			IModelElement element = i.next();

 			IMethod method = (IMethod) element;
 			TestCase.assertNotNull(method);
 			if (method.getElementName().equals(name)) {
 				String[] params = method.getParameterNames();
 				TestCase.assertNotNull(params);
 				TestCase.assertEquals(argCount, params.length);

 				return method;
 			}
 		}
 		TestCase.assertEquals("Method not exist", name, "");
 		return null;
 	}

 	/**
 	 * Assert check and return method by name. Also checks for arguments count
 	 * to determine method.
 	 *
 	 * Multiple declarations of one class in one module is ignored.
 	 */
 	public static IType getAssertClass(IModelElement[] elements, String name)
 			throws Exception {
 		IModelElement parent = getElementsParent(elements);
 		if (parent == null) {
 			TestCase.assertTrue("Can't get children's parent", false);
 		}

 		Collection<IModelElement> classes = new ArrayList<>(1);
 		Collection<IModelElement> methods = new ArrayList<>(1);
 		Collection<IModelElement> fields = new ArrayList<>(1);

 		getElementChildren(parent, classes, methods, fields);
 		Iterator<IModelElement> i = classes.iterator();
 		while (i.hasNext()) {
 			IModelElement element = i.next();

 			IType classElement = (IType) element;
 			TestCase.assertNotNull(classElement);
 			if (classElement.getElementName().equals(name)) {
 				return classElement;
 			}

 		}
 		TestCase.assertEquals("Class not exist", "", name);
 		return null;
 	}

 	private static void getElementChildren(IModelElement element,
 			Collection<IModelElement> classes,
 			Collection<IModelElement> methods, Collection<IModelElement> fields)
 			throws ModelException {

 		classes.clear();
 		fields.clear();
 		methods.clear();

 		// we don't use IModelElement children getting here cause we want to
 		// test each model element
 		// descendant's getters.

 		// checking parent element type
 		if (element.getElementType() == IModelElement.SOURCE_MODULE) {
 			IModule parentModule = (IModule) element;

 			IModelElement[] childs = parentModule.getChildren();

 			for (int i = 0; i < childs.length; ++i) {
 				IModelElement c = childs[i];
 				if (c.getElementType() == IModelElement.FIELD) {
 					fields.add(c);
 				} else if (c.getElementType() == IModelElement.METHOD) {
 					methods.add(c);
 				} else if (c.getElementType() == IModelElement.TYPE) {
 					classes.add(c);
 				}
 			}

 		} else if (element.getElementType() == IModelElement.TYPE) {
 			IType parentClass = (IType) element;

 			IModelElement[] childs = parentClass.getChildren();
 			for (int i = 0; i < childs.length; ++i) {
 				IModelElement c = childs[i];
 				if (c.getElementType() == IModelElement.FIELD) {
 					fields.add(c);
 				} else if (c.getElementType() == IModelElement.METHOD) {
 					methods.add(c);
 				} else if (c.getElementType() == IModelElement.TYPE) {
 					classes.add(c);
 				}
 			}
 		} else if (element.getElementType() == IModelElement.METHOD) {
 			IMethod parentMethod = (IMethod) element;

 			IModelElement[] childs = parentMethod.getChildren();
 			for (int i = 0; i < childs.length; ++i) {
 				IModelElement c = childs[i];
 				if (c.getElementType() == IModelElement.FIELD) {
 					fields.add(c);
 				}
 				if (c.getElementType() == IModelElement.METHOD) {
 					methods.add(c);
 				} else if (c.getElementType() == IModelElement.TYPE) {
 					classes.add(c);
 				}
 			}
 			// classes.addAll(parentMethod.getClasses());
 			// methods.addAll(parentMethod.getMethods());
 		} else {
 			return;
 		}
 	}

 	private static IModelElement getElementsParent(IModelElement[] elements) {
 		if (elements.length == 0) {
 			return null;
 		}
 		if (elements[0] != null) {
 			return elements[0].getParent();
 		}
 		return null;
 	}

 	public static void exractZipInto(IScriptProject scriptProject, URL entry)
 			throws IOException, CoreException {

 		IProject prj = scriptProject.getProject();

 		NullProgressMonitor monitor = new NullProgressMonitor();

 		InputStream openStream = entry.openStream();
 		ZipInputStream zis = new ZipInputStream(openStream);
 		while (true) {
 			ZipEntry nextEntry = zis.getNextEntry();
 			if (nextEntry != null) {
 				String name = nextEntry.getName();
 				// System.out.println(name);
 				if (!nextEntry.isDirectory()) {
 					byte[] buf = new byte[1024];
 					int len;
 					ByteArrayOutputStream arrayOut = new ByteArrayOutputStream();
 					while ((len = zis.read(buf)) > 0) {
 						arrayOut.write(buf, 0, len);
 					}
 					ByteArrayInputStream bis = new ByteArrayInputStream(
 							arrayOut.toByteArray());
 					IFile file = prj.getFile(new Path(name));
 					file.create(bis, true, monitor);
 				} else {
 					IFolder f = prj.getFolder(new Path(name));
 					f.create(true, true, monitor);
 				}
 				zis.closeEntry();
 			} else {
 				break;
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2017 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	*******************************************************************************/
	package org.eclipse.dltk.core.tests.util;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Iterator;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipInputStream;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IFolder;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.dltk.core.IField;
	import org.eclipse.dltk.core.IMethod;
	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.core.IModule;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.IType;
	import org.eclipse.dltk.core.ModelException;

	import junit.framework.TestCase;

	public class ModelTestUtils {

	public static void assertParameterNames(IMethod method, String[] names)
	throws Exception {
	String[] params = method.getParameterNames();
	TestCase.assertNotNull(params);
	int index = 0;
	for (int i = 0; i < params.length; ++i) {
	TestCase.assertNotNull(params[i]);
	TestCase.assertEquals(params[i], names[index]);
	index++;
	}
	}

	/**
	* Used to count classes, field and methods in collection. throws assert
	* expression if not equal to specified counts.
	*
	* @param moduleChildren
	* @param classCountNeed
	* @param fieldCountNeed
	* @param methodCountNeed
	* @throws Exception
	*/
	public static void counterAssert(IModelElement[] children,
	int classCountNeed, int fieldCountNeed, int methodCountNeed)
	throws Exception {
	int classCount = 0;
	int fieldCount = 0;
	int methodCount = 0;

	IModelElement parent = getElementsParent(children);
	if (parent == null) {
	TestCase.assertTrue("Can't get children's parent", false);
	}

	Collection<IModelElement> classes = new ArrayList<>(1);
	Collection<IModelElement> methods = new ArrayList<>(1);
	Collection<IModelElement> fields = new ArrayList<>(1);

	getElementChildren(parent, classes, methods, fields);

	classCount = classes.size();
	methodCount = methods.size();
	fieldCount = fields.size();

	TestCase.assertEquals(classCountNeed, classCount);
	TestCase.assertEquals(fieldCountNeed, fieldCount);
	TestCase.assertEquals(methodCountNeed, methodCount);
	}

	/**
	* Assert check and return filed by name.
	*
	* @param elements
	* @param name
	* @return
	*/

	public static IField getAssertField(IModelElement[] elements, String name)
	throws Exception {

	IModelElement parent = getElementsParent(elements);
	if (parent == null) {
	TestCase.assertTrue("Can't get children's parent", false);
	}

	Collection<IModelElement> classes = new ArrayList<>(1);
	Collection<IModelElement> methods = new ArrayList<>(1);
	Collection<IModelElement> fields = new ArrayList<>(1);

	getElementChildren(parent, classes, methods, fields);

	Iterator<IModelElement> i = fields.iterator();
	while (i.hasNext()) {
	IModelElement element = i.next();

	IField field = (IField) element;
	TestCase.assertNotNull(field);
	if (field.getElementName().equals(name)) {
	return field;
	}

	}
	TestCase.assertEquals("Field not exist", "", name);
	return null;
	}

	/**
	* Assert check and return method by name. Also checks for arguments count
	* to determine method.
	*/

	public static IMethod getAssertMethod(IModelElement[] elements, String name,
	int argCount) throws Exception {
	IModelElement parent = getElementsParent(elements);
	if (parent == null) {
	TestCase.assertTrue("Can't get children's parent", false);
	}

	Collection<IModelElement> classes = new ArrayList<>(1);
	Collection<IModelElement> methods = new ArrayList<>(1);
	Collection<IModelElement> fields = new ArrayList<>(1);

	getElementChildren(parent, classes, methods, fields);

	Iterator<IModelElement> i = methods.iterator();
	while (i.hasNext()) {
	IModelElement element = i.next();

	IMethod method = (IMethod) element;
	TestCase.assertNotNull(method);
	if (method.getElementName().equals(name)) {
	String[] params = method.getParameterNames();
	TestCase.assertNotNull(params);
	TestCase.assertEquals(argCount, params.length);

	return method;
	}
	}
	TestCase.assertEquals("Method not exist", name, "");
	return null;
	}

	/**
	* Assert check and return method by name. Also checks for arguments count
	* to determine method.
	*
	* Multiple declarations of one class in one module is ignored.
	*/
	public static IType getAssertClass(IModelElement[] elements, String name)
	throws Exception {
	IModelElement parent = getElementsParent(elements);
	if (parent == null) {
	TestCase.assertTrue("Can't get children's parent", false);
	}

	Collection<IModelElement> classes = new ArrayList<>(1);
	Collection<IModelElement> methods = new ArrayList<>(1);
	Collection<IModelElement> fields = new ArrayList<>(1);

	getElementChildren(parent, classes, methods, fields);
	Iterator<IModelElement> i = classes.iterator();
	while (i.hasNext()) {
	IModelElement element = i.next();

	IType classElement = (IType) element;
	TestCase.assertNotNull(classElement);
	if (classElement.getElementName().equals(name)) {
	return classElement;
	}

	}
	TestCase.assertEquals("Class not exist", "", name);
	return null;
	}

	private static void getElementChildren(IModelElement element,
	Collection<IModelElement> classes,
	Collection<IModelElement> methods, Collection<IModelElement> fields)
	throws ModelException {

	classes.clear();
	fields.clear();
	methods.clear();

	// we don't use IModelElement children getting here cause we want to
	// test each model element
	// descendant's getters.

	// checking parent element type
	if (element.getElementType() == IModelElement.SOURCE_MODULE) {
	IModule parentModule = (IModule) element;

	IModelElement[] childs = parentModule.getChildren();

	for (int i = 0; i < childs.length; ++i) {
	IModelElement c = childs[i];
	if (c.getElementType() == IModelElement.FIELD) {
	fields.add(c);
	} else if (c.getElementType() == IModelElement.METHOD) {
	methods.add(c);
	} else if (c.getElementType() == IModelElement.TYPE) {
	classes.add(c);
	}
	}

	} else if (element.getElementType() == IModelElement.TYPE) {
	IType parentClass = (IType) element;

	IModelElement[] childs = parentClass.getChildren();
	for (int i = 0; i < childs.length; ++i) {
	IModelElement c = childs[i];
	if (c.getElementType() == IModelElement.FIELD) {
	fields.add(c);
	} else if (c.getElementType() == IModelElement.METHOD) {
	methods.add(c);
	} else if (c.getElementType() == IModelElement.TYPE) {
	classes.add(c);
	}
	}
	} else if (element.getElementType() == IModelElement.METHOD) {
	IMethod parentMethod = (IMethod) element;

	IModelElement[] childs = parentMethod.getChildren();
	for (int i = 0; i < childs.length; ++i) {
	IModelElement c = childs[i];
	if (c.getElementType() == IModelElement.FIELD) {
	fields.add(c);
	}
	if (c.getElementType() == IModelElement.METHOD) {
	methods.add(c);
	} else if (c.getElementType() == IModelElement.TYPE) {
	classes.add(c);
	}
	}
	// classes.addAll(parentMethod.getClasses());
	// methods.addAll(parentMethod.getMethods());
	} else {
	return;
	}
	}

	private static IModelElement getElementsParent(IModelElement[] elements) {
	if (elements.length == 0) {
	return null;
	}
	if (elements[0] != null) {
	return elements[0].getParent();
	}
	return null;
	}

	public static void exractZipInto(IScriptProject scriptProject, URL entry)
	throws IOException, CoreException {

	IProject prj = scriptProject.getProject();

	NullProgressMonitor monitor = new NullProgressMonitor();

	InputStream openStream = entry.openStream();
	ZipInputStream zis = new ZipInputStream(openStream);
	while (true) {
	ZipEntry nextEntry = zis.getNextEntry();
	if (nextEntry != null) {
	String name = nextEntry.getName();
	// System.out.println(name);
	if (!nextEntry.isDirectory()) {
	byte[] buf = new byte[1024];
	int len;
	ByteArrayOutputStream arrayOut = new ByteArrayOutputStream();
	while ((len = zis.read(buf)) > 0) {
	arrayOut.write(buf, 0, len);
	}
	ByteArrayInputStream bis = new ByteArrayInputStream(
	arrayOut.toByteArray());
	IFile file = prj.getFile(new Path(name));
	file.create(bis, true, monitor);
	} else {
	IFolder f = prj.getFolder(new Path(name));
	f.create(true, true, monitor);
	}
	zis.closeEntry();
	} else {
	break;
	}
	}
	}
	}