Coverage Report

 package com.lexicalscope.jewel.cli;
 
 import java.util.List;
 
 import com.lexicalscope.jewel.JewelRuntimeException;
 import com.lexicalscope.jewel.cli.specification.OptionSpecification;
 import com.lexicalscope.jewel.cli.specification.SpecificationMultiplicity;
 
 
 /*
  * Copyright 2011 Tim Wood
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 class ValidationFailureWrongNumberOfValues extends ValidationFailureImpl
 {
     private static final long serialVersionUID = -7899339429456035393L;
     private final OptionSpecification specification;
     private final List<String> values;
 
     public ValidationFailureWrongNumberOfValues(final OptionSpecification specification, final List<String> values) {
         super(specification, formatMessage(specification, values));
         this.specification = specification;
         this.values = values;
     }
 
     private static String formatMessage(final OptionSpecification specification, final List<String> values) {
         return specification.compareCountToSpecification(values.size(), new SpecificationMultiplicity<String>(){
             @Override public String expectedNoneGotSome() {
                 if(values.size() == 1)
                 {
                     return String.format(ArgumentValidationException.m_messages.getString("validationError.UnexpectedValue"), values.get(0));
                 }
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.UnexpectedValues"), values);
             }
 
             @Override public String expectedOneGotNone() {
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.MissingValue"));
             }
 
             @Override public String expectedOneGotSome() {
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.AdditionalValue"), values.subList(1, values.size()));
             }
 
             @Override public String expectedExactGotTooFew(final int exactly, final int valueCount) {
                 if(exactly == 1)
                 {
                     return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValueThanExactly"), exactly, values);
                 }
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValuesThanExactly"), exactly, values);
             }
 
             @Override public String expectedExactGotTooMany(final int exactly, final int valueCount) {
                 final List<String> subList = values.subList(exactly, values.size());
                 if(exactly == 1) {
                     return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValueThanExactly"), exactly, subList);
                 }
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValuesThanExactly"), exactly, subList);
             }
 
             @Override public String expectedMinimumGotTooFew(final int minimum, final int valueCount) {
                 if(minimum == 1) {
                     return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValueThanMinimum"), minimum, values);
                 }
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValuesThanMinimum"), minimum, values);
             }
 
             @Override public String expectedMaximumGotTooMany(final int maximum, final int valueCount) {
                 final List<String> subList = values.subList(maximum, values.size());
                 if(maximum == 1) {
                     return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValueThanMaximum"), maximum, subList);
                 }
                 return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValuesThanMaximum"), maximum, subList);
             }
 
             @Override public String allowed() {
                 throw new JewelRuntimeException("unable to determine why the number of values is wrong " + specification + " with values (" + values.size() + ")");
             }});
     }
 
     @Override public ValidationFailureType getFailureType() {
         return specification.compareCountToSpecification(values.size(), new SpecificationMultiplicity<ValidationFailureType>(){
             @Override public ValidationFailureType expectedNoneGotSome() {
                 return ValidationFailureType.UnexpectedValue;
             }
 
             @Override public ValidationFailureType expectedOneGotNone() {
                 return ValidationFailureType.MissingValue;
             }
 
             @Override public ValidationFailureType expectedOneGotSome() {
                 return ValidationFailureType.UnexpectedAdditionalValue;
             }
 
             @Override public ValidationFailureType expectedExactGotTooFew(final int exactly, final int valueCount) {
                 return ValidationFailureType.TooFewValues;
             }
 
             @Override public ValidationFailureType expectedExactGotTooMany(final int exactly, final int valueCount) {
                 return ValidationFailureType.TooManyValues;
             }
 
             @Override public ValidationFailureType expectedMinimumGotTooFew(final int minimum, final int valueCount) {
                 return ValidationFailureType.TooFewValues;
             }
 
             @Override public ValidationFailureType expectedMaximumGotTooMany(final int maximum, final int valueCount) {
                 return ValidationFailureType.TooManyValues;
             }
 
             @Override public ValidationFailureType allowed() {
                 throw new JewelRuntimeException("unable to determine why the number of values is wrong " + specification + " with values (" + values.size() + ")");
             }});
     }
 }

1		package com.lexicalscope.jewel.cli;
2
3		import java.util.List;
4
5		import com.lexicalscope.jewel.JewelRuntimeException;
6		import com.lexicalscope.jewel.cli.specification.OptionSpecification;
7		import com.lexicalscope.jewel.cli.specification.SpecificationMultiplicity;
8
9
10		/*
11		* Copyright 2011 Tim Wood
12		*
13		* Licensed under the Apache License, Version 2.0 (the "License");
14		* you may not use this file except in compliance with the License.
15		* You may obtain a copy of the License at
16		*
17		* http://www.apache.org/licenses/LICENSE-2.0
18		*
19		* Unless required by applicable law or agreed to in writing, software
20		* distributed under the License is distributed on an "AS IS" BASIS,
21		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22		* See the License for the specific language governing permissions and
23		* limitations under the License.
24		*/
25
26	0	class ValidationFailureWrongNumberOfValues extends ValidationFailureImpl
27		{
28		private static final long serialVersionUID = -7899339429456035393L;
29		private final OptionSpecification specification;
30		private final List<String> values;
31
32		public ValidationFailureWrongNumberOfValues(final OptionSpecification specification, final List<String> values) {
33	34	super(specification, formatMessage(specification, values));
34	34	this.specification = specification;
35	34	this.values = values;
36	34	}
37
38		private static String formatMessage(final OptionSpecification specification, final List<String> values) {
39	34	return specification.compareCountToSpecification(values.size(), new SpecificationMultiplicity<String>(){
40		@Override public String expectedNoneGotSome() {
41	6	if(values.size() == 1)
42		{
43	4	return String.format(ArgumentValidationException.m_messages.getString("validationError.UnexpectedValue"), values.get(0));
44		}
45	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.UnexpectedValues"), values);
46		}
47
48		@Override public String expectedOneGotNone() {
49	6	return String.format(ArgumentValidationException.m_messages.getString("validationError.MissingValue"));
50		}
51
52		@Override public String expectedOneGotSome() {
53	10	return String.format(ArgumentValidationException.m_messages.getString("validationError.AdditionalValue"), values.subList(1, values.size()));
54		}
55
56		@Override public String expectedExactGotTooFew(final int exactly, final int valueCount) {
57	0	if(exactly == 1)
58		{
59	0	return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValueThanExactly"), exactly, values);
60		}
61	0	return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValuesThanExactly"), exactly, values);
62		}
63
64		@Override public String expectedExactGotTooMany(final int exactly, final int valueCount) {
65	4	final List<String> subList = values.subList(exactly, values.size());
66	4	if(exactly == 1) {
67	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValueThanExactly"), exactly, subList);
68		}
69	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValuesThanExactly"), exactly, subList);
70		}
71
72		@Override public String expectedMinimumGotTooFew(final int minimum, final int valueCount) {
73	4	if(minimum == 1) {
74	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValueThanMinimum"), minimum, values);
75		}
76	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValuesThanMinimum"), minimum, values);
77		}
78
79		@Override public String expectedMaximumGotTooMany(final int maximum, final int valueCount) {
80	4	final List<String> subList = values.subList(maximum, values.size());
81	4	if(maximum == 1) {
82	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValueThanMaximum"), maximum, subList);
83		}
84	2	return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValuesThanMaximum"), maximum, subList);
85		}
86
87		@Override public String allowed() {
88	0	throw new JewelRuntimeException("unable to determine why the number of values is wrong " + specification + " with values (" + values.size() + ")");
89		}});
90		}
91
92		@Override public ValidationFailureType getFailureType() {
93	68	return specification.compareCountToSpecification(values.size(), new SpecificationMultiplicity<ValidationFailureType>(){
94		@Override public ValidationFailureType expectedNoneGotSome() {
95	6	return ValidationFailureType.UnexpectedValue;
96		}
97
98		@Override public ValidationFailureType expectedOneGotNone() {
99	6	return ValidationFailureType.MissingValue;
100		}
101
102		@Override public ValidationFailureType expectedOneGotSome() {
103	10	return ValidationFailureType.UnexpectedAdditionalValue;
104		}
105
106		@Override public ValidationFailureType expectedExactGotTooFew(final int exactly, final int valueCount) {
107	0	return ValidationFailureType.TooFewValues;
108		}
109
110		@Override public ValidationFailureType expectedExactGotTooMany(final int exactly, final int valueCount) {
111	4	return ValidationFailureType.TooManyValues;
112		}
113
114		@Override public ValidationFailureType expectedMinimumGotTooFew(final int minimum, final int valueCount) {
115	4	return ValidationFailureType.TooFewValues;
116		}
117
118		@Override public ValidationFailureType expectedMaximumGotTooMany(final int maximum, final int valueCount) {
119	4	return ValidationFailureType.TooManyValues;
120		}
121
122		@Override public ValidationFailureType allowed() {
123	0	throw new JewelRuntimeException("unable to determine why the number of values is wrong " + specification + " with values (" + values.size() + ")");
124		}});
125		}
126		}