Classes

Class	Line #	Total Statements	Complexity	Uncovered Elements	TOTAL Coverage	Actions
InputType	47	59	31	66	0.3831775838.3%	Show methods
InputType.molType	57	4	1	5	0.00%	Show methods

Class InputType

Class InputType	Line # 47	Total Statements 59	Complexity 31	Uncovered Elements 66	TOTAL Coverage 0.3831775838.3%
InputType(Class[])   InputType(Class[])	8686	3.03	2.02	1.01	0.8 0.880%
validFor(RestJob) : boolean   validFor(RestJob) : boolean	104104	6.06	3.03	4.04	0.6 0.660%
validFor(RestServiceDescription) : boolean   validFor(RestServiceDescription) : boolean	118118	3.03	2.02	2.02	0.6 0.660%
utf8StringBody(String,String) : ContentBody   utf8StringBody(String,String) : ContentBody	126126	8.08	3.03	10.010	0.0 0.00%
isConstant() : boolean   isConstant() : boolean	163163	1.01	1.01	0.00	1.0 1.0100%
configureFromURLtokenString(List<String>,StringBuffer) : boolean   configureFromURLtokenString(List<String>,StringBuffer) : boolean	209209	18.018	7.07	12.012	0.5714286 0.571428657.1%
addBaseParams(ArrayList<String>) : void   addBaseParams(ArrayList<String>) : void	255255	4.04	3.03	3.03	0.625 0.62562.5%
getBaseOptions() : List<OptionI>   getBaseOptions() : List<OptionI>	271271	4.04	1.01	4.04	0.0 0.00%
configureFromArgumentI(List<ArgumentI>) : void   configureFromArgumentI(List<ArgumentI>) : void	295295	11.011	6.06	21.021	0.0 0.00%
createMolTypeOption(String,String,boolean,molType,molType) : OptionI   createMolTypeOption(String,String,boolean,molType,molType) : OptionI	328328	1.01	3.03	5.05	0.0 0.00%

 

Class InputType.molType

Class InputType.molType	Line # 57	Total Statements 4	Complexity 1	Uncovered Elements 5	TOTAL Coverage 0.00%
toStringValues() : Collection<String>   toStringValues() : Collection<String>	6161	4.04	1.01	4.04	0.0 0.00%

 

Contributing tests

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.ws.rest;
22
23		import jalview.ws.params.ArgumentI;
24		import jalview.ws.params.InvalidArgumentException;
25		import jalview.ws.params.OptionI;
26		import jalview.ws.params.ParameterI;
27		import jalview.ws.params.simple.IntegerParameter;
28		import jalview.ws.params.simple.Option;
29
30		import java.io.UnsupportedEncodingException;
31		import java.nio.charset.Charset;
32		import java.util.ArrayList;
33		import java.util.Collection;
34		import java.util.List;
35		import java.util.regex.Matcher;
36		import java.util.regex.Pattern;
37
38		import org.apache.http.entity.mime.content.ContentBody;
39		import org.apache.http.entity.mime.content.StringBody;
40
41		/***
42		* InputType is the abstract model of each input parameter that a rest service
43		* might take. It enables the engine to validate input by providing { formatter
44		* for type, parser for type }
45		*
46		*/
		38.3% Uncovered Elements: 66 (107) Complexity: 31 Complexity Density: 0.53
47		public abstract class InputType
48		{
49		private static final Pattern URL_PATTERN = Pattern
50		.compile("^([^=]+)=?'?([^']*)?'?");
51
52		/**
53		* not used yet
54		*/
55		boolean replaceids;
56
		0% Uncovered Elements: 5 (5) Complexity: 1 Complexity Density: 0.25
57		public enum molType
58		{
59		NUC, PROT, MIX;
60
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
61	0	public static Collection<String> toStringValues()...
62		{
63	0	Collection<String> c = new ArrayList<String>();
64	0	for (molType type : values())
65		{
66	0	c.add(type.toString());
67		}
68	0	return c;
69		}
70		}
71
72		public String token;
73
74		public int min = 1;
75
76		public int max = 0; // unbounded
77
78		protected ArrayList<Class> inputData = new ArrayList<Class>();
79
80		/**
81		* initialise the InputType with a list of jalview data classes that the
82		* RestJob needs to be able to provide to it.
83		*
84		* @param types
85		*/
		80% Uncovered Elements: 1 (5) Complexity: 2 Complexity Density: 0.67
86	4430	protected InputType(Class[] types)...
87		{
88	4430	if (types != null)
89		{
90	4430	for (Class t : types)
91		{
92	4430	inputData.add(t);
93		}
94		}
95		}
96
97		/**
98		* do basic tests to ensure the job's service takes this parameter, and the
99		* job's input data can be used to generate the input data
100		*
101		* @param restJob
102		* @return
103		*/
		60% Uncovered Elements: 4 (10) Complexity: 3 Complexity Density: 0.5
104	2	public boolean validFor(RestJob restJob)...
105		{
106	2	if (!validFor(restJob.rsd))
107	0	return false;
108	2	for (Class cl : inputData)
109		{
110	2	if (!restJob.hasDataOfType(cl))
111		{
112	0	return false;
113		}
114		}
115	2	return true;
116		}
117
		60% Uncovered Elements: 2 (5) Complexity: 2 Complexity Density: 0.67
118	2	public boolean validFor(RestServiceDescription restServiceDescription)...
119		{
120	2	if (!restServiceDescription.inputParams.values().contains(this))
121	0	return false;
122
123	2	return true;
124		}
125
		0% Uncovered Elements: 10 (10) Complexity: 3 Complexity Density: 0.38
126	0	protected ContentBody utf8StringBody(String content, String type)...
127		{
128	0	Charset utf8 = Charset.forName("UTF-8");
129	0	try
130		{
131	0	if (type == null)
132		{
133	0	return new StringBody(
134		utf8.encode(content).asCharBuffer().toString());
135		}
136		else
137		{
138	0	return new StringBody(
139		utf8.encode(content).asCharBuffer().toString(), type, utf8);
140		}
141		} catch (Exception ex)
142		{
143	0	System.err.println("Couldn't transform string\n" + content
144		+ "\nException was :");
145	0	ex.printStackTrace(System.err);
146		}
147	0	return null;
148		}
149
150		/**
151		*
152		* @param rj
153		* data from which input is to be extracted and formatted
154		* @return StringBody or FileBody ready for posting
155		*/
156		abstract public ContentBody formatForInput(RestJob rj)
157		throws UnsupportedEncodingException, NoValidInputDataException;
158
159		/**
160		*
161		* @return true if no input data needs to be provided for this parameter
162		*/
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
163	26	public boolean isConstant()...
164		{
165	26	return (inputData == null || inputData.size() == 0);
166		}
167
168		/**
169		* return a url encoded version of this parameter's value, or an empty string
170		* if the parameter has no ='value' content.
171		*
172		* @return
173		*/
174		public abstract List<String> getURLEncodedParameter();
175
176		/**
177		* set the property known as tok, possibly by assigning it with a given val
178		*
179		* @param tok
180		* @param val
181		* (may be empty or null)
182		* @param warnings
183		* place where parse warnings are reported
184		* @return true if property was set
185		*/
186		public abstract boolean configureProperty(String tok, String val,
187		StringBuffer warnings);
188
189		/**
190		* Get unique key for this type of parameter in a URL encoding.
191		*
192		* @return the string that prefixes an input parameter of InputType<T> type in
193		* the string returned from getURLEncodedParameter
194		*/
195		public abstract String getURLtokenPrefix();
196
197		/**
198		* parse the given token String and set InputParameter properties
199		* appropriately
200		*
201		* @param tokenstring
202		* - urlencoded parameter string as returned from
203		* getURLEncodedParameter
204		* @param warnings
205		* - place where any warning messages about bad property values are
206		* written
207		* @return true if configuration succeeded, false otherwise.
208		*/
		57.1% Uncovered Elements: 12 (28) Complexity: 7 Complexity Density: 0.39
209	2212	public boolean configureFromURLtokenString(List<String> tokenstring,...
210		StringBuffer warnings)
211		{
212	2212	boolean valid = true;
213	2212	for (String tok : tokenstring)
214		{
215	5530	Matcher mtch = URL_PATTERN.matcher(tok);
216	5530	if (mtch.find())
217		{
218	5530	try
219		{
220	5530	if (mtch.group(1).equals("min"))
221		{
222	1106	min = Integer.parseInt(mtch.group(2));
223	1106	continue;
224
225		}
226	4424	else if (mtch.group(1).equals("max"))
227		{
228	0	max = Integer.parseInt(mtch.group(2));
229	0	continue;
230		}
231		} catch (NumberFormatException x)
232		{
233	0	valid = false;
234	0	warnings.append("Invalid value for parameter "
235		+ mtch.group(1).toLowerCase() + " '" + mtch.group(2)
236		+ "' (expected an integer)\n");
237		}
238
239	4424	if (!configureProperty(mtch.group(1), mtch.group(2), warnings))
240		{
241	0	if (warnings.length() == 0)
242		{
243	0	warnings.append("Failed to configure InputType :"
244		+ getURLtokenPrefix() + " with property string: '"
245		+ mtch.group(0) + "'\n (token is '" + mtch.group(1)
246		+ "' and value is '" + mtch.group(2) + "')\n");
247		}
248	0	valid = false;
249		}
250		}
251		}
252	2212	return valid;
253		}
254
		62.5% Uncovered Elements: 3 (8) Complexity: 3 Complexity Density: 0.75
255	10	public void addBaseParams(ArrayList<String> prms)...
256		{
257		// todo : check if replaceids should be a global for the service, rather
258		// than for a specific parameter.
259	10	if (min != 1)
260		{
261	10	prms.add("min='" + min + "'");
262		}
263	10	if (max != 0)
264		{
265	0	prms.add("max='" + max + "'");
266		}
267		}
268
269		public abstract List<OptionI> getOptions();
270
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
271	0	public List<OptionI> getBaseOptions()...
272		{
273	0	ArrayList<OptionI> opts = new ArrayList<OptionI>();
274	0	opts.add(new IntegerParameter("min",
275		"Minimum number of data of this type", true, 1, min, 0, -1));
276	0	opts.add(new IntegerParameter("max",
277		"Maximum number of data of this type", false, 0, max, 0, -1));
278	0	return opts;
279		}
280
281		/**
282		* make a copy of this InputType
283		*
284		* @return may not be needed public abstract InputType copy();
285		*/
286
287		/**
288		* parse a set of configuration options
289		*
290		* @param currentSettings
291		* - modified settings originally from getOptions
292		* @throws InvalidArgumentException
293		* thrown if currentSettings contains invalid options for this type.
294		*/
		0% Uncovered Elements: 21 (21) Complexity: 6 Complexity Density: 0.55
295	0	public void configureFromArgumentI(List<ArgumentI> currentSettings)...
296		throws InvalidArgumentException
297		{
298	0	ArrayList<String> urltoks = new ArrayList<String>();
299	0	String rg;
300	0	for (ArgumentI arg : currentSettings)
301		{
302	0	if (arg instanceof ParameterI)
303		{
304	0	rg = arg.getName() + "='" + arg.getValue() + "'";
305		}
306		else
307		{
308		// TODO: revise architecture - this is counter intuitive - options with
309		// different values to their names are actually parameters
310	0	rg = (arg.getValue().length() > 0)
311	0	? (arg.getValue().equals(arg.getName()) ? arg.getName()
312		: arg.getName() + "='" + arg.getValue() + "'")
313		: arg.getName();
314		}
315	0	if (rg.length() > 0)
316		{
317	0	urltoks.add(rg);
318		}
319		}
320	0	StringBuffer warnings;
321	0	if (!configureFromURLtokenString(urltoks,
322		warnings = new StringBuffer()))
323		{
324	0	throw new InvalidArgumentException(warnings.toString());
325		}
326		}
327
		0% Uncovered Elements: 5 (5) Complexity: 3 Complexity Density: 3
328	0	protected OptionI createMolTypeOption(String name, String descr,...
329		boolean req, molType curType, molType defType)
330		{
331	0	return new Option(name, descr, req,
332	0	defType == null ? "" : defType.toString(),
333	0	curType == null ? "" : curType.toString(),
334		molType.toStringValues(), null);
335		}
336		}