Attachment #178540 for bug #324076

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 324076
Collapse All | Expand All

Lines 1065-1070 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BaseApiAnalyzer.java (-1 / +2 lines)
1065	IDelta.REMOVED,	1065	IDelta.REMOVED,
1066	IDelta.TYPE,	1066	IDelta.TYPE,
1067	restrictions,	1067	restrictions,
		1068	RestrictionModifiers.NO_RESTRICTIONS,
1068	type.getModifiers(),	1069	type.getModifiers(),
1069	0,	1070	0,
1070	typeName,	1071	typeName,
Lines 1500-1506 Link Here
1500	int kind = delta.getKind();	1501	int kind = delta.getKind();
1501	int modifiers = delta.getNewModifiers();	1502	int modifiers = delta.getNewModifiers();
1502	if (DeltaProcessor.isCompatible(delta)) {	1503	if (DeltaProcessor.isCompatible(delta)) {
1503	if (!RestrictionModifiers.isReferenceRestriction(delta.getRestrictions())) {	1504	if (!RestrictionModifiers.isReferenceRestriction(delta.getCurrentRestrictions())) {
1504	if (Util.isVisible(modifiers)) {	1505	if (Util.isVisible(modifiers)) {
1505	if (Flags.isProtected(modifiers)) {	1506	if (Flags.isProtected(modifiers)) {
1506	String typeName = delta.getTypeName();	1507	String typeName = delta.getTypeName();

Lines 189-195 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BuildState.java (-2 / +4 lines)
189	}	189	}
190	int oldModifiers = modifiers & Delta.MODIFIERS_MASK;	190	int oldModifiers = modifiers & Delta.MODIFIERS_MASK;
191	int newModifiers = modifiers >>> Delta.NEW_MODIFIERS_OFFSET;	191	int newModifiers = modifiers >>> Delta.NEW_MODIFIERS_OFFSET;
192	return new Delta(componentID, elementType, kind, flags, restrictions, oldModifiers, newModifiers, typeName, key, datas);	192	int previousRestrictions = restrictions >>> Delta.PREVIOUS_RESTRICTIONS_OFFSET;
		193	int currentRestrictions = restrictions & Delta.RESTRICTIONS_MASK;
		194	return new Delta(componentID, elementType, kind, flags, currentRestrictions, previousRestrictions, oldModifiers, newModifiers, typeName, key, datas);
193	}	195	}
194		196
195	/**	197	/**
Lines 210-216 Link Here
210	out.writeInt(delta.getElementType());	212	out.writeInt(delta.getElementType());
211	out.writeInt(delta.getKind());	213	out.writeInt(delta.getKind());
212	out.writeInt(delta.getFlags());	214	out.writeInt(delta.getFlags());
213	out.writeInt(delta.getRestrictions());	215	out.writeInt(delta.getCurrentRestrictions());
214	int modifiers = (delta.getNewModifiers() << Delta.NEW_MODIFIERS_OFFSET) \| delta.getOldModifiers();	216	int modifiers = (delta.getNewModifiers() << Delta.NEW_MODIFIERS_OFFSET) \| delta.getOldModifiers();
215	out.writeInt(modifiers);	217	out.writeInt(modifiers);
216	out.writeUTF(delta.getTypeName());	218	out.writeUTF(delta.getTypeName());

Lines 173-179 Link Here

(-)src/org/eclipse/pde/api/tools/internal/comparator/ClassFileComparator.java (-2 / +8 lines)
173	this.addDelta(new Delta(Util.getDeltaComponentVersionsId(this.component2), elementType, kind, flags, restrictions, oldModifiers, newModifiers, type.getName(), key, data));	173	this.addDelta(new Delta(Util.getDeltaComponentVersionsId(this.component2), elementType, kind, flags, restrictions, oldModifiers, newModifiers, type.getName(), key, data));
174	}	174	}
175	private void addDelta(int elementType, int kind, int flags, int restrictions, int oldModifiers, int newModifiers, IApiType type, String key, String[] datas) {	175	private void addDelta(int elementType, int kind, int flags, int restrictions, int oldModifiers, int newModifiers, IApiType type, String key, String[] datas) {
176	this.addDelta(new Delta(Util.getDeltaComponentVersionsId(this.component2), elementType, kind, flags, restrictions, oldModifiers, newModifiers, type.getName(), key, datas));	176	this.addDelta(new Delta(Util.getDeltaComponentVersionsId(this.component2), elementType, kind, flags, restrictions, 0, oldModifiers, newModifiers, type.getName(), key, datas));
		177	}
		178	private void addDelta(int elementType, int kind, int flags, int currentRestrictions, int previousRestrictions, int oldModifiers, int newModifiers, IApiType type, String key, String[] datas) {
		179	this.addDelta(new Delta(Util.getDeltaComponentVersionsId(this.component2), elementType, kind, flags, currentRestrictions, previousRestrictions, oldModifiers, newModifiers, type.getName(), key, datas));
177	}	180	}
178	/**	181	/**
179	* Checks if the super-class set has been change in any way compared to the baseline (grown or reduced or types changed)	182	* Checks if the super-class set has been change in any way compared to the baseline (grown or reduced or types changed)
Lines 542-547 Link Here
542	IDelta.CHANGED,	545	IDelta.CHANGED,
543	IDelta.DECREASE_ACCESS,	546	IDelta.DECREASE_ACCESS,
544	restrictions \| this.currentDescriptorRestrictions,	547	restrictions \| this.currentDescriptorRestrictions,
		548	0,
545	typeMember.getModifiers(),	549	typeMember.getModifiers(),
546	typeMember2.getModifiers(),	550	typeMember2.getModifiers(),
547	typeMember.getName(),	551	typeMember.getName(),
Lines 558-563 Link Here
558	IDelta.CHANGED,	562	IDelta.CHANGED,
559	IDelta.TYPE_VISIBILITY,	563	IDelta.TYPE_VISIBILITY,
560	restrictions \| this.currentDescriptorRestrictions,	564	restrictions \| this.currentDescriptorRestrictions,
		565	0,
561	typeMember.getModifiers(),	566	typeMember.getModifiers(),
562	typeMember2.getModifiers(),	567	typeMember2.getModifiers(),
563	typeMember.getName(),	568	typeMember.getName(),
Lines 2369-2380 Link Here
2369	if (restrictions != referenceRestrictions) {	2374	if (restrictions != referenceRestrictions) {
2370	if (!Flags.isFinal(access2)) {	2375	if (!Flags.isFinal(access2)) {
2371	if (RestrictionModifiers.isOverrideRestriction(restrictions)	2376	if (RestrictionModifiers.isOverrideRestriction(restrictions)
2372	&& !RestrictionModifiers.isOverrideRestriction(referenceRestrictions)) {	2377	&& !RestrictionModifiers.isOverrideRestriction(referenceRestrictions)) {
2373	this.addDelta(	2378	this.addDelta(
2374	getElementType(method),	2379	getElementType(method),
2375	IDelta.ADDED,	2380	IDelta.ADDED,
2376	IDelta.RESTRICTIONS,	2381	IDelta.RESTRICTIONS,
2377	restrictions,	2382	restrictions,
		2383	referenceRestrictions,
2378	access,	2384	access,
2379	access2,	2385	access2,
2380	this.type1,	2386	this.type1,

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/internal/comparator/Delta.java (-9 / +17 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 IBM Corporation and others.	2	* Copyright (c) 2007, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 28-33 Link Here
28	public static final int MODIFIERS_MASK = 0xFFFF;	28	public static final int MODIFIERS_MASK = 0xFFFF;
29	public static final int NEW_MODIFIERS_OFFSET = 16;	29	public static final int NEW_MODIFIERS_OFFSET = 16;
30		30
		31	public static final int RESTRICTIONS_MASK = 0xFFFF;
		32	public static final int PREVIOUS_RESTRICTIONS_OFFSET = 16;
		33
31	/**	34	/**
32	* Writes the delta to the given {@link PrintWriter}	35	* Writes the delta to the given {@link PrintWriter}
33	* @param delta	36	* @param delta
Lines 105-121 Link Here
105	* @param data	108	* @param data
106	*/	109	*/
107	public Delta(String componentID, int elementType, int kind, int flags, int restrictions, int oldModifiers, int newModifiers, String typeName, String key, String data) {	110	public Delta(String componentID, int elementType, int kind, int flags, int restrictions, int oldModifiers, int newModifiers, String typeName, String key, String data) {
108	this(componentID, elementType, kind, flags, restrictions, oldModifiers, newModifiers, typeName, key, new String[] {data});	111	this(componentID, elementType, kind, flags, restrictions, 0, oldModifiers, newModifiers, typeName, key, new String[] {data});
109	}	112	}
110		113
111	public Delta(String componentID, int elementType, int kind, int flags, int restrictions, int oldModifiers, int newModifiers, String typeName, String key, String[] datas) {	114	public Delta(String componentID, int elementType, int kind, int flags, int restrictions, int previousRestrictions, int oldModifiers, int newModifiers, String typeName, String key, String[] datas) {
112	this.componentID = componentID;	115	this.componentID = componentID;
113	this.elementType = elementType;	116	this.elementType = elementType;
114	this.kind = kind;	117	this.kind = kind;
115	this.flags = flags;	118	this.flags = flags;
116	this.modifiers = (newModifiers & MODIFIERS_MASK) << 16 \| (oldModifiers & MODIFIERS_MASK);	119	this.modifiers = (newModifiers & MODIFIERS_MASK) << NEW_MODIFIERS_OFFSET \| (oldModifiers & MODIFIERS_MASK);
117	this.typeName = typeName == null ? Util.EMPTY_STRING : typeName;	120	this.typeName = typeName == null ? Util.EMPTY_STRING : typeName;
118	this.restrictions = restrictions;	121	this.restrictions = (previousRestrictions & RESTRICTIONS_MASK) << PREVIOUS_RESTRICTIONS_OFFSET \| (restrictions & RESTRICTIONS_MASK);
119	this.key = key;	122	this.key = key;
120	this.datas = datas;	123	this.datas = datas;
121	}	124	}
Lines 304-315 Link Here
304	return this.modifiers & MODIFIERS_MASK;	307	return this.modifiers & MODIFIERS_MASK;
305	}	308	}
306	/* (non-Javadoc)	309	/* (non-Javadoc)
307	* @see org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta#getRestrictions()	310	* @see org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta#getCurrentRestrictions()
308	*/	311	*/
309	public int getRestrictions() {	312	public int getCurrentRestrictions() {
310	return this.restrictions;	313	return (this.restrictions & RESTRICTIONS_MASK);
		314	}
		315	/* (non-Javadoc)
		316	* @see org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta#getPreviousRestrictions()
		317	*/
		318	public int getPreviousRestrictions() {
		319	return (this.restrictions >>> PREVIOUS_RESTRICTIONS_OFFSET);
311	}	320	}
312
313	/* (non-Javadoc)	321	/* (non-Javadoc)
314	* @see org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta#getTypeName()	322	* @see org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta#getTypeName()
315	*/	323	*/

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/internal/comparator/DeltaXmlVisitor.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 IBM Corporation and others.	2	* Copyright (c) 2007, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 73-79 Link Here
73	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_COMPATIBLE, Boolean.toString(DeltaProcessor.isCompatible(delta)));	73	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_COMPATIBLE, Boolean.toString(DeltaProcessor.isCompatible(delta)));
74	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_OLD_MODIFIERS, Integer.toString(delta.getOldModifiers()));	74	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_OLD_MODIFIERS, Integer.toString(delta.getOldModifiers()));
75	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_NEW_MODIFIERS, Integer.toString(delta.getNewModifiers()));	75	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_NEW_MODIFIERS, Integer.toString(delta.getNewModifiers()));
76	deltaElement.setAttribute(IApiXmlConstants.ATTR_RESTRICTIONS, Integer.toString(delta.getRestrictions()));	76	deltaElement.setAttribute(IApiXmlConstants.ATTR_RESTRICTIONS, Integer.toString(delta.getCurrentRestrictions()));
77	String apiComponentID = delta.getComponentVersionId();	77	String apiComponentID = delta.getComponentVersionId();
78	if (apiComponentID != null) {	78	if (apiComponentID != null) {
79	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_COMPONENT_ID, apiComponentID);	79	deltaElement.setAttribute(IApiXmlConstants.ATTR_NAME_COMPONENT_ID, apiComponentID);

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/internal/comparator/Messages.java (-3 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 IBM Corporation and others.	2	* Copyright (c) 2008, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 418-427 Link Here
418	case IDelta.SYNCHRONIZED_TO_NON_SYNCHRONIZED :	418	case IDelta.SYNCHRONIZED_TO_NON_SYNCHRONIZED :
419	return 74;	419	return 74;
420	case IDelta.NON_FINAL_TO_FINAL :	420	case IDelta.NON_FINAL_TO_FINAL :
421	if (RestrictionModifiers.isExtendRestriction(delta.getRestrictions())) {	421	if (RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions())) {
422	return 81;	422	return 81;
423	}	423	}
424	if (RestrictionModifiers.isOverrideRestriction(delta.getRestrictions())) {	424	if (RestrictionModifiers.isOverrideRestriction(delta.getCurrentRestrictions())) {
425	return 82;	425	return 82;
426	}	426	}
427	return 83;	427	return 83;

Lines 327-333 Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/BundleComponent.java (-1 / +1 lines)
327	version = ver != null ? new Version(ver) : null;	327	version = ver != null ? new Version(ver) : null;
328	}	328	}
329	catch (NumberFormatException nfe) {	329	catch (NumberFormatException nfe) {
330	version = null;	330	// ignore
331	}	331	}
332	ManifestElement[] name = ManifestElement.parseHeader(Constants.BUNDLE_SYMBOLICNAME, (String)manifest.get(Constants.BUNDLE_SYMBOLICNAME));	332	ManifestElement[] name = ManifestElement.parseHeader(Constants.BUNDLE_SYMBOLICNAME, (String)manifest.get(Constants.BUNDLE_SYMBOLICNAME));
333	if(name.length < 1) {	333	if(name.length < 1) {




						IDelta.CHANGED,
						IDelta.MAJOR_VERSION,
						RestrictionModifiers.NO_RESTRICTIONS,
						RestrictionModifiers.NO_RESTRICTIONS,
						0,
						0,
						null,

						IDelta.CHANGED,
						IDelta.MINOR_VERSION,
						RestrictionModifiers.NO_RESTRICTIONS,
						RestrictionModifiers.NO_RESTRICTIONS,
						0,
						0,
						null,

									IDelta.REMOVED,
									IDelta.EXECUTION_ENVIRONMENT,
									RestrictionModifiers.NO_RESTRICTIONS,
									RestrictionModifiers.NO_RESTRICTIONS,
									0,
									0,
									null,

								IDelta.ADDED,
								IDelta.EXECUTION_ENVIRONMENT,
								RestrictionModifiers.NO_RESTRICTIONS,
								RestrictionModifiers.NO_RESTRICTIONS,
								0,
								0,
								null,

							IDelta.ADDED,
							reexporter == null ? IDelta.TYPE : IDelta.REEXPORTED_TYPE,
							elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
							RestrictionModifiers.NO_RESTRICTIONS,
							0,
							typeDescriptor2.getModifiers(),
							typeName,

							IDelta.REMOVED,
							IDelta.API_TYPE,
							elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
							RestrictionModifiers.NO_RESTRICTIONS,
							typeDescriptor.getModifiers(),
							typeDescriptor2.getModifiers(),
							typeName,

						IDelta.ADDED,
						IDelta.TYPE,
						elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
						RestrictionModifiers.NO_RESTRICTIONS,
						typeDescriptor.getModifiers(),
						typeDescriptor2.getModifiers(),
						typeName,

							IDelta.REMOVED,
							IDelta.API_TYPE,
							elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
							RestrictionModifiers.NO_RESTRICTIONS,
							typeDescriptor.getModifiers(),
							typeDescriptor2.getModifiers(),
							typeName,

													IDelta.REMOVED,
													IDelta.TYPE,
													RestrictionModifiers.NO_RESTRICTIONS,
													RestrictionModifiers.NO_RESTRICTIONS,
													typeDescriptor.getModifiers(),
													0,
													typeName,

													IDelta.REMOVED,
													reexported ?  IDelta.REEXPORTED_API_TYPE : IDelta.API_TYPE,
													elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
													RestrictionModifiers.NO_RESTRICTIONS,
													typeDescriptor.getModifiers(),
													typeDescriptor2.getModifiers(),
													typeName,

														IDelta.CHANGED,
														IDelta.TYPE_VISIBILITY,
														elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
														RestrictionModifiers.NO_RESTRICTIONS,
														typeDescriptor.getModifiers(),
														typeDescriptor2.getModifiers(),
														typeName,

																IDelta.REMOVED,
																IDelta.REEXPORTED_TYPE,
																RestrictionModifiers.NO_RESTRICTIONS,
																RestrictionModifiers.NO_RESTRICTIONS,
																typeDescriptor.getModifiers(),
																0,
																typeName,

																IDelta.REMOVED,
																IDelta.REEXPORTED_API_TYPE,
																elementDescription2 != null ? elementDescription2.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
																RestrictionModifiers.NO_RESTRICTIONS,
																typeDescriptor.getModifiers(),
																typeDescriptor2.getModifiers(),
																typeName,

												IDelta.ADDED,
												IDelta.TYPE,
												elementDescription != null ? elementDescription.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
												RestrictionModifiers.NO_RESTRICTIONS,
												0,
												type.getModifiers(),
												typeName,

															IDelta.ADDED,
															IDelta.REEXPORTED_TYPE,
															elementDescription != null ? elementDescription.getRestrictions() : RestrictionModifiers.NO_RESTRICTIONS,
															RestrictionModifiers.NO_RESTRICTIONS,
															0,
															typeDescriptor.getModifiers(),
															typeName,

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/internal/provisional/comparator/DeltaProcessor.java (-19 / +22 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 IBM Corporation and others.	2	* Copyright (c) 2007, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 173-179 Link Here
173	* @return true if compatible, false otherwise	173	* @return true if compatible, false otherwise
174	*/	174	*/
175	private static boolean isMethodCompatible(IDelta delta) {	175	private static boolean isMethodCompatible(IDelta delta) {
176	int restrictions = delta.getRestrictions();	176	int restrictions = delta.getCurrentRestrictions();
177	if (RestrictionModifiers.isReferenceRestriction(restrictions)) {	177	if (RestrictionModifiers.isReferenceRestriction(restrictions)) {
178	return true;	178	return true;
179	}	179	}
Lines 189-195 Link Here
189	switch(delta.getFlags()) {	189	switch(delta.getFlags()) {
190	case IDelta.TYPE_PARAMETER :	190	case IDelta.TYPE_PARAMETER :
191	case IDelta.RESTRICTIONS :	191	case IDelta.RESTRICTIONS :
192	return !Util.isVisible(delta.getNewModifiers());	192	if (Util.isVisible(delta.getNewModifiers())) {
		193	return RestrictionModifiers.isExtendRestriction(delta.getPreviousRestrictions());
		194	}
		195	return true;
193	}	196	}
194	break;	197	break;
195	case IDelta.CHANGED :	198	case IDelta.CHANGED :
Lines 219-225 Link Here
219	* @return true if compatible, false otherwise	222	* @return true if compatible, false otherwise
220	*/	223	*/
221	private static boolean isFieldCompatible(IDelta delta) {	224	private static boolean isFieldCompatible(IDelta delta) {
222	int restrictions = delta.getRestrictions();	225	int restrictions = delta.getCurrentRestrictions();
223	if (RestrictionModifiers.isReferenceRestriction(restrictions)) {	226	if (RestrictionModifiers.isReferenceRestriction(restrictions)) {
224	return true;	227	return true;
225	}	228	}
Lines 230-236 Link Here
230	switch(delta.getFlags()) {	233	switch(delta.getFlags()) {
231	case IDelta.VALUE :	234	case IDelta.VALUE :
232	if (Flags.isProtected(oldModifiers)) {	235	if (Flags.isProtected(oldModifiers)) {
233	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	236	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
234	}	237	}
235	if (Flags.isPublic(oldModifiers)) {	238	if (Flags.isPublic(oldModifiers)) {
236	return false;	239	return false;
Lines 249-255 Link Here
249	switch(delta.getFlags()) {	252	switch(delta.getFlags()) {
250	case IDelta.TYPE :	253	case IDelta.TYPE :
251	if (Flags.isProtected(newModifiers)) {	254	if (Flags.isProtected(newModifiers)) {
252	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	255	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
253	}	256	}
254	return !Util.isVisible(newModifiers);	257	return !Util.isVisible(newModifiers);
255	case IDelta.TYPE_ARGUMENT :	258	case IDelta.TYPE_ARGUMENT :
Lines 260-266 Link Here
260	case IDelta.VALUE :	263	case IDelta.VALUE :
261	case IDelta.FINAL_TO_NON_FINAL_STATIC_CONSTANT :	264	case IDelta.FINAL_TO_NON_FINAL_STATIC_CONSTANT :
262	if (Flags.isProtected(newModifiers)) {	265	if (Flags.isProtected(newModifiers)) {
263	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	266	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
264	}	267	}
265	if (Flags.isPublic(newModifiers)) {	268	if (Flags.isPublic(newModifiers)) {
266	return false;	269	return false;
Lines 268-274 Link Here
268	// not visible	271	// not visible
269	return true;	272	return true;
270	case IDelta.DECREASE_ACCESS :	273	case IDelta.DECREASE_ACCESS :
271	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	274	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
272	}	275	}
273	break;	276	break;
274	case IDelta.ADDED :	277	case IDelta.ADDED :
Lines 286-292 Link Here
286	* @return true if compatible, false otherwise	289	* @return true if compatible, false otherwise
287	*/	290	*/
288	private static boolean isConstructorCompatible(IDelta delta) {	291	private static boolean isConstructorCompatible(IDelta delta) {
289	int restrictions = delta.getRestrictions();	292	int restrictions = delta.getCurrentRestrictions();
290	if (RestrictionModifiers.isReferenceRestriction(restrictions)) {	293	if (RestrictionModifiers.isReferenceRestriction(restrictions)) {
291	return true;	294	return true;
292	}	295	}
Lines 380-386 Link Here
380	if (Util.isVisible(newModifiers)) {	383	if (Util.isVisible(newModifiers)) {
381	if (Flags.isAbstract(newModifiers)) {	384	if (Flags.isAbstract(newModifiers)) {
382	// case where the implementation is provided and the class cannot be instantiated by the client	385	// case where the implementation is provided and the class cannot be instantiated by the client
383	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	386	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
384	}	387	}
385	}	388	}
386	return true;	389	return true;
Lines 400-414 Link Here
400	return false;	403	return false;
401	}	404	}
402	if (Flags.isProtected(delta.getOldModifiers())) {	405	if (Flags.isProtected(delta.getOldModifiers())) {
403	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	406	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
404	}	407	}
405	return true;	408	return true;
406	case IDelta.CONSTRUCTOR :	409	case IDelta.CONSTRUCTOR :
407	case IDelta.API_CONSTRUCTOR :	410	case IDelta.API_CONSTRUCTOR :
408	if (Util.isVisible(delta.getOldModifiers())) {	411	if (Util.isVisible(delta.getOldModifiers())) {
409	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions())	412	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions())
410	&& (Flags.isProtected(delta.getOldModifiers()) \|\|	413	&& (Flags.isProtected(delta.getOldModifiers()) \|\|
411	RestrictionModifiers.isInstantiateRestriction(delta.getRestrictions()));	414	RestrictionModifiers.isInstantiateRestriction(delta.getCurrentRestrictions()));
412	}	415	}
413	return true;	416	return true;
414	case IDelta.TYPE_PARAMETER :	417	case IDelta.TYPE_PARAMETER :
Lines 420-426 Link Here
420	switch(delta.getFlags()) {	423	switch(delta.getFlags()) {
421	case IDelta.NON_ABSTRACT_TO_ABSTRACT :	424	case IDelta.NON_ABSTRACT_TO_ABSTRACT :
422	if (Util.isVisible(delta.getNewModifiers())) {	425	if (Util.isVisible(delta.getNewModifiers())) {
423	return RestrictionModifiers.isInstantiateRestriction(delta.getRestrictions());	426	return RestrictionModifiers.isInstantiateRestriction(delta.getCurrentRestrictions());
424	}	427	}
425	return true;	428	return true;
426	case IDelta.TYPE_CONVERSION :	429	case IDelta.TYPE_CONVERSION :
Lines 430-440 Link Here
430	return !Util.isVisible(delta.getNewModifiers());	433	return !Util.isVisible(delta.getNewModifiers());
431	case IDelta.NON_FINAL_TO_FINAL:	434	case IDelta.NON_FINAL_TO_FINAL:
432	if (Util.isVisible(delta.getNewModifiers())) {	435	if (Util.isVisible(delta.getNewModifiers())) {
433	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	436	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
434	}	437	}
435	return true;	438	return true;
436	case IDelta.DECREASE_ACCESS :	439	case IDelta.DECREASE_ACCESS :
437	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	440	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
438	}	441	}
439	break;	442	break;
440	}	443	}
Lines 481-490 Link Here
481	case IDelta.ADDED :	484	case IDelta.ADDED :
482	switch(delta.getFlags()) {	485	switch(delta.getFlags()) {
483	case IDelta.FIELD :	486	case IDelta.FIELD :
484	return RestrictionModifiers.isImplementRestriction(delta.getRestrictions());	487	return RestrictionModifiers.isImplementRestriction(delta.getCurrentRestrictions());
485	case IDelta.METHOD :	488	case IDelta.METHOD :
486	case IDelta.SUPER_INTERFACE_WITH_METHODS :	489	case IDelta.SUPER_INTERFACE_WITH_METHODS :
487	return RestrictionModifiers.isImplementRestriction(delta.getRestrictions());	490	return RestrictionModifiers.isImplementRestriction(delta.getCurrentRestrictions());
488	case IDelta.TYPE_PARAMETER :	491	case IDelta.TYPE_PARAMETER :
489	return false;	492	return false;
490	case IDelta.RESTRICTIONS :	493	case IDelta.RESTRICTIONS :
Lines 508-514 Link Here
508	case IDelta.TYPE_CONVERSION :	511	case IDelta.TYPE_CONVERSION :
509	return false;	512	return false;
510	case IDelta.DECREASE_ACCESS :	513	case IDelta.DECREASE_ACCESS :
511	return RestrictionModifiers.isExtendRestriction(delta.getRestrictions());	514	return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
512	}	515	}
513	break;	516	break;
514	}	517	}




/*******************************************************************************
 * Copyright (c) 2007, 2010 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

	public String[] getArguments();
	
	/**
	 * Returns the delta's current restrictions.
	 * 
	 * @return the delta's current restrictions
	 */
	public int getCurrentRestrictions();

	/**
	 * Returns the delta's previous restrictions.
	 * 
	 * @return the delta's previous restrictions
	 */
	public int getPreviousRestrictions();

	/**
	 * Returns the delta's new modifiers. This corresponds to the new modifiers of the affected element.

Lines 146-152 Link Here

(-)src_ant/org/eclipse/pde/api/tools/internal/tasks/ExcludeListDeltaVisitor.java (-1 / +1 lines)
146	break;	146	break;
147	}	147	}
148	}	148	}
149	} else if (Flags.isProtected(modifiers) && !RestrictionModifiers.isExtendRestriction(delta.getRestrictions())) {	149	} else if (Flags.isProtected(modifiers) && !RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions())) {
150	if ((this.flags & CHECK_DEPRECATION) != 0) {	150	if ((this.flags & CHECK_DEPRECATION) != 0) {
151	switch(delta.getFlags()) {	151	switch(delta.getFlags()) {
152	case IDelta.DEPRECATION :	152	case IDelta.DEPRECATION :

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/builder/tests/compatibility/ClassCompatibilityMethodTests.java (-1 / +20 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 IBM Corporation and others.	2	* Copyright (c) 2008, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 56-61 Link Here
56	*/	56	*/
57	public static Test suite() {	57	public static Test suite() {
58	return buildTestSuite(ClassCompatibilityMethodTests.class);	58	return buildTestSuite(ClassCompatibilityMethodTests.class);
		59	// junit.framework.TestSuite suite = new junit.framework.TestSuite();
		60	// suite.addTest(new ClassCompatibilityMethodTests("testAddNooverrideRemoveNoextendI"));
		61	// suite.addTest(new ClassCompatibilityMethodTests("testAddNooverrideRemoveNoextendF"));
		62	// return suite;
59	}	63	}
60		64
61	/* (non-Javadoc)	65	/* (non-Javadoc)
Lines 107-112 Link Here
107	xRemoveTwoPublicAPIMethods(false);	111	xRemoveTwoPublicAPIMethods(false);
108	}	112	}
109		113
		114	public void testAddNooverrideRemoveNoextendI() throws Exception {
		115	xAddNooverrideRemoveNoextendI(true);
		116	}
		117
		118	public void testAddNooverrideRemoveNoextendF() throws Exception {
		119	xAddNooverrideRemoveNoextendI(false);
		120	}
		121
		122	/**
		123	* Tests the removal of a public methods from an API class - incremental.
		124	*/
		125	private void xAddNooverrideRemoveNoextendI(boolean incremental) throws Exception {
		126	IPath filePath = WORKSPACE_CLASSES_PACKAGE_A.append("AddNooverrideRemoveNoextend.java");
		127	performCompatibilityTest(filePath, incremental);
		128	}
110	/**	129	/**
111	* Tests the removal of a public methods from an API class - incremental.	130	* Tests the removal of a public methods from an API class - incremental.
112	*/	131	*/




		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Has no extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertFalse("Extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		// implicit restrictions
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.CONSTRUCTOR, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("No extend restriction", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.CONSTRUCTOR, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertTrue("Not instantiate restrictions", RestrictionModifiers.isInstantiateRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.CONSTRUCTOR, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.REMOVED, child.getKind());
		assertFalse("Is extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertTrue("Not instantiate restrictions", RestrictionModifiers.isInstantiateRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.CONSTRUCTOR, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertTrue("No @noextend restriction", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertTrue("No @noextend restriction", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.ANNOTATION_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertTrue("No @noextend restriction", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertTrue("No @noextend restriction", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}




/*******************************************************************************
 * Copyright (c) 2007, 2010 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

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertTrue("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertTrue("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertTrue("Wrong restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertTrue("Wrong modifier", Flags.isProtected(child.getNewModifiers()));
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.INCREASE_ACCESS, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @noreferece restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
		child = allLeavesDeltas[1];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.NON_STATIC_TO_STATIC, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.STATIC_TO_NON_STATIC, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
		child = allLeavesDeltas[1];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.TYPE, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}




/*******************************************************************************
 * Copyright (c) 2007, 2010 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

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Should be compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Should not be compatible", !DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Should be compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Implement restrictions", !RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Method Add not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Method Add not compatible", !DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Method Add compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertFalse("Is implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertFalse("Is implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
		child = allLeavesDeltas[1];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Not implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertFalse("Is implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Is compatible", DeltaProcessor.isCompatible(child));
		child = allLeavesDeltas[1];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertFalse("Is implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.TYPE_MEMBER, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertFalse("Is implement restrictions", RestrictionModifiers.isImplementRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));




		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 1, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.INCREASE_ACCESS, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @noreferece restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not protected", Flags.isProtected(child.getNewModifiers()));
		assertTrue("Not @extend restriction", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.CONSTRUCTOR_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.CONSTRUCTOR_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.CONSTRUCTOR_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.CONSTRUCTOR_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.NON_STATIC_TO_STATIC, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.STATIC_TO_NON_STATIC, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
		assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertEquals("Wrong flag", IDelta.RESTRICTIONS, child.getFlags());
		assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @override restriction", RestrictionModifiers.isOverrideRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertFalse("Is compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertEquals("Wrong flag", IDelta.RESTRICTIONS, child.getFlags());
		assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
		assertTrue("Not @override restriction", RestrictionModifiers.isOverrideRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong element type", IDelta.METHOD_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
	}

		assertEquals("Wrong element type", IDelta.INTERFACE_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
		assertTrue("Not noextend", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
	}
}




/*******************************************************************************
 * Copyright (c) 2007, 2010 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

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));

		assertEquals("Wrong size", 2, allLeavesDeltas.length);
		IDelta child = allLeavesDeltas[0];
		assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
		assertTrue("Extend restrictions", !RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
		assertEquals("Wrong flag", IDelta.METHOD, child.getFlags());
		assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
		assertTrue("Not compatible", DeltaProcessor.isCompatible(child));




/*******************************************************************************
 * Copyright (c) 2010 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package a.classes.methods;

/**
 * @noextend This class is not intended to be subclassed by clients.
 */
public class AddNooverrideRemoveNoextend {
	
	public void methodOne() {
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package a.classes.methods;

public class AddNooverrideRemoveNoextend {
	
	/**
	 * @nooverride This method is not intended to be re-implemented or extended by clients.
	 */
	public void methodOne() {
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/actions/ActionMessages.java (-2 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 IBM Corporation and others.	2	* Copyright (c) 2008, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 55-61 Link Here
55	public static String PropertyKindKey;	55	public static String PropertyKindKey;
56	public static String PropertyNewModifiersKey;	56	public static String PropertyNewModifiersKey;
57	public static String PropertyOldModifiersKey;	57	public static String PropertyOldModifiersKey;
58	public static String PropertyRestrictionsKey;	58	public static String PropertyCurrentRestrictionsKey;
		59	public static String PropertyPreviousRestrictionsKey;
59	public static String PropertyTypeNameKey;	60	public static String PropertyTypeNameKey;
60		61
61	public static String MessageCategory;	62	public static String MessageCategory;




/*******************************************************************************
 * Copyright (c) 2009, 2010 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

		private static final Object ID_KIND = "IDelta.Kind"; //$NON-NLS-1$
		private static final Object ID_NEW_MODIFIERS = "IDelta.NewModifiers"; //$NON-NLS-1$
		private static final Object ID_OLD_MODIFIERS = "IDelta.OldModifiers"; //$NON-NLS-1$
		private static final Object ID_CURRENT_RESTRICTIONS = "IDelta.CurrentRestrictions"; //$NON-NLS-1$
		private static final Object ID_PREVIOUS_RESTRICTIONS = "IDelta.PreviousRestrictions"; //$NON-NLS-1$
		private static final Object ID_TYPENAME = "IDelta.TypeName"; //$NON-NLS-1$

		// categories

		public static final String P_KIND = ActionMessages.PropertyKindKey;
		public static final String P_NEW_MODIFIERS = ActionMessages.PropertyNewModifiersKey;
		public static final String P_OLD_MODIFIERS = ActionMessages.PropertyOldModifiersKey;
		public static final String P_CURRENT_RESTRICTIONS = ActionMessages.PropertyCurrentRestrictionsKey;
		public static final String P_PREVIOUS_RESTRICTIONS = ActionMessages.PropertyPreviousRestrictionsKey;
		public static final String P_TYPENAME = ActionMessages.PropertyTypeNameKey;

		private static List Descriptors;

			propertyDescriptor.setCategory(P_INFO_CATEGORY);
			Descriptors.add(propertyDescriptor);

			propertyDescriptor = new PropertyDescriptor(ID_CURRENT_RESTRICTIONS, P_CURRENT_RESTRICTIONS);
			propertyDescriptor.setCategory(P_INFO_CATEGORY);
			Descriptors.add(propertyDescriptor);

			propertyDescriptor = new PropertyDescriptor(ID_PREVIOUS_RESTRICTIONS, P_PREVIOUS_RESTRICTIONS);
			propertyDescriptor.setCategory(P_INFO_CATEGORY);
			Descriptors.add(propertyDescriptor);


			}
			if (ID_OLD_MODIFIERS.equals(propKey)) {
				return getDisplayedModifiers(delta.getOldModifiers());
			}
			if (ID_CURRENT_RESTRICTIONS.equals(propKey)) {
				int restrictions = delta.getCurrentRestrictions();
				return getDisplayRestrictions(restrictions);
			}
			if (ID_PREVIOUS_RESTRICTIONS.equals(propKey)) {
				int restrictions = delta.getPreviousRestrictions();
				return getDisplayRestrictions(restrictions);
			}
			if (ID_TYPENAME.equals(propKey)) {
				return delta.getTypeName();
			}
			return null;
		}
		private Object getDisplayRestrictions(int restrictions) {
			StringBuffer buffer = new StringBuffer(RestrictionModifiers.getRestrictionText(restrictions));
			buffer.append(" (0x").append(Integer.toHexString(restrictions)).append(')'); //$NON-NLS-1$
			return String.valueOf(buffer);
		}
		public boolean isPropertySet(Object id) {
			return false;
		}

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/actions/actionmessages.properties (-2 / +3 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2008, 2009 IBM Corporation and others.	2	# Copyright (c) 2008, 2010 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials	3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0	4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at	5	# which accompanies this distribution, and is available at
Lines 47-53 Link Here
47	PropertyKindKey=kind	47	PropertyKindKey=kind
48	PropertyNewModifiersKey=new modifiers	48	PropertyNewModifiersKey=new modifiers
49	PropertyOldModifiersKey=old modifiers	49	PropertyOldModifiersKey=old modifiers
50	PropertyRestrictionsKey=restrictions	50	PropertyCurrentRestrictionsKey=current restrictions
		51	PropertyPreviousRestrictionsKey=previous restrictions
51	PropertyTypeNameKey=type name	52	PropertyTypeNameKey=type name
52		53
53	MessageCategory=Message	54	MessageCategory=Message

Return to bug 324076

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/internal/provisional/comparator/IDelta.java (-4 / +11 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 IBM Corporation and others.	2	* Copyright (c) 2007, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 942-952 Link Here
942	public String[] getArguments();	942	public String[] getArguments();
943		943
944	/**	944	/**
945	* Returns the delta's restrictions.	945	* Returns the delta's current restrictions.
946	*	946	*
947	* @return the delta's restrictions	947	* @return the delta's current restrictions
948	*/	948	*/
949	public int getRestrictions();	949	public int getCurrentRestrictions();
		950
		951	/**
		952	* Returns the delta's previous restrictions.
		953	*
		954	* @return the delta's previous restrictions
		955	*/
		956	public int getPreviousRestrictions();
950		957
951	/**	958	/**
952	* Returns the delta's new modifiers. This corresponds to the new modifiers of the affected element.	959	* Returns the delta's new modifiers. This corresponds to the new modifiers of the affected element.

Lines 1-5 Link Here

(-)src/org/eclipse/pde/api/tools/comparator/tests/FieldDeltaTests.java (-16 / +16 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 IBM Corporation and others.	2	* Copyright (c) 2007, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 541-547 Link Here
541	IDelta child = allLeavesDeltas[0];	541	IDelta child = allLeavesDeltas[0];
542	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	542	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
543	assertTrue("Is visible", Util.isVisible(child.getNewModifiers()));	543	assertTrue("Is visible", Util.isVisible(child.getNewModifiers()));
544	assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getRestrictions()));	544	assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
545	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());	545	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
546	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	546	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
547	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	547	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
Lines 724-730 Link Here
724	IDelta child = allLeavesDeltas[0];	724	IDelta child = allLeavesDeltas[0];
725	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	725	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
726	assertTrue("Is visible", Util.isVisible(child.getNewModifiers()));	726	assertTrue("Is visible", Util.isVisible(child.getNewModifiers()));
727	assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getRestrictions()));	727	assertTrue("No extend restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
728	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());	728	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
729	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	729	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
730	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	730	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
Lines 930-936 Link Here
930	IDelta child = allLeavesDeltas[0];	930	IDelta child = allLeavesDeltas[0];
931	assertEquals("Wrong kind", IDelta.ADDED, child.getKind());	931	assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
932	assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());	932	assertEquals("Wrong flag", IDelta.FIELD, child.getFlags());
933	assertTrue("Wrong restrictions", RestrictionModifiers.isExtendRestriction(child.getRestrictions()));	933	assertTrue("Wrong restrictions", RestrictionModifiers.isExtendRestriction(child.getCurrentRestrictions()));
934	assertTrue("Wrong modifier", Flags.isProtected(child.getNewModifiers()));	934	assertTrue("Wrong modifier", Flags.isProtected(child.getNewModifiers()));
935	assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());	935	assertEquals("Wrong element type", IDelta.CLASS_ELEMENT_TYPE, child.getElementType());
936	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	936	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
Lines 1324-1330 Link Here
1324	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1324	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1325	assertEquals("Wrong flag", IDelta.INCREASE_ACCESS, child.getFlags());	1325	assertEquals("Wrong flag", IDelta.INCREASE_ACCESS, child.getFlags());
1326	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1326	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1327	assertTrue("Not @noreferece restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1327	assertTrue("Not @noreferece restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1328	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1328	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1329	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1329	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1330	}	1330	}
Lines 1391-1404 Link Here
1391	assertEquals("Wrong kind", IDelta.ADDED, child.getKind());	1391	assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
1392	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());	1392	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
1393	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1393	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1394	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1394	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1395	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1395	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1396	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1396	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1397	child = allLeavesDeltas[1];	1397	child = allLeavesDeltas[1];
1398	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1398	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1399	assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());	1399	assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());
1400	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1400	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1401	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1401	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1402	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1402	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1403	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1403	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1404	}	1404	}
Lines 1421-1427 Link Here
1421	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1421	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1422	assertEquals("Wrong flag", IDelta.NON_STATIC_TO_STATIC, child.getFlags());	1422	assertEquals("Wrong flag", IDelta.NON_STATIC_TO_STATIC, child.getFlags());
1423	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1423	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1424	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1424	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1425	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1425	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1426	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1426	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1427	}	1427	}
Lines 1444-1450 Link Here
1444	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1444	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1445	assertEquals("Wrong flag", IDelta.STATIC_TO_NON_STATIC, child.getFlags());	1445	assertEquals("Wrong flag", IDelta.STATIC_TO_NON_STATIC, child.getFlags());
1446	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1446	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1447	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1447	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1448	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1448	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1449	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1449	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1450	}	1450	}
Lines 1467-1480 Link Here
1467	assertEquals("Wrong kind", IDelta.ADDED, child.getKind());	1467	assertEquals("Wrong kind", IDelta.ADDED, child.getKind());
1468	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());	1468	assertEquals("Wrong flag", IDelta.VALUE, child.getFlags());
1469	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1469	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1470	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1470	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1471	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1471	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1472	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1472	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1473	child = allLeavesDeltas[1];	1473	child = allLeavesDeltas[1];
1474	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1474	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1475	assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());	1475	assertEquals("Wrong flag", IDelta.NON_FINAL_TO_FINAL, child.getFlags());
1476	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1476	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1477	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1477	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1478	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1478	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1479	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1479	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1480	}	1480	}
Lines 1497-1503 Link Here
1497	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1497	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1498	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());	1498	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
1499	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));	1499	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
1500	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1500	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1501	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1501	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1502	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1502	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1503	}	1503	}
Lines 1520-1526 Link Here
1520	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1520	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1521	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());	1521	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
1522	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));	1522	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
1523	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1523	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1524	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1524	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1525	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1525	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1526	}	1526	}
Lines 1543-1549 Link Here
1543	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1543	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1544	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());	1544	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
1545	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));	1545	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
1546	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1546	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1547	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1547	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1548	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1548	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1549	}	1549	}
Lines 1566-1572 Link Here
1566	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1566	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1567	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());	1567	assertEquals("Wrong flag", IDelta.DECREASE_ACCESS, child.getFlags());
1568	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));	1568	assertFalse("Is visible", Util.isVisible(child.getNewModifiers()));
1569	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1569	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1570	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1570	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1571	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1571	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1572	}	1572	}
Lines 1589-1595 Link Here
1589	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());	1589	assertEquals("Wrong kind", IDelta.CHANGED, child.getKind());
1590	assertEquals("Wrong flag", IDelta.TYPE, child.getFlags());	1590	assertEquals("Wrong flag", IDelta.TYPE, child.getFlags());
1591	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));	1591	assertTrue("Not visible", Util.isVisible(child.getNewModifiers()));
1592	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getRestrictions()));	1592	assertTrue("Not @reference restriction", RestrictionModifiers.isReferenceRestriction(child.getCurrentRestrictions()));
1593	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());	1593	assertEquals("Wrong element type", IDelta.FIELD_ELEMENT_TYPE, child.getElementType());
1594	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));	1594	assertTrue("Not compatible", DeltaProcessor.isCompatible(child));
1595	}	1595	}

Added Link Here

(-)test-builder/baseline/bundle.a/src/a/classes/methods/AddNooverrideRemoveNoextend.java (+20 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package a.classes.methods;
12
13	/**
14	* @noextend This class is not intended to be subclassed by clients.
15	*/
16	public class AddNooverrideRemoveNoextend {
17
18	public void methodOne() {
19	}
20	}

Added Link Here

(-)test-builder/compat/class/methods/AddNooverrideRemoveNoextend.java (+20 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package a.classes.methods;
12
13	public class AddNooverrideRemoveNoextend {
14
15	/**
16	* @nooverride This method is not intended to be re-implemented or extended by clients.
17	*/
18	public void methodOne() {
19	}
20	}