/*******************************************************************************
* Copyright (c) 2000, 2009 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.core.tests.model;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.internal.core.hierarchy.RegionBasedTypeHierarchy;
import org.eclipse.jdt.internal.core.hierarchy.TypeHierarchy;
import junit.framework.Test;
public class TypeHierarchySerializationTests extends AbstractJavaModelTests {
private static final String PROJECTNAME = "TypeHierarchySerialization";
IJavaProject project;
public TypeHierarchySerializationTests(String name) {
super(name);
}
public static Test suite() {
return buildModelTestSuite(TypeHierarchySerializationTests.class);
}
private static void compare(String focus, ITypeHierarchy stored, ITypeHierarchy loaded){
if(stored instanceof RegionBasedTypeHierarchy) {
assertTrue("["+focus+"] hierarchies are not the same", loaded instanceof RegionBasedTypeHierarchy);
compareRegionBasedTypeHierarchy(focus, (RegionBasedTypeHierarchy)stored,(RegionBasedTypeHierarchy)loaded);
} else if(stored instanceof TypeHierarchy) {
assertTrue("["+focus+"] hierarchies are not the same", loaded instanceof TypeHierarchy);
compareTypeHierarchy(focus, (TypeHierarchy)stored,(TypeHierarchy)loaded);
}
}
private static void compareRegionBasedTypeHierarchy(String focus, RegionBasedTypeHierarchy stored, RegionBasedTypeHierarchy loaded){
compareTypeHierarchy(focus, stored, loaded);
}
private static void compareTypeHierarchy(String focus, TypeHierarchy stored, TypeHierarchy loaded){
//System.out.println(stored.toString());
IType type1 = stored.getType();
IType type2 = loaded.getType();
assertEquals("["+focus+"] focus are not the same", type1, type2);
IType[] allTypes1 = stored.getAllTypes();
IType[] allTypes2 = loaded.getAllTypes();
compare("["+focus+"] all types are not the same", allTypes1, allTypes2);
IType[] allClasses1 = stored.getAllClasses();
IType[] allClasses2 = loaded.getAllClasses();
compare("["+focus+"] all classes are not the same", allClasses1, allClasses2);
IType[] allInterfaces1 = stored.getAllInterfaces();
IType[] allInterfaces2 = loaded.getAllInterfaces();
compare("["+focus+"] all interfaces are not the same", allInterfaces1, allInterfaces2);
IType[] rootClasses1 = stored.getRootClasses();
IType[] rootClasses2 = loaded.getRootClasses();
compare("["+focus+"] all roots are not the same", rootClasses1, rootClasses2);
IType[] rootInterfaces1 = stored.getRootInterfaces();
IType[] rootInterfaces2 = loaded.getRootInterfaces();
compare("["+focus+"] all roots are not the same", rootInterfaces1, rootInterfaces2);
Object[] missingTypes1 = stored.missingTypes.toArray();
Object[] missingTypes2 = loaded.missingTypes.toArray();
compare("["+focus+"] all missing types are not the same", missingTypes1, missingTypes2);
for (int i = 0; i < allTypes1.length; i++) {
IType aType = allTypes1[i];
int cachedFlags1 = stored.getCachedFlags(aType);
int cachedFlags2 = loaded.getCachedFlags(aType);
assertEquals("["+focus+"] flags are not the same for "+aType.getFullyQualifiedName(), cachedFlags1, cachedFlags2);
IType superclass1 = stored.getSuperclass(aType);
IType superclass2 = loaded.getSuperclass(aType);
assertEquals("["+focus+"] superclass are not the same for "+aType.getFullyQualifiedName(), superclass1, superclass2);
IType[] superInterfaces1 = stored.getSuperInterfaces(aType);
IType[] superInterfaces2 = loaded.getSuperInterfaces(aType);
compare("["+focus+"] all super interfaces are not the same for "+aType.getFullyQualifiedName(), superInterfaces1, superInterfaces2);
IType[] superTypes1 = stored.getSupertypes(aType);
IType[] superTypes2 = loaded.getSupertypes(aType);
compare("["+focus+"] all super types are not the same for "+aType.getFullyQualifiedName(), superTypes1, superTypes2);
IType[] subclasses1 = stored.getSubclasses(aType);
IType[] subclasses2 = loaded.getSubclasses(aType);
compare("["+focus+"] all subclasses are not the same for "+aType.getFullyQualifiedName(), subclasses1, subclasses2);
IType[] subtypes1 = stored.getSubtypes(aType);
IType[] subtypes2 = loaded.getSubtypes(aType);
compare("["+focus+"] all subtypes are not the same for "+aType.getFullyQualifiedName(), subtypes1, subtypes2);
IType[] extendingInterfaces1 = stored.getExtendingInterfaces(aType);
IType[] extendingInterfaces2 = loaded.getExtendingInterfaces(aType);
compare("["+focus+"] all extending interfaces are not the same for "+aType.getFullyQualifiedName(), extendingInterfaces1, extendingInterfaces2);
IType[] implementingClasses1 = stored.getImplementingClasses(aType);
IType[] implementingClasses2 = loaded.getImplementingClasses(aType);
compare("["+focus+"] all implemeting classes are not the same for "+aType.getFullyQualifiedName(), implementingClasses1, implementingClasses2);
}
}
private static void compare(String msg, Object[] types1, Object[] types2) {
if(types1 == null) {
assertTrue(msg, types2 == null);
} else {
assertTrue(msg, types2 != null);
assertTrue(msg, types1.length == types2.length);
for (int i = 0; i < types1.length; i++) {
boolean found = false;
for (int j = 0; j < types2.length; j++) {
if(types1[i] == null && types1[j] == null) {
found = true;
} else if(types1[i] != null && types1[i].equals(types2[j])) {
found = true;
}
}
assertTrue(msg, found);
}
}
}
public void setUpSuite() throws Exception {
super.setUpSuite();
this.project = setUpJavaProject(PROJECTNAME);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.tests.model.SuiteOfTestCases#tearDownSuite()
*/
public void tearDownSuite() throws Exception {
deleteProject(PROJECTNAME);
super.tearDownSuite();
}
private static void testFocusHierarchy(IType type, IJavaProject project) throws JavaModelException{
ITypeHierarchy h1 = type.newTypeHierarchy(project, null);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
h1.store(outputStream, null);
byte[] bytes = outputStream.toByteArray();
ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
ITypeHierarchy h2 = type.loadTypeHierachy(inputStream, null);
compare(type.getFullyQualifiedName(), h1, h2);
h2.refresh(null);
compare(type.getFullyQualifiedName(), h1, h2);
}
public void test001() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "X.java");
IType type = cu.getType("X");
testFocusHierarchy(type, this.project);
}
public void test002() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "Y.java");
IType type = cu.getType("Y");
testFocusHierarchy(type, this.project);
}
public void test003() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "Z.java");
IType type = cu.getType("Z");
testFocusHierarchy(type, this.project);
}
public void test004() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "I1.java");
IType type = cu.getType("I1");
testFocusHierarchy(type, this.project);
}
public void test005() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "I2.java");
IType type = cu.getType("I2");
testFocusHierarchy(type, this.project);
}
public void test006() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "I3.java");
IType type = cu.getType("I3");
testFocusHierarchy(type, this.project);
}
public void test007() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "I4.java");
IType type = cu.getType("I4");
testFocusHierarchy(type, this.project);
}
public void test008() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "I5.java");
IType type = cu.getType("I5");
testFocusHierarchy(type, this.project);
}
public void test009() throws JavaModelException {
ICompilationUnit cu = getCompilationUnit(PROJECTNAME, "src", "p1", "I6.java");
IType type = cu.getType("I6");
testFocusHierarchy(type, this.project);
}
}
