14399493439

Committed 11 Apr 2025 08:57AM UTC coverage: 50.568% (+0.8%) from 49.802%

Build # 14399493439

Build Type

Pull #127

github

Committed by

web-flow

Commit Message

Merge c0482750b into 9b619ef21

Pull Request Pull Request #127: New generics implementation

Run Details

1877 of 3942 branches covered (47.62%)

Branch coverage included in aggregate %.

489 of 1090 new or added lines in 52 files covered. (44.86%)

56 existing lines in 10 files now uncovered.

4261 of 8196 relevant lines covered (51.99%)

2.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.75

/app/src/main/java/org/moosetechnology/model/famix/famixjavaentities/TypeParameter.java

// Automagically generated code, please do not change
package org.moosetechnology.model.famix.famixjavaentities;

import ch.akuhn.fame.FameDescription;
import ch.akuhn.fame.FamePackage;
import ch.akuhn.fame.FameProperty;
import ch.akuhn.fame.internal.MultivalueSet;
import java.util.*;
import org.moosetechnology.model.famix.famixtraits.TConcreteType;
import org.moosetechnology.model.famix.famixtraits.TConcretization;
import org.moosetechnology.model.famix.famixtraits.TParametricEntity;
import org.moosetechnology.model.famix.famixtraits.TThrowable;
import org.moosetechnology.model.famix.famixtraits.TTypeParameter;
import org.moosetechnology.model.famix.famixtraits.TWithExceptions;


@FamePackage("Famix-Java-Entities")
@FameDescription("TypeParameter")
public class TypeParameter extends Type implements TBounded, TConcreteType, TThrowable, TTypeParameter {

    private Collection<TWithExceptions> catchingEntities; 

    private Collection<TConcretization> concretizations; 

    private Collection<TWithExceptions> declaringEntities; 

    private Collection<TParametricEntity> genericEntities; 

    private TBound lowerBound;
    
    private Collection<TConcretization> outgoingConcretizations; 

    private Collection<TWithExceptions> throwingEntities; 

    private TBound upperBound;
    


    @FameProperty(name = "catchingEntities", opposite = "caughtExceptions", derived = true)
    public Collection<TWithExceptions> getCatchingEntities() {
        if (catchingEntities == null) {
            catchingEntities = new MultivalueSet<TWithExceptions>() {
                @Override
                protected void clearOpposite(TWithExceptions e) {
                    e.getCaughtExceptions().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TWithExceptions e) {
                    e.getCaughtExceptions().add(TypeParameter.this);
                }
            };
        }
        return catchingEntities;
    }
    
    public void setCatchingEntities(Collection<? extends TWithExceptions> catchingEntities) {
        this.getCatchingEntities().clear();
        this.getCatchingEntities().addAll(catchingEntities);
    }
    
    public void addCatchingEntities(TWithExceptions one) {
        this.getCatchingEntities().add(one);
    }   
    
    public void addCatchingEntities(TWithExceptions one, TWithExceptions... many) {
        this.getCatchingEntities().add(one);
        for (TWithExceptions each : many)
            this.getCatchingEntities().add(each);
    }   
    
    public void addCatchingEntities(Iterable<? extends TWithExceptions> many) {
        for (TWithExceptions each : many)
            this.getCatchingEntities().add(each);
    }   
                
    public void addCatchingEntities(TWithExceptions[] many) {
        for (TWithExceptions each : many)
            this.getCatchingEntities().add(each);
    }
    
    public int numberOfCatchingEntities() {
        return getCatchingEntities().size();
    }

    public boolean hasCatchingEntities() {
        return !getCatchingEntities().isEmpty();
    }

    @FameProperty(name = "concretizations", opposite = "genericParameter", derived = true)
    public Collection<TConcretization> getConcretizations() {
        if (concretizations == null) {
            concretizations = new MultivalueSet<TConcretization>() {
                @Override
                protected void clearOpposite(TConcretization e) {
                    e.setGenericParameter(null);
                }
                @Override
                protected void setOpposite(TConcretization e) {
                    e.setGenericParameter(TypeParameter.this);
                }
            };
        }
        return concretizations;
    }
    
    public void setConcretizations(Collection<? extends TConcretization> concretizations) {
        this.getConcretizations().clear();
        this.getConcretizations().addAll(concretizations);
    }                    
    
        
    public void addConcretizations(TConcretization one) {
        this.getConcretizations().add(one);
    }   
    
    public void addConcretizations(TConcretization one, TConcretization... many) {
        this.getConcretizations().add(one);
        for (TConcretization each : many)
            this.getConcretizations().add(each);
    }   
    
    public void addConcretizations(Iterable<? extends TConcretization> many) {
        for (TConcretization each : many)
            this.getConcretizations().add(each);
    }   
                
    public void addConcretizations(TConcretization[] many) {
        for (TConcretization each : many)
            this.getConcretizations().add(each);
    }
    
    public int numberOfConcretizations() {
        return getConcretizations().size();
    }

    public boolean hasConcretizations() {
        return !getConcretizations().isEmpty();
    }

    @FameProperty(name = "declaringEntities", opposite = "declaredExceptions", derived = true)
    public Collection<TWithExceptions> getDeclaringEntities() {
        if (declaringEntities == null) {
            declaringEntities = new MultivalueSet<TWithExceptions>() {
                @Override
                protected void clearOpposite(TWithExceptions e) {
                    e.getDeclaredExceptions().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TWithExceptions e) {
                    e.getDeclaredExceptions().add(TypeParameter.this);
                }
            };
        }
        return declaringEntities;
    }
    
    public void setDeclaringEntities(Collection<? extends TWithExceptions> declaringEntities) {
        this.getDeclaringEntities().clear();
        this.getDeclaringEntities().addAll(declaringEntities);
    }
    
    public void addDeclaringEntities(TWithExceptions one) {
        this.getDeclaringEntities().add(one);
    }   
    
    public void addDeclaringEntities(TWithExceptions one, TWithExceptions... many) {
        this.getDeclaringEntities().add(one);
        for (TWithExceptions each : many)
            this.getDeclaringEntities().add(each);
    }   
    
    public void addDeclaringEntities(Iterable<? extends TWithExceptions> many) {
        for (TWithExceptions each : many)
            this.getDeclaringEntities().add(each);
    }   
                
    public void addDeclaringEntities(TWithExceptions[] many) {
        for (TWithExceptions each : many)
            this.getDeclaringEntities().add(each);
    }
    
    public int numberOfDeclaringEntities() {
        return getDeclaringEntities().size();
    }

    public boolean hasDeclaringEntities() {
        return !getDeclaringEntities().isEmpty();
    }

    @FameProperty(name = "genericEntities", opposite = "typeParameters")
    public Collection<TParametricEntity> getGenericEntities() {
        if (genericEntities == null) {
            genericEntities = new MultivalueSet<TParametricEntity>() {
                @Override
                protected void clearOpposite(TParametricEntity e) {
                    e.getTypeParameters().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TParametricEntity e) {
                    e.getTypeParameters().add(TypeParameter.this);
                }
            };
        }
        return genericEntities;
    }
    
    public void setGenericEntities(Collection<? extends TParametricEntity> genericEntities) {
        this.getGenericEntities().clear();
        this.getGenericEntities().addAll(genericEntities);
    }
    
    public void addGenericEntities(TParametricEntity one) {
        this.getGenericEntities().add(one);
    }   
    
    public void addGenericEntities(TParametricEntity one, TParametricEntity... many) {
        this.getGenericEntities().add(one);
        for (TParametricEntity each : many)
            this.getGenericEntities().add(each);
    }   
    
    public void addGenericEntities(Iterable<? extends TParametricEntity> many) {
        for (TParametricEntity each : many)
            this.getGenericEntities().add(each);
    }   
                
    public void addGenericEntities(TParametricEntity[] many) {
        for (TParametricEntity each : many)
            this.getGenericEntities().add(each);
    }
    
    public int numberOfGenericEntities() {
        return getGenericEntities().size();
    }

    public boolean hasGenericEntities() {
        return !getGenericEntities().isEmpty();
    }

    @FameProperty(name = "lowerBound", opposite = "lowerBoundedWildcards")
    public TBound getLowerBound() {
        return lowerBound;
    }

    public void setLowerBound(TBound lowerBound) {
        if (this.lowerBound != null) {
            if (this.lowerBound.equals(lowerBound)) return;
            this.lowerBound.getLowerBoundedWildcards().remove(this);
        }
        this.lowerBound = lowerBound;
        if (lowerBound == null) return;
        lowerBound.getLowerBoundedWildcards().add(this);
    }
    
    @FameProperty(name = "outgoingConcretizations", opposite = "concreteParameter", derived = true)
    public Collection<TConcretization> getOutgoingConcretizations() {
        if (outgoingConcretizations == null) {
            outgoingConcretizations = new MultivalueSet<TConcretization>() {
                @Override
                protected void clearOpposite(TConcretization e) {
                    e.setConcreteParameter(null);
                }
                @Override
                protected void setOpposite(TConcretization e) {
                    e.setConcreteParameter(TypeParameter.this);
                }
            };
        }
        return outgoingConcretizations;
    }
    
    public void setOutgoingConcretizations(Collection<? extends TConcretization> outgoingConcretizations) {
        this.getOutgoingConcretizations().clear();
        this.getOutgoingConcretizations().addAll(outgoingConcretizations);
    }                    
    
        
    public void addOutgoingConcretizations(TConcretization one) {
        this.getOutgoingConcretizations().add(one);
    }   
    
    public void addOutgoingConcretizations(TConcretization one, TConcretization... many) {
        this.getOutgoingConcretizations().add(one);
        for (TConcretization each : many)
            this.getOutgoingConcretizations().add(each);
    }   
    
    public void addOutgoingConcretizations(Iterable<? extends TConcretization> many) {
        for (TConcretization each : many)
            this.getOutgoingConcretizations().add(each);
    }   
                
    public void addOutgoingConcretizations(TConcretization[] many) {
        for (TConcretization each : many)
            this.getOutgoingConcretizations().add(each);
    }
    
    public int numberOfOutgoingConcretizations() {
        return getOutgoingConcretizations().size();
    }

    public boolean hasOutgoingConcretizations() {
        return !getOutgoingConcretizations().isEmpty();
    }

    @FameProperty(name = "throwingEntities", opposite = "thrownExceptions", derived = true)
    public Collection<TWithExceptions> getThrowingEntities() {
        if (throwingEntities == null) {
            throwingEntities = new MultivalueSet<TWithExceptions>() {
                @Override
                protected void clearOpposite(TWithExceptions e) {
                    e.getThrownExceptions().remove(TypeParameter.this);
                }
                @Override
                protected void setOpposite(TWithExceptions e) {
                    e.getThrownExceptions().add(TypeParameter.this);
                }
            };
        }
        return throwingEntities;
    }
    
    public void setThrowingEntities(Collection<? extends TWithExceptions> throwingEntities) {
        this.getThrowingEntities().clear();
        this.getThrowingEntities().addAll(throwingEntities);
    }
    
    public void addThrowingEntities(TWithExceptions one) {
        this.getThrowingEntities().add(one);
    }   
    
    public void addThrowingEntities(TWithExceptions one, TWithExceptions... many) {
        this.getThrowingEntities().add(one);
        for (TWithExceptions each : many)
            this.getThrowingEntities().add(each);
    }   
    
    public void addThrowingEntities(Iterable<? extends TWithExceptions> many) {
        for (TWithExceptions each : many)
            this.getThrowingEntities().add(each);
    }   
                
    public void addThrowingEntities(TWithExceptions[] many) {
        for (TWithExceptions each : many)
            this.getThrowingEntities().add(each);
    }
    
    public int numberOfThrowingEntities() {
        return getThrowingEntities().size();
    }

    public boolean hasThrowingEntities() {
        return !getThrowingEntities().isEmpty();
    }

    @FameProperty(name = "upperBound", opposite = "upperBoundedWildcards")
    public TBound getUpperBound() {
        return upperBound;
    }

    public void setUpperBound(TBound upperBound) {
        if (this.upperBound != null) {
            if (this.upperBound.equals(upperBound)) return;
            this.upperBound.getUpperBoundedWildcards().remove(this);
        }
        this.upperBound = upperBound;
        if (upperBound == null) return;
        upperBound.getUpperBoundedWildcards().add(this);
    }
    


}


1	// Automagically generated code, please do not change
2	package org.moosetechnology.model.famix.famixjavaentities;
3
4	import ch.akuhn.fame.FameDescription;
5	import ch.akuhn.fame.FamePackage;
6	import ch.akuhn.fame.FameProperty;
7	import ch.akuhn.fame.internal.MultivalueSet;
8	import java.util.*;
9	import org.moosetechnology.model.famix.famixtraits.TConcreteType;
10	import org.moosetechnology.model.famix.famixtraits.TConcretization;
11	import org.moosetechnology.model.famix.famixtraits.TParametricEntity;
12	import org.moosetechnology.model.famix.famixtraits.TThrowable;
13	import org.moosetechnology.model.famix.famixtraits.TTypeParameter;
14	import org.moosetechnology.model.famix.famixtraits.TWithExceptions;
15
16
17	@FamePackage("Famix-Java-Entities")
18	@FameDescription("TypeParameter")
19	public class TypeParameter extends Type implements TBounded, TConcreteType, TThrowable, TTypeParameter {	3✔
20
21	private Collection<TWithExceptions> catchingEntities;
22
23	private Collection<TConcretization> concretizations;
24
25	private Collection<TWithExceptions> declaringEntities;
26
27	private Collection<TParametricEntity> genericEntities;
28
29	private TBound lowerBound;
30
31	private Collection<TConcretization> outgoingConcretizations;
32
33	private Collection<TWithExceptions> throwingEntities;
34
35	private TBound upperBound;
36
37
38
39	@FameProperty(name = "catchingEntities", opposite = "caughtExceptions", derived = true)
40	public Collection<TWithExceptions> getCatchingEntities() {
41	if (catchingEntities == null) {	3✔
42	catchingEntities = new MultivalueSet<TWithExceptions>() {	12✔
43	@Override
44	protected void clearOpposite(TWithExceptions e) {
NEW 45	e.getCaughtExceptions().remove(TypeParameter.this);	×
NEW 46	}	×
47	@Override
48	protected void setOpposite(TWithExceptions e) {
NEW 49	e.getCaughtExceptions().add(TypeParameter.this);	×
NEW 50	}	×
51	};
52	}
53	return catchingEntities;	3✔
54	}
55
56	public void setCatchingEntities(Collection<? extends TWithExceptions> catchingEntities) {
NEW 57	this.getCatchingEntities().clear();	×
NEW 58	this.getCatchingEntities().addAll(catchingEntities);	×
NEW 59	}	×
60
61	public void addCatchingEntities(TWithExceptions one) {
NEW 62	this.getCatchingEntities().add(one);	×
NEW 63	}	×
64
65	public void addCatchingEntities(TWithExceptions one, TWithExceptions... many) {
NEW 66	this.getCatchingEntities().add(one);	×
NEW 67	for (TWithExceptions each : many)	×
NEW 68	this.getCatchingEntities().add(each);	×
NEW 69	}	×
70
71	public void addCatchingEntities(Iterable<? extends TWithExceptions> many) {
NEW 72	for (TWithExceptions each : many)	×
NEW 73	this.getCatchingEntities().add(each);	×
NEW 74	}	×
75
76	public void addCatchingEntities(TWithExceptions[] many) {
NEW 77	for (TWithExceptions each : many)	×
NEW 78	this.getCatchingEntities().add(each);	×
NEW 79	}	×
80
81	public int numberOfCatchingEntities() {
NEW 82	return getCatchingEntities().size();	×
83	}
84
85	public boolean hasCatchingEntities() {
NEW 86	return !getCatchingEntities().isEmpty();	×
87	}
88
89	@FameProperty(name = "concretizations", opposite = "genericParameter", derived = true)
90	public Collection<TConcretization> getConcretizations() {
91	if (concretizations == null) {	3✔
92	concretizations = new MultivalueSet<TConcretization>() {	12✔
93	@Override
94	protected void clearOpposite(TConcretization e) {
NEW 95	e.setGenericParameter(null);	×
NEW 96	}	×
97	@Override
98	protected void setOpposite(TConcretization e) {
99	e.setGenericParameter(TypeParameter.this);	4✔
100	}	1✔
101	};
102	}
103	return concretizations;	3✔
104	}
105
106	public void setConcretizations(Collection<? extends TConcretization> concretizations) {
NEW 107	this.getConcretizations().clear();	×
NEW 108	this.getConcretizations().addAll(concretizations);	×
NEW 109	}	×
110
111
112	public void addConcretizations(TConcretization one) {
NEW 113	this.getConcretizations().add(one);	×
NEW 114	}	×
115
116	public void addConcretizations(TConcretization one, TConcretization... many) {
NEW 117	this.getConcretizations().add(one);	×
NEW 118	for (TConcretization each : many)	×
NEW 119	this.getConcretizations().add(each);	×
NEW 120	}	×
121
122	public void addConcretizations(Iterable<? extends TConcretization> many) {
NEW 123	for (TConcretization each : many)	×
NEW 124	this.getConcretizations().add(each);	×
NEW 125	}	×
126
127	public void addConcretizations(TConcretization[] many) {
NEW 128	for (TConcretization each : many)	×
NEW 129	this.getConcretizations().add(each);	×
NEW 130	}	×
131
132	public int numberOfConcretizations() {
133	return getConcretizations().size();	4✔
134	}
135
136	public boolean hasConcretizations() {
NEW 137	return !getConcretizations().isEmpty();	×
138	}
139
140	@FameProperty(name = "declaringEntities", opposite = "declaredExceptions", derived = true)
141	public Collection<TWithExceptions> getDeclaringEntities() {
142	if (declaringEntities == null) {	3✔
143	declaringEntities = new MultivalueSet<TWithExceptions>() {	12✔
144	@Override
145	protected void clearOpposite(TWithExceptions e) {
NEW 146	e.getDeclaredExceptions().remove(TypeParameter.this);	×
NEW 147	}	×
148	@Override
149	protected void setOpposite(TWithExceptions e) {
150	e.getDeclaredExceptions().add(TypeParameter.this);	6✔
151	}	1✔
152	};
153	}
154	return declaringEntities;	3✔
155	}
156
157	public void setDeclaringEntities(Collection<? extends TWithExceptions> declaringEntities) {
NEW 158	this.getDeclaringEntities().clear();	×
NEW 159	this.getDeclaringEntities().addAll(declaringEntities);	×
NEW 160	}	×
161
162	public void addDeclaringEntities(TWithExceptions one) {
NEW 163	this.getDeclaringEntities().add(one);	×
NEW 164	}	×
165
166	public void addDeclaringEntities(TWithExceptions one, TWithExceptions... many) {
NEW 167	this.getDeclaringEntities().add(one);	×
NEW 168	for (TWithExceptions each : many)	×
NEW 169	this.getDeclaringEntities().add(each);	×
NEW 170	}	×
171
172	public void addDeclaringEntities(Iterable<? extends TWithExceptions> many) {
NEW 173	for (TWithExceptions each : many)	×
NEW 174	this.getDeclaringEntities().add(each);	×
NEW 175	}	×
176
177	public void addDeclaringEntities(TWithExceptions[] many) {
NEW 178	for (TWithExceptions each : many)	×
NEW 179	this.getDeclaringEntities().add(each);	×
NEW 180	}	×
181
182	public int numberOfDeclaringEntities() {
NEW 183	return getDeclaringEntities().size();	×
184	}
185
186	public boolean hasDeclaringEntities() {
NEW 187	return !getDeclaringEntities().isEmpty();	×
188	}
189
190	@FameProperty(name = "genericEntities", opposite = "typeParameters")
191	public Collection<TParametricEntity> getGenericEntities() {
192	if (genericEntities == null) {	3✔
193	genericEntities = new MultivalueSet<TParametricEntity>() {	12✔
194	@Override
195	protected void clearOpposite(TParametricEntity e) {
NEW 196	e.getTypeParameters().remove(TypeParameter.this);	×
NEW 197	}	×
198	@Override
199	protected void setOpposite(TParametricEntity e) {
200	e.getTypeParameters().add(TypeParameter.this);	6✔
201	}	1✔
202	};
203	}
204	return genericEntities;	3✔
205	}
206
207	public void setGenericEntities(Collection<? extends TParametricEntity> genericEntities) {
208	this.getGenericEntities().clear();	3✔
209	this.getGenericEntities().addAll(genericEntities);	5✔
210	}	1✔
211
212	public void addGenericEntities(TParametricEntity one) {
213	this.getGenericEntities().add(one);	5✔
214	}	1✔
215
216	public void addGenericEntities(TParametricEntity one, TParametricEntity... many) {
NEW 217	this.getGenericEntities().add(one);	×
NEW 218	for (TParametricEntity each : many)	×
NEW 219	this.getGenericEntities().add(each);	×
NEW 220	}	×
221
222	public void addGenericEntities(Iterable<? extends TParametricEntity> many) {
NEW 223	for (TParametricEntity each : many)	×
NEW 224	this.getGenericEntities().add(each);	×
NEW 225	}	×
226
227	public void addGenericEntities(TParametricEntity[] many) {
NEW 228	for (TParametricEntity each : many)	×
NEW 229	this.getGenericEntities().add(each);	×
NEW 230	}	×
231
232	public int numberOfGenericEntities() {
NEW 233	return getGenericEntities().size();	×
234	}
235
236	public boolean hasGenericEntities() {
NEW 237	return !getGenericEntities().isEmpty();	×
238	}
239
240	@FameProperty(name = "lowerBound", opposite = "lowerBoundedWildcards")
241	public TBound getLowerBound() {
242	return lowerBound;	3✔
243	}
244
245	public void setLowerBound(TBound lowerBound) {
NEW 246	if (this.lowerBound != null) {	×
NEW 247	if (this.lowerBound.equals(lowerBound)) return;	×
NEW 248	this.lowerBound.getLowerBoundedWildcards().remove(this);	×
249	}
NEW 250	this.lowerBound = lowerBound;	×
NEW 251	if (lowerBound == null) return;	×
NEW 252	lowerBound.getLowerBoundedWildcards().add(this);	×
NEW 253	}	×
254
255	@FameProperty(name = "outgoingConcretizations", opposite = "concreteParameter", derived = true)
256	public Collection<TConcretization> getOutgoingConcretizations() {
257	if (outgoingConcretizations == null) {	3✔
258	outgoingConcretizations = new MultivalueSet<TConcretization>() {	12✔
259	@Override
260	protected void clearOpposite(TConcretization e) {
NEW 261	e.setConcreteParameter(null);	×
NEW 262	}	×
263	@Override
264	protected void setOpposite(TConcretization e) {
265	e.setConcreteParameter(TypeParameter.this);	4✔
266	}	1✔
267	};
268	}
269	return outgoingConcretizations;	3✔
270	}
271
272	public void setOutgoingConcretizations(Collection<? extends TConcretization> outgoingConcretizations) {
NEW 273	this.getOutgoingConcretizations().clear();	×
NEW 274	this.getOutgoingConcretizations().addAll(outgoingConcretizations);	×
NEW 275	}	×
276
277
278	public void addOutgoingConcretizations(TConcretization one) {
NEW 279	this.getOutgoingConcretizations().add(one);	×
NEW 280	}	×
281
282	public void addOutgoingConcretizations(TConcretization one, TConcretization... many) {
NEW 283	this.getOutgoingConcretizations().add(one);	×
NEW 284	for (TConcretization each : many)	×
NEW 285	this.getOutgoingConcretizations().add(each);	×
NEW 286	}	×
287
288	public void addOutgoingConcretizations(Iterable<? extends TConcretization> many) {
NEW 289	for (TConcretization each : many)	×
NEW 290	this.getOutgoingConcretizations().add(each);	×
NEW 291	}	×
292
293	public void addOutgoingConcretizations(TConcretization[] many) {
NEW 294	for (TConcretization each : many)	×
NEW 295	this.getOutgoingConcretizations().add(each);	×
NEW 296	}	×
297
298	public int numberOfOutgoingConcretizations() {
NEW 299	return getOutgoingConcretizations().size();	×
300	}
301
302	public boolean hasOutgoingConcretizations() {
NEW 303	return !getOutgoingConcretizations().isEmpty();	×
304	}
305
306	@FameProperty(name = "throwingEntities", opposite = "thrownExceptions", derived = true)
307	public Collection<TWithExceptions> getThrowingEntities() {
308	if (throwingEntities == null) {	3✔
309	throwingEntities = new MultivalueSet<TWithExceptions>() {	12✔
310	@Override
311	protected void clearOpposite(TWithExceptions e) {
NEW 312	e.getThrownExceptions().remove(TypeParameter.this);	×
NEW 313	}	×
314	@Override
315	protected void setOpposite(TWithExceptions e) {
NEW 316	e.getThrownExceptions().add(TypeParameter.this);	×
NEW 317	}	×
318	};
319	}
320	return throwingEntities;	3✔
321	}
322
323	public void setThrowingEntities(Collection<? extends TWithExceptions> throwingEntities) {
NEW 324	this.getThrowingEntities().clear();	×
NEW 325	this.getThrowingEntities().addAll(throwingEntities);	×
NEW 326	}	×
327
328	public void addThrowingEntities(TWithExceptions one) {
NEW 329	this.getThrowingEntities().add(one);	×
NEW 330	}	×
331
332	public void addThrowingEntities(TWithExceptions one, TWithExceptions... many) {
NEW 333	this.getThrowingEntities().add(one);	×
NEW 334	for (TWithExceptions each : many)	×
NEW 335	this.getThrowingEntities().add(each);	×
NEW 336	}	×
337
338	public void addThrowingEntities(Iterable<? extends TWithExceptions> many) {
NEW 339	for (TWithExceptions each : many)	×
NEW 340	this.getThrowingEntities().add(each);	×
NEW 341	}	×
342
343	public void addThrowingEntities(TWithExceptions[] many) {
NEW 344	for (TWithExceptions each : many)	×
NEW 345	this.getThrowingEntities().add(each);	×
NEW 346	}	×
347
348	public int numberOfThrowingEntities() {
NEW 349	return getThrowingEntities().size();	×
350	}
351
352	public boolean hasThrowingEntities() {
NEW 353	return !getThrowingEntities().isEmpty();	×
354	}
355
356	@FameProperty(name = "upperBound", opposite = "upperBoundedWildcards")
357	public TBound getUpperBound() {
358	return upperBound;	3✔
359	}
360
361	public void setUpperBound(TBound upperBound) {
362	if (this.upperBound != null) {	3✔
363	if (this.upperBound.equals(upperBound)) return;	6✔
364	this.upperBound.getUpperBoundedWildcards().remove(this);	6✔
365	}
366	this.upperBound = upperBound;	3✔
367	if (upperBound == null) return;	3✔
368	upperBound.getUpperBoundedWildcards().add(this);	5✔
369	}	1✔
370
371
372
373	}
374

moosetechnology / VerveineJ / 14399493439

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous