EMMA Coverage Report

EMMA Coverage Report (generated Thu Nov 26 15:54:18 CST 2009)
[all classes][org.eclipse.pde.api.tools.internal.comparator]

COVERAGE SUMMARY FOR SOURCE FILE [Messages.java]

name	class, %	method, %	block, %	line, %
Messages.java	100% (1/1)	80% (4/5)	87% (488/563)	84% (189.7/227)

COVERAGE BREAKDOWN BY CLASS AND METHOD

name	class, %	method, %	block, %	line, %

class Messages	100% (1/1)	80% (4/5)	87% (488/563)	84% (189.7/227)
Messages (): void		0% (0/1)	0% (0/3)	0% (0/2)
loadMessageTemplates (Locale): Hashtable		100% (1/1)	65% (41/63)	67% (10/15)
<static initializer>		100% (1/1)	70% (14/20)	90% (2.7/3)
getCompatibleLocalizedMessage (Delta): String		100% (1/1)	70% (28/40)	80% (8/10)
getKey (IDelta): int		100% (1/1)	93% (405/437)	86% (169/197)

1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 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 org.eclipse.pde.api.tools.internal.comparator;
12
13	import java.util.Enumeration;
14	import java.util.Hashtable;
15	import java.util.Locale;
16	import java.util.MissingResourceException;
17	import java.util.ResourceBundle;
18
19	import org.eclipse.jdt.core.Flags;
20	import org.eclipse.osgi.util.NLS;
21	import org.eclipse.pde.api.tools.internal.provisional.RestrictionModifiers;
22	import org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta;
23
24	import com.ibm.icu.text.MessageFormat;
25
26	/**
27	* Class that manages the messages for compatible deltas.
28	*/
29	public class Messages extends NLS {
30	/**
31	* The current mapping of problem id to message
32	*/
33	private static Hashtable fMessages = null;
34
35	public static String problem_message_not_found;
36
37	static {
38	// initialize resource bundle
39	NLS.initializeMessages("org.eclipse.pde.api.tools.internal.comparator.messages", Messages.class); //$NON-NLS-1$
40	}
41
42	private Messages() {
43	}
44
45	/**
46	* This method initializes the MessageTemplates class variable according
47	* to the current Locale.
48	* @param loc Locale
49	* @return HashtableOfInt
50	*/
51	public static Hashtable loadMessageTemplates(Locale loc) {
52	ResourceBundle bundle = null;
53	String bundleName = "org.eclipse.pde.api.tools.internal.comparator.compatible_delta_messages"; //$NON-NLS-1$
54	try {
55	bundle = ResourceBundle.getBundle(bundleName, loc);
56	} catch(MissingResourceException e) {
57	System.out.println("Missing resource : " + bundleName.replace('.', '/') + ".properties for locale " + loc); //$NON-NLS-1$//$NON-NLS-2$
58	throw e;
59	}
60	Hashtable templates = new Hashtable(700);
61	Enumeration keys = bundle.getKeys();
62	while (keys.hasMoreElements()) {
63	String key = (String)keys.nextElement();
64	try {
65	int messageID = Integer.parseInt(key);
66	templates.put(new Integer(messageID), bundle.getString(key));
67	} catch(NumberFormatException e) {
68	// key ill-formed
69	} catch (MissingResourceException e) {
70	// available ID
71	}
72	}
73	return templates;
74	}
75
76	public static String getCompatibleLocalizedMessage(Delta delta) {
77	if(fMessages == null) {
78	fMessages = loadMessageTemplates(Locale.getDefault());
79	}
80	Integer key = new Integer(getKey(delta));
81	String message = (String) fMessages.get(key);
82	if(message == null) {
83	return MessageFormat.format(Messages.problem_message_not_found, new String[] { String.valueOf(key)});
84	}
85	String[] arguments = delta.getArguments();
86	if (arguments.length != 0)
87	return MessageFormat.format(message, arguments);
88	return message;
89	}
90
91	private static int getKey(IDelta delta) {
92	switch(delta.getElementType()) {
93	case IDelta.ANNOTATION_ELEMENT_TYPE :
94	switch(delta.getKind()) {
95	case IDelta.ADDED :
96	switch(delta.getFlags()) {
97	case IDelta.METHOD_WITH_DEFAULT_VALUE :
98	return 1;
99	case IDelta.DEPRECATION :
100	return 110;
101	}
102	break;
103	case IDelta.CHANGED :
104	switch(delta.getFlags()) {
105	case IDelta.DECREASE_ACCESS :
106	return 101;
107	}
108	break;
109	case IDelta.REMOVED :
110	switch(delta.getFlags()) {
111	case IDelta.DEPRECATION :
112	return 111;
113	}
114	break;
115	}
116	break;
117	case IDelta.API_COMPONENT_ELEMENT_TYPE :
118	switch(delta.getKind()) {
119	case IDelta.ADDED :
120	switch(delta.getFlags()) {
121	case IDelta.EXECUTION_ENVIRONMENT :
122	return 2;
123	case IDelta.TYPE :
124	return 3;
125	case IDelta.REEXPORTED_TYPE :
126	return 109;
127	}
128	break;
129	case IDelta.CHANGED :
130	switch(delta.getFlags()) {
131	case IDelta.TYPE_VISIBILITY : return 4;
132	case IDelta.MAJOR_VERSION : return 95;
133	case IDelta.MINOR_VERSION : return 96;
134	}
135	break;
136	case IDelta.REMOVED :
137	if (delta.getFlags() == IDelta.EXECUTION_ENVIRONMENT) {
138	return 5;
139	}
140	}
141	break;
142	case IDelta.API_PROFILE_ELEMENT_TYPE :
143	switch(delta.getKind()) {
144	case IDelta.ADDED :
145	if (delta.getFlags() == IDelta.API_COMPONENT) {
146	return 6;
147	}
148	}
149	break;
150	case IDelta.CLASS_ELEMENT_TYPE :
151	switch(delta.getKind()) {
152	case IDelta.ADDED :
153	switch(delta.getFlags()) {
154	case IDelta.DEPRECATION :
155	return 110;
156	case IDelta.CLINIT :
157	return 7;
158	case IDelta.CONSTRUCTOR :
159	return 8;
160	case IDelta.FIELD :
161	if (Flags.isProtected(delta.getNewModifiers())) {
162	return 9;
163	}
164	if (Flags.isStatic(delta.getNewModifiers())) {
165	return 10;
166	}
167	if (Flags.isPublic(delta.getNewModifiers())) {
168	return 11;
169	}
170	return 80;
171	case IDelta.METHOD :
172	if (!Flags.isAbstract(delta.getNewModifiers())) {
173	return 12;
174	}
175	return 13;
176	case IDelta.OVERRIDEN_METHOD :
177	return 14;
178	case IDelta.SUPERCLASS :
179	return 15;
180	case IDelta.TYPE_MEMBER :
181	return 16;
182	case IDelta.TYPE_PARAMETERS :
183	return 17;
184	case IDelta.METHOD_MOVED_DOWN :
185	return 97;
186	case IDelta.RESTRICTIONS :
187	return 108;
188	}
189	break;
190	case IDelta.CHANGED :
191	switch(delta.getFlags()) {
192	case IDelta.ABSTRACT_TO_NON_ABSTRACT :
193	return 19;
194	case IDelta.EXPANDED_SUPERINTERFACES_SET :
195	return 21;
196	case IDelta.FINAL_TO_NON_FINAL :
197	return 22;
198	case IDelta.INCREASE_ACCESS :
199	return 23;
200	case IDelta.NON_FINAL_TO_FINAL :
201	return 94;
202	case IDelta.DECREASE_ACCESS :
203	return 101;
204	case IDelta.NON_ABSTRACT_TO_ABSTRACT :
205	return 105;
206	}
207	break;
208	case IDelta.REMOVED :
209	switch(delta.getFlags()) {
210	case IDelta.DEPRECATION :
211	return 111;
212	case IDelta.CLINIT :
213	return 25;
214	case IDelta.CONSTRUCTOR :
215	case IDelta.API_CONSTRUCTOR :
216	return 26;
217	case IDelta.FIELD_MOVED_UP :
218	return 27;
219	case IDelta.FIELD :
220	case IDelta.API_FIELD :
221	if (Flags.isProtected(delta.getOldModifiers())) {
222	return 28;
223	}
224	return 29;
225	case IDelta.METHOD_MOVED_UP :
226	return 30;
227	case IDelta.METHOD :
228	case IDelta.API_METHOD :
229	if (Flags.isProtected(delta.getOldModifiers())) {
230	return 31;
231	}
232	return 32;
233	case IDelta.TYPE_MEMBER :
234	if (Flags.isProtected(delta.getOldModifiers())) {
235	return 33;
236	}
237	return 34;
238	}
239	break;
240	}
241	break;
242	case IDelta.ENUM_ELEMENT_TYPE :
243	switch(delta.getKind()) {
244	case IDelta.ADDED :
245	switch(delta.getFlags()) {
246	case IDelta.CONSTRUCTOR :
247	return 35;
248	case IDelta.ENUM_CONSTANT :
249	return 36;
250	case IDelta.METHOD :
251	return 37;
252	case IDelta.DEPRECATION :
253	return 110;
254	}
255	break;
256	case IDelta.REMOVED :
257	switch(delta.getFlags()) {
258	case IDelta.CONSTRUCTOR :
259	case IDelta.API_CONSTRUCTOR :
260	return 38;
261	case IDelta.DEPRECATION :
262	return 111;
263	}
264	break;
265	case IDelta.CHANGED :
266	switch(delta.getFlags()) {
267	case IDelta.DECREASE_ACCESS :
268	return 101;
269	}
270	}
271	break;
272	case IDelta.FIELD_ELEMENT_TYPE :
273	switch(delta.getKind()) {
274	case IDelta.ADDED :
275	switch(delta.getFlags()) {
276	case IDelta.TYPE_ARGUMENTS :
277	return 18;
278	case IDelta.VALUE :
279	return 40;
280	case IDelta.DEPRECATION :
281	return 110;
282	}
283	break;
284	case IDelta.CHANGED :
285	switch(delta.getFlags()) {
286	case IDelta.FINAL_TO_NON_FINAL_NON_STATIC :
287	return 41;
288	case IDelta.FINAL_TO_NON_FINAL_STATIC_CONSTANT :
289	if (Flags.isProtected(delta.getNewModifiers())) {
290	return 42;
291	}
292	return 43;
293	case IDelta.FINAL_TO_NON_FINAL_STATIC_NON_CONSTANT :
294	return 44;
295	case IDelta.INCREASE_ACCESS :
296	return 45;
297	case IDelta.NON_FINAL_TO_FINAL :
298	return 46;
299	case IDelta.NON_TRANSIENT_TO_TRANSIENT :
300	return 47;
301	case IDelta.TRANSIENT_TO_NON_TRANSIENT :
302	return 48;
303	case IDelta.VALUE :
304	if (Flags.isProtected(delta.getNewModifiers())) {
305	return 50;
306	}
307	return 51;
308	case IDelta.TYPE :
309	return 78;
310	case IDelta.NON_VOLATILE_TO_VOLATILE :
311	return 92;
312	case IDelta.VOLATILE_TO_NON_VOLATILE :
313	return 93;
314	case IDelta.DECREASE_ACCESS :
315	return 98;
316	case IDelta.NON_STATIC_TO_STATIC :
317	return 103;
318	case IDelta.STATIC_TO_NON_STATIC :
319	return 104;
320	}
321	break;
322	case IDelta.REMOVED :
323	switch(delta.getFlags()) {
324	case IDelta.VALUE :
325	if (Flags.isProtected(delta.getNewModifiers())) {
326	return 52;
327	}
328	return 53;
329	case IDelta.DEPRECATION :
330	return 111;
331	}
332	}
333	break;
334	case IDelta.TYPE_PARAMETER_ELEMENT_TYPE :
335	if (delta.getKind() == IDelta.CHANGED && delta.getFlags() == IDelta.TYPE_PARAMETER_NAME) {
336	return 24;
337	}
338	break;
339	case IDelta.INTERFACE_ELEMENT_TYPE :
340	switch(delta.getKind()) {
341	case IDelta.ADDED :
342	switch(delta.getFlags()) {
343	case IDelta.DEPRECATION :
344	return 110;
345	case IDelta.FIELD :
346	return 54;
347	case IDelta.METHOD :
348	return 55;
349	case IDelta.TYPE_MEMBER :
350	return 56;
351	case IDelta.OVERRIDEN_METHOD :
352	return 57;
353	case IDelta.TYPE_PARAMETERS :
354	return 58;
355	case IDelta.METHOD_MOVED_DOWN :
356	return 97;
357	case IDelta.SUPER_INTERFACE_WITH_METHODS :
358	return 107;
359	}
360	break;
361	case IDelta.CHANGED :
362	switch(delta.getFlags()) {
363	case IDelta.EXPANDED_SUPERINTERFACES_SET :
364	return 79;
365	case IDelta.DECREASE_ACCESS :
366	return 101;
367	}
368	break;
369	case IDelta.REMOVED :
370	switch(delta.getFlags()) {
371	case IDelta.FIELD_MOVED_UP :
372	return 60;
373	case IDelta.METHOD_MOVED_UP :
374	return 61;
375	case IDelta.DEPRECATION :
376	return 111;
377	}
378	}
379	break;
380	case IDelta.METHOD_ELEMENT_TYPE :
381	switch(delta.getKind()) {
382	case IDelta.ADDED :
383	switch(delta.getFlags()) {
384	case IDelta.DEPRECATION :
385	return 110;
386	case IDelta.ANNOTATION_DEFAULT_VALUE :
387	return 62;
388	case IDelta.CHECKED_EXCEPTION :
389	return 63;
390	case IDelta.TYPE_PARAMETERS :
391	return 64;
392	case IDelta.UNCHECKED_EXCEPTION :
393	return 65;
394	case IDelta.TYPE_ARGUMENTS :
395	return 18;
396	case IDelta.RESTRICTIONS :
397	return 106;
398	}
399	break;
400	case IDelta.CHANGED :
401	switch(delta.getFlags()) {
402	case IDelta.ABSTRACT_TO_NON_ABSTRACT :
403	return 66;
404	case IDelta.ANNOTATION_DEFAULT_VALUE :
405	return 67;
406	case IDelta.ARRAY_TO_VARARGS :
407	return 68;
408	case IDelta.FINAL_TO_NON_FINAL :
409	return 69;
410	case IDelta.INCREASE_ACCESS :
411	return 70;
412	case IDelta.NATIVE_TO_NON_NATIVE :
413	return 71;
414	case IDelta.NON_NATIVE_TO_NATIVE :
415	return 72;
416	case IDelta.NON_SYNCHRONIZED_TO_SYNCHRONIZED :
417	return 73;
418	case IDelta.SYNCHRONIZED_TO_NON_SYNCHRONIZED :
419	return 74;
420	case IDelta.NON_FINAL_TO_FINAL :
421	if (RestrictionModifiers.isExtendRestriction(delta.getRestrictions())) {
422	return 81;
423	}
424	if (RestrictionModifiers.isOverrideRestriction(delta.getRestrictions())) {
425	return 82;
426	}
427	return 83;
428	case IDelta.NON_STATIC_TO_STATIC :
429	return 84;
430	case IDelta.DECREASE_ACCESS :
431	return 99;
432	case IDelta.STATIC_TO_NON_STATIC :
433	return 102;
434	}
435	break;
436	case IDelta.REMOVED :
437	switch(delta.getFlags()) {
438	case IDelta.CHECKED_EXCEPTION :
439	return 76;
440	case IDelta.UNCHECKED_EXCEPTION :
441	return 77;
442	case IDelta.DEPRECATION :
443	return 111;
444	}
445	}
446	break;
447	case IDelta.CONSTRUCTOR_ELEMENT_TYPE :
448	switch(delta.getKind()) {
449	case IDelta.ADDED :
450	switch(delta.getFlags()) {
451	case IDelta.DEPRECATION :
452	return 110;
453	case IDelta.CHECKED_EXCEPTION :
454	return 85;
455	case IDelta.TYPE_PARAMETERS :
456	return 64;
457	case IDelta.UNCHECKED_EXCEPTION :
458	return 86;
459	case IDelta.TYPE_ARGUMENTS :
460	return 18;
461	}
462	break;
463	case IDelta.CHANGED :
464	switch(delta.getFlags()) {
465	case IDelta.ARRAY_TO_VARARGS :
466	return 87;
467	case IDelta.INCREASE_ACCESS :
468	return 89;
469	case IDelta.DECREASE_ACCESS :
470	return 100;
471	}
472	break;
473	case IDelta.REMOVED :
474	switch(delta.getFlags()) {
475	case IDelta.CHECKED_EXCEPTION :
476	return 90;
477	case IDelta.UNCHECKED_EXCEPTION :
478	return 91;
479	case IDelta.DEPRECATION :
480	return 111;
481	}
482	}
483	break;
484	}
485	return 0;
486	}
487	}

[all classes][org.eclipse.pde.api.tools.internal.comparator]

EMMA 2.0.5312 EclEmma Fix 1 (C) Vladimir Roubtsov