hohn/codeql
1
0
Fork 0
mirror of https://github.com/github/codeql.git synced 2025-12-18 01:33:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6684 from owen-mc/java/model/apache-collections-subpackages

Browse Source 
Java: model remaining subpackages of Apache Commons Collections
This commit is contained in:
Chris Smowton
2021-09-28 12:28:48 +01:00
committed by GitHub
parent cec6cd0830 39a12a8464
commit 413ac4e8f4
139 changed files with 7715 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
java/change-notes/2021-09-27-apache-collections-subpackages.md Normal file
View File

@@ -0,0 +1,2 @@
lgtm,codescanning
* Added models for the subpackages of Apache Commons Collections. This may lead to more results from any query using data-flow analysis where a relevant path uses one of these container types.

3
java/ql/lib/semmle/code/java/dataflow/internal/ContainerFlow.qll
View File

@@ -95,6 +95,9 @@ private class ContainerFlowSummaries extends SummaryModelCsv {
override predicate row(string row) {
row =
[
"java.lang;Object;true;clone;;;MapKey of Argument[-1];MapKey of ReturnValue;value",
"java.lang;Object;true;clone;;;MapValue of Argument[-1];MapValue of ReturnValue;value",
"java.lang;Object;true;clone;;;Element of Argument[-1];Element of ReturnValue;value",
"java.util;Map$Entry;true;getKey;;;MapKey of Argument[-1];ReturnValue;value",
"java.util;Map$Entry;true;getValue;;;MapValue of Argument[-1];ReturnValue;value",
"java.util;Map$Entry;true;setValue;;;MapValue of Argument[-1];ReturnValue;value",

581
java/ql/lib/semmle/code/java/frameworks/apache/Collections.qll
View File

@@ -136,6 +136,9 @@ private class ApacheCollectionsModel extends SummaryModelCsv {
}
}
// Note that when lambdas are supported we should model the package `org.apache.commons.collections4.functors`,
// and when more general callable flow is supported we should model the package
// `org.apache.commons.collections4.sequence`.
/**
* Value-propagating models for classes in the package `org.apache.commons.collections4.keyvalue`.
*/
@@ -170,6 +173,24 @@ private class ApacheKeyValueModel extends SummaryModelCsv {
".keyvalue;DefaultMapEntry;true;DefaultMapEntry;(KeyValue);;MapValue of Argument[0];MapValue of Argument[-1];value",
".keyvalue;DefaultMapEntry;true;DefaultMapEntry;(Entry);;MapKey of Argument[0];MapKey of Argument[-1];value",
".keyvalue;DefaultMapEntry;true;DefaultMapEntry;(Entry);;MapValue of Argument[0];MapValue of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object[]);;ArrayElement of Argument[0];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object[],boolean);;ArrayElement of Argument[0];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object);;Argument[0];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object);;Argument[1];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object);;Argument[0];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object);;Argument[1];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object);;Argument[2];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object);;Argument[0];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object);;Argument[1];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object);;Argument[2];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object);;Argument[3];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object,Object);;Argument[0];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object,Object);;Argument[1];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object,Object);;Argument[2];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object,Object);;Argument[3];Element of Argument[-1];value",
".keyvalue;MultiKey;true;MultiKey;(Object,Object,Object,Object,Object);;Argument[4];Element of Argument[-1];value",
".keyvalue;MultiKey;true;getKeys;;;Element of Argument[-1];ArrayElement of ReturnValue;value",
".keyvalue;MultiKey;true;getKey;;;Element of Argument[-1];ReturnValue;value",
".keyvalue;TiedMapEntry;true;TiedMapEntry;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".keyvalue;TiedMapEntry;true;TiedMapEntry;;;Argument[1];MapKey of Argument[-1];value",
".keyvalue;UnmodifiableMapEntry;true;UnmodifiableMapEntry;(Object,Object);;Argument[0];MapKey of Argument[-1];value",
@@ -182,6 +203,560 @@ private class ApacheKeyValueModel extends SummaryModelCsv {
}
}
/**
* Value-propagating models for classes in the package `org.apache.commons.collections4.bag`.
*/
private class ApacheBagModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedBag, TransformedSortedBag
".bag;AbstractBagDecorator;true;AbstractBagDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".bag;AbstractMapBag;true;AbstractMapBag;;;MapKey of Argument[0];Element of Argument[-1];value",
".bag;AbstractMapBag;true;getMap;;;Element of Argument[-1];MapKey of ReturnValue;value",
".bag;AbstractSortedBagDecorator;true;AbstractSortedBagDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".bag;CollectionBag;true;CollectionBag;;;Element of Argument[0];Element of Argument[-1];value",
".bag;CollectionBag;true;collectionBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;CollectionSortedBag;true;CollectionSortedBag;;;Element of Argument[0];Element of Argument[-1];value",
".bag;CollectionSortedBag;true;collectionSortedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;HashBag;true;HashBag;;;Element of Argument[0];Element of Argument[-1];value",
".bag;PredicatedBag;true;predicatedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;PredicatedSortedBag;true;predicatedSortedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;SynchronizedBag;true;synchronizedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;SynchronizedSortedBag;true;synchronizedSortedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;TransformedBag;true;transformedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;TransformedSortedBag;true;transformedSortedBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;TreeBag;true;TreeBag;(Collection);;Element of Argument[0];Element of Argument[-1];value",
".bag;UnmodifiableBag;true;unmodifiableBag;;;Element of Argument[0];Element of ReturnValue;value",
".bag;UnmodifiableSortedBag;true;unmodifiableSortedBag;;;Element of Argument[0];Element of ReturnValue;value"
]
}
}
/**
* Value-propagating models for classes in the package `org.apache.commons.collections4.bidimap`.
*/
private class ApacheBidiMapModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
".bidimap;AbstractBidiMapDecorator;true;AbstractBidiMapDecorator;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;AbstractBidiMapDecorator;true;AbstractBidiMapDecorator;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;AbstractDualBidiMap;true;AbstractDualBidiMap;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;AbstractDualBidiMap;true;AbstractDualBidiMap;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;AbstractDualBidiMap;true;AbstractDualBidiMap;;;MapKey of Argument[1];MapValue of Argument[-1];value",
".bidimap;AbstractDualBidiMap;true;AbstractDualBidiMap;;;MapValue of Argument[1];MapKey of Argument[-1];value",
".bidimap;AbstractDualBidiMap;true;AbstractDualBidiMap;;;MapKey of Argument[2];MapValue of Argument[-1];value",
".bidimap;AbstractDualBidiMap;true;AbstractDualBidiMap;;;MapValue of Argument[2];MapKey of Argument[-1];value",
".bidimap;AbstractOrderedBidiMapDecorator;true;AbstractOrderedBidiMapDecorator;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;AbstractOrderedBidiMapDecorator;true;AbstractOrderedBidiMapDecorator;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;AbstractSortedBidiMapDecorator;true;AbstractSortedBidiMapDecorator;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;AbstractSortedBidiMapDecorator;true;AbstractSortedBidiMapDecorator;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;DualHashBidiMap;true;DualHashBidiMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;DualHashBidiMap;true;DualHashBidiMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;DualLinkedHashBidiMap;true;DualLinkedHashBidiMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;DualLinkedHashBidiMap;true;DualLinkedHashBidiMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;DualTreeBidiMap;true;DualTreeBidiMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;DualTreeBidiMap;true;DualTreeBidiMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;DualTreeBidiMap;true;inverseOrderedBidiMap;;;MapKey of Argument[-1];MapValue of ReturnValue;value",
".bidimap;DualTreeBidiMap;true;inverseOrderedBidiMap;;;MapValue of Argument[-1];MapKey of ReturnValue;value",
".bidimap;DualTreeBidiMap;true;inverseSortedBidiMap;;;MapKey of Argument[-1];MapValue of ReturnValue;value",
".bidimap;DualTreeBidiMap;true;inverseSortedBidiMap;;;MapValue of Argument[-1];MapKey of ReturnValue;value",
".bidimap;TreeBidiMap;true;TreeBidiMap;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".bidimap;TreeBidiMap;true;TreeBidiMap;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".bidimap;UnmodifiableBidiMap;true;unmodifiableBidiMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".bidimap;UnmodifiableBidiMap;true;unmodifiableBidiMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".bidimap;UnmodifiableOrderedBidiMap;true;unmodifiableOrderedBidiMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".bidimap;UnmodifiableOrderedBidiMap;true;unmodifiableOrderedBidiMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".bidimap;UnmodifiableOrderedBidiMap;true;inverseOrderedBidiMap;;;MapKey of Argument[-1];MapValue of ReturnValue;value",
".bidimap;UnmodifiableOrderedBidiMap;true;inverseOrderedBidiMap;;;MapValue of Argument[-1];MapKey of ReturnValue;value",
".bidimap;UnmodifiableSortedBidiMap;true;unmodifiableSortedBidiMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".bidimap;UnmodifiableSortedBidiMap;true;unmodifiableSortedBidiMap;;;MapValue of Argument[0];MapValue of ReturnValue;value"
]
}
}
/**
* Value-propagating models for classes in the package `org.apache.commons.collections4.collection`.
*/
private class ApacheCollectionModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedCollection
".collection;AbstractCollectionDecorator;true;AbstractCollectionDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".collection;AbstractCollectionDecorator;true;decorated;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;AbstractCollectionDecorator;true;setCollection;;;Element of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection$CollectionMutator;true;add;;;Argument[2];Element of Argument[0];value",
".collection;CompositeCollection$CollectionMutator;true;add;;;Argument[2];Element of Element of Argument[1];value",
".collection;CompositeCollection$CollectionMutator;true;addAll;;;Element of Argument[2];Element of Argument[0];value",
".collection;CompositeCollection$CollectionMutator;true;addAll;;;Element of Argument[2];Element of Element of Argument[1];value",
".collection;CompositeCollection;true;CompositeCollection;(Collection);;Element of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection;true;CompositeCollection;(Collection,Collection);;Element of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection;true;CompositeCollection;(Collection,Collection);;Element of Argument[1];Element of Argument[-1];value",
".collection;CompositeCollection;true;CompositeCollection;(Collection[]);;Element of ArrayElement of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection;true;addComposited;(Collection);;Element of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection;true;addComposited;(Collection,Collection);;Element of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection;true;addComposited;(Collection,Collection);;Element of Argument[1];Element of Argument[-1];value",
".collection;CompositeCollection;true;addComposited;(Collection[]);;Element of ArrayElement of Argument[0];Element of Argument[-1];value",
".collection;CompositeCollection;true;toCollection;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;CompositeCollection;true;getCollections;;;Element of Argument[-1];Element of Element of ReturnValue;value",
".collection;IndexedCollection;true;IndexedCollection;;;Element of Argument[0];Element of Argument[-1];value",
".collection;IndexedCollection;true;uniqueIndexedCollection;;;Element of Argument[0];Element of ReturnValue;value",
".collection;IndexedCollection;true;nonUniqueIndexedCollection;;;Element of Argument[0];Element of ReturnValue;value",
".collection;IndexedCollection;true;get;;;Element of Argument[-1];ReturnValue;value",
".collection;IndexedCollection;true;values;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;add;;;Argument[0];Element of Argument[-1];value",
".collection;PredicatedCollection$Builder;true;addAll;;;Element of Argument[0];Element of Argument[-1];value",
".collection;PredicatedCollection$Builder;true;createPredicatedList;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedList;;;Element of Argument[0];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedSet;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedSet;;;Element of Argument[0];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedMultiSet;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedMultiSet;;;Element of Argument[0];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedBag;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedBag;;;Element of Argument[0];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedQueue;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;createPredicatedQueue;;;Element of Argument[0];Element of ReturnValue;value",
".collection;PredicatedCollection$Builder;true;rejectedElements;;;Element of Argument[-1];Element of ReturnValue;value",
".collection;PredicatedCollection;true;predicatedCollection;;;Element of Argument[0];Element of ReturnValue;value",
".collection;SynchronizedCollection;true;synchronizedCollection;;;Element of Argument[0];Element of ReturnValue;value",
".collection;TransformedCollection;true;transformingCollection;;;Element of Argument[0];Element of ReturnValue;value",
".collection;UnmodifiableBoundedCollection;true;unmodifiableBoundedCollection;;;Element of Argument[0];Element of ReturnValue;value",
".collection;UnmodifiableCollection;true;unmodifiableCollection;;;Element of Argument[0];Element of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.iterators`.
*/
private class ApacheIteratorsModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformIterator
".iterators;AbstractIteratorDecorator;true;AbstractIteratorDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;AbstractListIteratorDecorator;true;AbstractListIteratorDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;AbstractListIteratorDecorator;true;getListIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;AbstractMapIteratorDecorator;true;AbstractMapIteratorDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;AbstractMapIteratorDecorator;true;AbstractMapIteratorDecorator;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".iterators;AbstractMapIteratorDecorator;true;getMapIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;AbstractMapIteratorDecorator;true;getMapIterator;;;MapValue of Argument[-1];MapValue of ReturnValue;value",
".iterators;AbstractOrderedMapIteratorDecorator;true;AbstractOrderedMapIteratorDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;AbstractOrderedMapIteratorDecorator;true;AbstractOrderedMapIteratorDecorator;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".iterators;AbstractOrderedMapIteratorDecorator;true;getOrderedMapIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;AbstractOrderedMapIteratorDecorator;true;getOrderedMapIterator;;;MapValue of Argument[-1];MapValue of ReturnValue;value",
".iterators;AbstractUntypedIteratorDecorator;true;AbstractUntypedIteratorDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;AbstractUntypedIteratorDecorator;true;getIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;ArrayIterator;true;ArrayIterator;;;ArrayElement of Argument[0];Element of Argument[-1];value",
".iterators;ArrayIterator;true;getArray;;;Element of Argument[-1];ArrayElement of ReturnValue;value",
".iterators;ArrayListIterator;true;ArrayListIterator;;;ArrayElement of Argument[0];Element of Argument[-1];value",
".iterators;BoundedIterator;true;BoundedIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;CollatingIterator;true;CollatingIterator;(Comparator,Iterator,Iterator);;Element of Argument[1];Element of Argument[-1];value",
".iterators;CollatingIterator;true;CollatingIterator;(Comparator,Iterator,Iterator);;Element of Argument[2];Element of Argument[-1];value",
".iterators;CollatingIterator;true;CollatingIterator;(Comparator,Iterator[]);;Element of ArrayElement of Argument[1];Element of Argument[-1];value",
".iterators;CollatingIterator;true;CollatingIterator;(Comparator,Collection);;Element of Element of Argument[1];Element of Argument[-1];value",
".iterators;CollatingIterator;true;addIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;CollatingIterator;true;setIterator;;;Element of Argument[1];Element of Argument[-1];value",
".iterators;CollatingIterator;true;getIterators;;;Element of Argument[-1];Element of Element of ReturnValue;value",
".iterators;EnumerationIterator;true;EnumerationIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;EnumerationIterator;true;getEnumeration;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;EnumerationIterator;true;setEnumeration;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;FilterIterator;true;FilterIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;FilterIterator;true;getIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;FilterIterator;true;setIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;FilterListIterator;true;FilterListIterator;(ListIterator);;Element of Argument[0];Element of Argument[-1];value",
".iterators;FilterListIterator;true;FilterListIterator;(ListIterator,Predicate);;Element of Argument[0];Element of Argument[-1];value",
".iterators;FilterListIterator;true;getListIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;FilterListIterator;true;setListIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorChain;true;IteratorChain;(Iterator);;Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorChain;true;IteratorChain;(Iterator,Iterator);;Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorChain;true;IteratorChain;(Iterator,Iterator);;Element of Argument[1];Element of Argument[-1];value",
".iterators;IteratorChain;true;IteratorChain;(Iterator[]);;Element of ArrayElement of Argument[0];Element of Argument[-1];value",
".iterators;IteratorChain;true;IteratorChain;(Collection);;Element of Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorChain;true;addIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorEnumeration;true;IteratorEnumeration;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorEnumeration;true;getIterator;;;Element of Argument[-1];Element of ReturnValue;value",
".iterators;IteratorEnumeration;true;setIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;IteratorIterable;true;IteratorIterable;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;ListIteratorWrapper;true;ListIteratorWrapper;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;LoopingIterator;true;LoopingIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;LoopingListIterator;true;LoopingListIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;ObjectArrayIterator;true;ObjectArrayIterator;;;ArrayElement of Argument[0];Element of Argument[-1];value",
".iterators;ObjectArrayIterator;true;getArray;;;Element of Argument[-1];ArrayElement of ReturnValue;value",
".iterators;ObjectArrayListIterator;true;ObjectArrayListIterator;;;ArrayElement of Argument[0];Element of Argument[-1];value",
".iterators;PeekingIterator;true;PeekingIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;PeekingIterator;true;peekingIterator;;;Element of Argument[0];Element of ReturnValue;value",
".iterators;PeekingIterator;true;peek;;;Element of Argument[-1];ReturnValue;value",
".iterators;PeekingIterator;true;element;;;Element of Argument[-1];ReturnValue;value",
".iterators;PermutationIterator;true;PermutationIterator;;;Element of Argument[0];Element of Element of Argument[-1];value",
".iterators;PushbackIterator;true;PushbackIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;PushbackIterator;true;pushbackIterator;;;Element of Argument[0];Element of ReturnValue;value",
".iterators;PushbackIterator;true;pushback;;;Argument[0];Element of Argument[-1];value",
".iterators;ReverseListIterator;true;ReverseListIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;SingletonIterator;true;SingletonIterator;;;Argument[0];Element of Argument[-1];value",
".iterators;SingletonListIterator;true;SingletonListIterator;;;Argument[0];Element of Argument[-1];value",
".iterators;SkippingIterator;true;SkippingIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;UniqueFilterIterator;true;UniqueFilterIterator;;;Element of Argument[0];Element of Argument[-1];value",
".iterators;UnmodifiableIterator;true;unmodifiableIterator;;;Element of Argument[0];Element of ReturnValue;value",
".iterators;UnmodifiableListIterator;true;umodifiableListIterator;;;Element of Argument[0];Element of ReturnValue;value",
".iterators;UnmodifiableMapIterator;true;unmodifiableMapIterator;;;Element of Argument[0];Element of ReturnValue;value",
".iterators;UnmodifiableMapIterator;true;unmodifiableMapIterator;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".iterators;UnmodifiableOrderedMapIterator;true;unmodifiableOrderedMapIterator;;;Element of Argument[0];Element of ReturnValue;value",
".iterators;UnmodifiableOrderedMapIterator;true;unmodifiableOrderedMapIterator;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".iterators;ZippingIterator;true;ZippingIterator;(Iterator[]);;Element of ArrayElement of Argument[0];Element of Argument[-1];value",
".iterators;ZippingIterator;true;ZippingIterator;(Iterator,Iterator);;Element of Argument[0];Element of Argument[-1];value",
".iterators;ZippingIterator;true;ZippingIterator;(Iterator,Iterator);;Element of Argument[1];Element of Argument[-1];value",
".iterators;ZippingIterator;true;ZippingIterator;(Iterator,Iterator,Iterator);;Element of Argument[0];Element of Argument[-1];value",
".iterators;ZippingIterator;true;ZippingIterator;(Iterator,Iterator,Iterator);;Element of Argument[1];Element of Argument[-1];value",
".iterators;ZippingIterator;true;ZippingIterator;(Iterator,Iterator,Iterator);;Element of Argument[2];Element of Argument[-1];value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.list`.
*/
private class ApacheListModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedList
".list;AbstractLinkedList;true;AbstractLinkedList;;;Element of Argument[0];Element of Argument[-1];value",
".list;AbstractLinkedList;true;getFirst;;;Element of Argument[-1];ReturnValue;value",
".list;AbstractLinkedList;true;getLast;;;Element of Argument[-1];ReturnValue;value",
".list;AbstractLinkedList;true;addFirst;;;Argument[0];Element of Argument[-1];value",
".list;AbstractLinkedList;true;addLast;;;Argument[0];Element of Argument[-1];value",
".list;AbstractLinkedList;true;removeFirst;;;Element of Argument[-1];ReturnValue;value",
".list;AbstractLinkedList;true;removeLast;;;Element of Argument[-1];ReturnValue;value",
".list;AbstractListDecorator;true;AbstractListDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".list;AbstractSerializableListDecorator;true;AbstractSerializableListDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".list;CursorableLinkedList;true;CursorableLinkedList;;;Element of Argument[0];Element of Argument[-1];value",
".list;CursorableLinkedList;true;cursor;;;Element of Argument[-1];Element of ReturnValue;value",
".list;FixedSizeList;true;fixedSizeList;;;Element of Argument[0];Element of ReturnValue;value",
".list;GrowthList;true;growthList;;;Element of Argument[0];Element of ReturnValue;value",
".list;LazyList;true;lazyList;;;Element of Argument[0];Element of ReturnValue;value",
".list;NodeCachingLinkedList;true;NodeCachingLinkedList;(Collection);;Element of Argument[0];Element of Argument[-1];value",
".list;PredicatedList;true;predicatedList;;;Element of Argument[0];Element of ReturnValue;value",
".list;SetUniqueList;true;setUniqueList;;;Element of Argument[0];Element of ReturnValue;value",
".list;SetUniqueList;true;asSet;;;Element of Argument[-1];Element of ReturnValue;value",
".list;TransformedList;true;transformingList;;;Element of Argument[0];Element of ReturnValue;value",
".list;TreeList;true;TreeList;;;Element of Argument[0];Element of Argument[-1];value",
".list;UnmodifiableList;true;UnmodifiableList;;;Element of Argument[0];Element of Argument[-1];value",
".list;UnmodifiableList;true;unmodifiableList;;;Element of Argument[0];Element of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.map`.
*/
private class ApacheMapModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for DefaultedMap, LazyMap, TransformedMap, TransformedSortedMap
".map;AbstractHashedMap;true;AbstractHashedMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;AbstractHashedMap;true;AbstractHashedMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;AbstractLinkedMap;true;AbstractLinkedMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;AbstractLinkedMap;true;AbstractLinkedMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;AbstractMapDecorator;true;AbstractMapDecorator;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;AbstractMapDecorator;true;AbstractMapDecorator;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;AbstractMapDecorator;true;decorated;;;MapKey of Argument[-1];MapKey of ReturnValue;value",
".map;AbstractMapDecorator;true;decorated;;;MapValue of Argument[-1];MapValue of ReturnValue;value",
".map;AbstractOrderedMapDecorator;true;AbstractOrderedMapDecorator;(OrderedMap);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;AbstractOrderedMapDecorator;true;AbstractOrderedMapDecorator;(OrderedMap);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;AbstractSortedMapDecorator;true;AbstractSortedMapDecorator;(SortedMap);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;AbstractSortedMapDecorator;true;AbstractSortedMapDecorator;(SortedMap);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;CaseInsensitiveMap;true;CaseInsensitiveMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;CaseInsensitiveMap;true;CaseInsensitiveMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map);;MapKey of Argument[1];MapKey of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map);;MapValue of Argument[1];MapValue of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map,MapMutator);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map,MapMutator);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map,MapMutator);;MapKey of Argument[1];MapKey of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map,Map,MapMutator);;MapValue of Argument[1];MapValue of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map[]);;MapKey of ArrayElement of Argument[0];MapKey of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map[]);;MapValue of ArrayElement of Argument[0];MapValue of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map[],MapMutator);;MapKey of ArrayElement of Argument[0];MapKey of Argument[-1];value",
".map;CompositeMap;true;CompositeMap;(Map[],MapMutator);;MapValue of ArrayElement of Argument[0];MapValue of Argument[-1];value",
".map;CompositeMap;true;addComposited;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;CompositeMap;true;addComposited;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;CompositeMap;true;removeComposited;;;MapKey of Argument[-1];MapKey of ReturnValue;value",
".map;CompositeMap;true;removeComposited;;;MapValue of Argument[-1];MapValue of ReturnValue;value",
".map;CompositeMap;true;removeComposited;;;Argument[0];ReturnValue;value",
".map;DefaultedMap;true;DefaultedMap;(Object);;Argument[0];MapValue of Argument[-1];value",
".map;DefaultedMap;true;defaultedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;DefaultedMap;true;defaultedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;DefaultedMap;true;defaultedMap;(Map,Object);;Argument[1];MapValue of ReturnValue;value",
".map;EntrySetToMapIteratorAdapter;true;EntrySetToMapIteratorAdapter;;;MapKey of Element of Argument[0];Element of Argument[-1];value",
".map;EntrySetToMapIteratorAdapter;true;EntrySetToMapIteratorAdapter;;;MapValue of Element of Argument[0];MapValue of Argument[-1];value",
".map;FixedSizeMap;true;fixedSizeMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;FixedSizeMap;true;fixedSizeMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;FixedSizeSortedMap;true;fixedSizeSortedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;FixedSizeSortedMap;true;fixedSizeSortedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;Flat3Map;true;Flat3Map;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;Flat3Map;true;Flat3Map;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;HashedMap;true;HashedMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;HashedMap;true;HashedMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;LazyMap;true;lazyMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;LazyMap;true;lazyMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;LazySortedMap;true;lazySortedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;LazySortedMap;true;lazySortedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;LinkedMap;true;LinkedMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;LinkedMap;true;LinkedMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;LinkedMap;true;get;(int);;MapKey of Argument[-1];ReturnValue;value",
".map;LinkedMap;true;getValue;(int);;MapValue of Argument[-1];ReturnValue;value",
".map;LinkedMap;true;remove;(int);;MapValue of Argument[-1];ReturnValue;value",
".map;LinkedMap;true;asList;;;MapKey of Argument[-1];Element of ReturnValue;value",
".map;ListOrderedMap;true;listOrderedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;ListOrderedMap;true;listOrderedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;ListOrderedMap;true;putAll;;;MapKey of Argument[1];MapKey of Argument[-1];value",
".map;ListOrderedMap;true;putAll;;;MapValue of Argument[1];MapValue of Argument[-1];value",
".map;ListOrderedMap;true;keyList;;;MapKey of Argument[-1];Element of ReturnValue;value",
".map;ListOrderedMap;true;valueList;;;MapValue of Argument[-1];Element of ReturnValue;value",
".map;ListOrderedMap;true;get;(int);;MapKey of Argument[-1];ReturnValue;value",
".map;ListOrderedMap;true;getValue;(int);;MapValue of Argument[-1];ReturnValue;value",
".map;ListOrderedMap;true;setValue;;;Argument[1];MapValue of Argument[-1];value",
".map;ListOrderedMap;true;put;;;Argument[1];MapKey of Argument[-1];value",
".map;ListOrderedMap;true;put;;;Argument[2];MapValue of Argument[-1];value",
".map;ListOrderedMap;true;remove;(int);;MapValue of Argument[-1];ReturnValue;value",
".map;ListOrderedMap;true;asList;;;MapKey of Argument[-1];Element of ReturnValue;value",
".map;LRUMap;true;LRUMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;LRUMap;true;LRUMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;LRUMap;true;LRUMap;(Map,boolean);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;LRUMap;true;LRUMap;(Map,boolean);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;LRUMap;true;get;(Object,boolean);;MapValue of Argument[0];ReturnValue;value",
".map;MultiKeyMap;true;get;;;MapValue of Argument[-1];ReturnValue;value",
".map;MultiKeyMap;true;put;;;MapValue of Argument[-1];ReturnValue;value",
".map;MultiKeyMap;true;put;(Object,Object,Object);;Argument[0..1];Element of MapKey of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object,Object);;Argument[0..2];Element of MapKey of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object,Object,Object);;Argument[0..3];Element of MapKey of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object,Object,Object,Object);;Argument[0..4];Element of MapKey of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object);;Argument[2];MapValue of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object,Object);;Argument[3];MapValue of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object,Object,Object);;Argument[4];MapValue of Argument[-1];value",
".map;MultiKeyMap;true;put;(Object,Object,Object,Object,Object,Object);;Argument[5];MapValue of Argument[-1];value",
".map;MultiKeyMap;true;removeMultiKey;;;MapValue of Argument[-1];ReturnValue;value",
".map;MultiValueMap;true;multiValueMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;MultiValueMap;true;multiValueMap;;;Element of MapValue of Argument[0];Element of MapValue of ReturnValue;value",
".map;MultiValueMap;true;getCollection;;;Element of MapValue of Argument[-1];Element of ReturnValue;value",
".map;MultiValueMap;true;putAll;(Map);;MapValue of Argument[0];Element of MapValue of Argument[-1];value",
".map;MultiValueMap;true;putAll;(Map);;Element of MapValue of Argument[0];Element of MapValue of Argument[-1];value",
".map;MultiValueMap;true;values;;;Element of MapValue of Argument[-1];Element of ReturnValue;value",
".map;MultiValueMap;true;putAll;(Object,Collection);;Argument[0];MapKey of Argument[-1];value",
".map;MultiValueMap;true;putAll;(Object,Collection);;Element of Argument[1];Element of MapValue of Argument[-1];value",
".map;MultiValueMap;true;iterator;(Object);;Element of MapValue of Argument[-1];Element of ReturnValue;value",
".map;MultiValueMap;true;iterator;();;MapKey of Argument[-1];MapKey of Element of ReturnValue;value",
".map;MultiValueMap;true;iterator;();;Element of MapValue of Argument[-1];MapValue of Element of ReturnValue;value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(ExpirationPolicy,Map);;MapKey of Argument[1];MapKey of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(ExpirationPolicy,Map);;MapValue of Argument[1];MapValue of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(long,Map);;MapKey of Argument[1];MapKey of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(long,Map);;MapValue of Argument[1];MapValue of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(long,TimeUnit,Map);;MapKey of Argument[2];MapKey of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(long,TimeUnit,Map);;MapValue of Argument[2];MapValue of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;PassiveExpiringMap;true;PassiveExpiringMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;PredicatedMap;true;predicatedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;PredicatedMap;true;predicatedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;PredicatedSortedMap;true;predicatedSortedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;PredicatedSortedMap;true;predicatedSortedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;SingletonMap;true;SingletonMap;(Object,Object);;Argument[0];MapKey of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(Object,Object);;Argument[1];MapValue of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(KeyValue);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(KeyValue);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(Entry);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(Entry);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".map;SingletonMap;true;SingletonMap;(Map);;MapValue of Argument[0];MapValue of Argument[-1];value",
".map;SingletonMap;true;setValue;;;Argument[0];MapValue of Argument[-1];value",
".map;TransformedMap;true;transformingMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;TransformedMap;true;transformingMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;TransformedSortedMap;true;transformingSortedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;TransformedSortedMap;true;transformingSortedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;UnmodifiableEntrySet;true;unmodifiableEntrySet;;;MapKey of Element of Argument[0];MapKey of Element of ReturnValue;value",
".map;UnmodifiableEntrySet;true;unmodifiableEntrySet;;;MapValue of Element of Argument[0];MapValue of Element of ReturnValue;value",
".map;UnmodifiableMap;true;unmodifiableMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;UnmodifiableMap;true;unmodifiableMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;UnmodifiableOrderedMap;true;unmodifiableOrderedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;UnmodifiableOrderedMap;true;unmodifiableOrderedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
".map;UnmodifiableSortedMap;true;unmodifiableSortedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".map;UnmodifiableSortedMap;true;unmodifiableSortedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.multimap`.
*/
private class ApacheMultiMapModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedMultiValuedMap
".multimap;ArrayListValuedHashMap;true;ArrayListValuedHashMap;(MultiValuedMap);;MapKey of Argument[0];MapKey of Argument[-1];value",
".multimap;ArrayListValuedHashMap;true;ArrayListValuedHashMap;(MultiValuedMap);;Element of MapValue of Argument[0];Element of MapValue of Argument[-1];value",
".multimap;ArrayListValuedHashMap;true;ArrayListValuedHashMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".multimap;ArrayListValuedHashMap;true;ArrayListValuedHashMap;(Map);;MapValue of Argument[0];Element of MapValue of Argument[-1];value",
".multimap;HashSetValuedHashMap;true;HashSetValuedHashMap;(MultiValuedMap);;MapKey of Argument[0];MapKey of Argument[-1];value",
".multimap;HashSetValuedHashMap;true;HashSetValuedHashMap;(MultiValuedMap);;Element of MapValue of Argument[0];Element of MapValue of Argument[-1];value",
".multimap;HashSetValuedHashMap;true;HashSetValuedHashMap;(Map);;MapKey of Argument[0];MapKey of Argument[-1];value",
".multimap;HashSetValuedHashMap;true;HashSetValuedHashMap;(Map);;MapValue of Argument[0];Element of MapValue of Argument[-1];value",
".multimap;TransformedMultiValuedMap;true;transformingMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".multimap;TransformedMultiValuedMap;true;transformingMap;;;Element of MapValue of Argument[0];Element of MapValue of ReturnValue;value",
".multimap;UnmodifiableMultiValuedMap;true;unmodifiableMultiValuedMap;(MultiValuedMap);;MapKey of Argument[0];MapKey of ReturnValue;value",
".multimap;UnmodifiableMultiValuedMap;true;unmodifiableMultiValuedMap;(MultiValuedMap);;Element of MapValue of Argument[0];Element of MapValue of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.multiset`.
*/
private class ApacheMultiSetModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
".multiset;HashMultiSet;true;HashMultiSet;;;Element of Argument[0];Element of Argument[-1];value",
".multiset;PredicatedMultiSet;true;predicatedMultiSet;;;Element of Argument[0];Element of ReturnValue;value",
".multiset;SynchronizedMultiSet;true;synchronizedMultiSet;;;Element of Argument[0];Element of ReturnValue;value",
".multiset;UnmodifiableMultiSet;true;unmodifiableMultiSet;;;Element of Argument[0];Element of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.properties`.
*/
private class ApachePropertiesModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
".properties;AbstractPropertiesFactory;true;load;(ClassLoader,String);;Argument[1];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(File);;Argument[0];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(InputStream);;Argument[0];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(Path);;Argument[0];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(Reader);;Argument[0];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(String);;Argument[0];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(URI);;Argument[0];ReturnValue;taint",
".properties;AbstractPropertiesFactory;true;load;(URL);;Argument[0];ReturnValue;taint"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.queue`.
*/
private class ApacheQueueModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedQueue
".queue;CircularFifoQueue;true;CircularFifoQueue;(Collection);;Element of Argument[0];Element of Argument[-1];value",
".queue;CircularFifoQueue;true;get;;;Element of Argument[-1];ReturnValue;value",
".queue;PredicatedQueue;true;predicatedQueue;;;Element of Argument[0];Element of ReturnValue;value",
".queue;SynchronizedQueue;true;synchronizedQueue;;;Element of Argument[0];Element of ReturnValue;value",
".queue;TransformedQueue;true;transformingQueue;;;Element of Argument[0];Element of ReturnValue;value",
".queue;UnmodifiableQueue;true;unmodifiableQueue;;;Element of Argument[0];Element of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.set`.
*/
private class ApacheSetModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedNavigableSet
".set;AbstractNavigableSetDecorator;true;AbstractNavigableSetDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".set;AbstractSetDecorator;true;AbstractSetDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".set;AbstractSortedSetDecorator;true;AbstractSortedSetDecorator;;;Element of Argument[0];Element of Argument[-1];value",
".set;CompositeSet$SetMutator;true;add;;;Argument[2];Element of Argument[0];value",
".set;CompositeSet$SetMutator;true;add;;;Argument[2];Element of Element of Argument[1];value",
".set;CompositeSet$SetMutator;true;addAll;;;Element of Argument[2];Element of Argument[0];value",
".set;CompositeSet$SetMutator;true;addAll;;;Element of Argument[2];Element of Element of Argument[1];value",
".set;CompositeSet;true;CompositeSet;(Set);;Element of Argument[0];Element of Argument[-1];value",
".set;CompositeSet;true;CompositeSet;(Set[]);;Element of ArrayElement of Argument[0];Element of Argument[-1];value",
".set;CompositeSet;true;addComposited;(Set);;Element of Argument[0];Element of Argument[-1];value",
".set;CompositeSet;true;addComposited;(Set,Set);;Element of Argument[0];Element of Argument[-1];value",
".set;CompositeSet;true;addComposited;(Set,Set);;Element of Argument[1];Element of Argument[-1];value",
".set;CompositeSet;true;addComposited;(Set[]);;Element of ArrayElement of Argument[0];Element of Argument[-1];value",
".set;CompositeSet;true;toSet;;;Element of Argument[-1];Element of ReturnValue;value",
".set;CompositeSet;true;getSets;;;Element of Argument[-1];Element of Element of ReturnValue;value",
".set;ListOrderedSet;true;listOrderedSet;(Set);;Element of Argument[0];Element of ReturnValue;value",
".set;ListOrderedSet;true;listOrderedSet;(List);;Element of Argument[0];Element of ReturnValue;value",
".set;ListOrderedSet;true;asList;;;Element of Argument[-1];Element of ReturnValue;value",
".set;ListOrderedSet;true;get;;;Element of Argument[-1];ReturnValue;value",
".set;ListOrderedSet;true;add;;;Argument[1];Element of Argument[-1];value",
".set;ListOrderedSet;true;addAll;;;Element of Argument[1];Element of Argument[-1];value",
".set;MapBackedSet;true;mapBackedSet;;;MapKey of Argument[0];Element of ReturnValue;value",
".set;PredicatedNavigableSet;true;predicatedNavigableSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;PredicatedSet;true;predicatedSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;PredicatedSortedSet;true;predicatedSortedSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;TransformedNavigableSet;true;transformingNavigableSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;TransformedSet;true;transformingSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;TransformedSortedSet;true;transformingSortedSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;UnmodifiableNavigableSet;true;unmodifiableNavigableSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;UnmodifiableSet;true;unmodifiableSet;;;Element of Argument[0];Element of ReturnValue;value",
".set;UnmodifiableSortedSet;true;unmodifiableSortedSet;;;Element of Argument[0];Element of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.splitmap`.
*/
private class ApacheSplitMapModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedSplitMap
".splitmap;AbstractIterableGetMapDecorator;true;AbstractIterableGetMapDecorator;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".splitmap;AbstractIterableGetMapDecorator;true;AbstractIterableGetMapDecorator;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".splitmap;TransformedSplitMap;true;transformingMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".splitmap;TransformedSplitMap;true;transformingMap;;;MapValue of Argument[0];MapValue of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the package `org.apache.commons.collections4.trie`.
*/
private class ApacheTrieModel extends SummaryModelCsv {
override predicate row(string row) {
row =
["org.apache.commons.collections4", "org.apache.commons.collections"] +
[
// Note that when lambdas are supported we should have more models for TransformedSplitMap
".trie;PatriciaTrie;true;PatriciaTrie;;;MapKey of Argument[0];MapKey of Argument[-1];value",
".trie;PatriciaTrie;true;PatriciaTrie;;;MapValue of Argument[0];MapValue of Argument[-1];value",
".trie;AbstractPatriciaTrie;true;select;;;MapKey of Argument[-1];MapKey of ReturnValue;value",
".trie;AbstractPatriciaTrie;true;select;;;MapValue of Argument[-1];MapValue of ReturnValue;value",
".trie;AbstractPatriciaTrie;true;selectKey;;;MapKey of Argument[-1];ReturnValue;value",
".trie;AbstractPatriciaTrie;true;selectValue;;;MapValue of Argument[-1];ReturnValue;value",
".trie;UnmodifiableTrie;true;unmodifiableTrie;;;MapKey of Argument[0];MapKey of ReturnValue;value",
".trie;UnmodifiableTrie;true;unmodifiableTrie;;;MapValue of Argument[0];MapValue of ReturnValue;value"
]
}
}
/**
* Value-propagating models for the class `org.apache.commons.collections4.MapUtils`.
*/
@@ -217,7 +792,7 @@ private class ApacheMapUtilsModel extends SummaryModelCsv {
";MapUtils;true;orderedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
";MapUtils;true;orderedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
";MapUtils;true;populateMap;(Map,Iterable,Transformer);;Element of Argument[1];MapValue of Argument[0];value",
";MapUtils;true;populateMap;(MultiMap,Iterable,Transformer);;Element of Argument[1];MapValue of Argument[0];value",
";MapUtils;true;populateMap;(MultiMap,Iterable,Transformer);;Element of Argument[1];Element of MapValue of Argument[0];value",
";MapUtils;true;predicatedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
";MapUtils;true;predicatedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
";MapUtils;true;predicatedSortedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
@@ -488,9 +1063,9 @@ private class ApacheMultiMapUtilsModel extends SummaryModelCsv {
";MultiMapUtils;true;getValuesAsList;;;Element of MapValue of Argument[0];Element of ReturnValue;value",
";MultiMapUtils;true;getValuesAsSet;;;Element of MapValue of Argument[0];Element of ReturnValue;value",
";MultiMapUtils;true;transformedMultiValuedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
";MultiMapUtils;true;transformedMultiValuedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value",
";MultiMapUtils;true;transformedMultiValuedMap;;;Element of MapValue of Argument[0];Element of MapValue of ReturnValue;value",
";MultiMapUtils;true;unmodifiableMultiValuedMap;;;MapKey of Argument[0];MapKey of ReturnValue;value",
";MultiMapUtils;true;unmodifiableMultiValuedMap;;;MapValue of Argument[0];MapValue of ReturnValue;value"
";MultiMapUtils;true;unmodifiableMultiValuedMap;;;Element of MapValue of Argument[0];Element of MapValue of ReturnValue;value"
]
}
}

3883
java/ql/test/library-tests/frameworks/apache-collections/Test.java
View File

File diff suppressed because it is too large Load Diff

5
java/ql/test/library-tests/frameworks/apache-collections/test.ql
View File

@@ -1,7 +1,4 @@
import java
import semmle.code.java.dataflow.DataFlow
import semmle.code.java.dataflow.ExternalFlow
import semmle.code.java.dataflow.TaintTracking
import TestUtilities.InlineFlowTest
class SummaryModelTest extends SummaryModelCsv {
@@ -9,8 +6,6 @@ class SummaryModelTest extends SummaryModelCsv {
row =
[
//"package;type;overrides;name;signature;ext;inputspec;outputspec;kind",
// This is temporarily modelled for the helper function newEnumerationWithElement, until the relevant package is modelled
"org.apache.commons.collections4.iterators;IteratorEnumeration;true;IteratorEnumeration;;;Element of Argument[0];Element of Argument[-1];value",
"generatedtest;Test;false;newRBWithMapValue;;;Argument[0];MapValue of ReturnValue;value",
"generatedtest;Test;false;newRBWithMapKey;;;Argument[0];MapKey of ReturnValue;value"
]

11
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/BoundedCollection.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from org.apache.commons.collections4.BoundedCollection for testing purposes
package org.apache.commons.collections4;
import java.util.Collection;
public interface BoundedCollection<E> extends Collection<E>
{
boolean isFull();
int maxSize();
}

11
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/BoundedMap.java generated Normal file
View File

@@ -0,0 +1,11 @@
// Generated automatically from org.apache.commons.collections4.BoundedMap for testing purposes
package org.apache.commons.collections4;
import org.apache.commons.collections4.IterableMap;
public interface BoundedMap<K, V> extends IterableMap<K, V>
{
boolean isFull();
int maxSize();
}

13
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/SortedBidiMap.java generated Normal file
View File

@@ -0,0 +1,13 @@
// Generated automatically from org.apache.commons.collections4.SortedBidiMap for testing purposes
package org.apache.commons.collections4;
import java.util.Comparator;
import java.util.SortedMap;
import org.apache.commons.collections4.OrderedBidiMap;
public interface SortedBidiMap<K, V> extends OrderedBidiMap<K, V>, SortedMap<K, V>
{
Comparator<? super V> valueComparator();
SortedBidiMap<V, K> inverseBidiMap();
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/AbstractBagDecorator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.bag.AbstractBagDecorator for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Set;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
abstract public class AbstractBagDecorator<E> extends AbstractCollectionDecorator<E> implements Bag<E>
{
protected AbstractBagDecorator(){}
protected AbstractBagDecorator(Bag<E> p0){}
protected Bag<E> decorated(){ return null; }
public Set<E> uniqueSet(){ return null; }
public boolean add(E p0, int p1){ return false; }
public boolean equals(Object p0){ return false; }
public boolean remove(Object p0, int p1){ return false; }
public int getCount(Object p0){ return 0; }
public int hashCode(){ return 0; }
}

2
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/AbstractMapBag.java generated
View File

@@ -39,7 +39,7 @@ abstract public class AbstractMapBag<E> implements Bag<E>
public int hashCode(){ return 0; }
public int size(){ return 0; }
public void clear(){}
static class MutableInteger
protected static class MutableInteger
{
protected MutableInteger() {}
MutableInteger(int p0){}

17
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/AbstractSortedBagDecorator.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from org.apache.commons.collections4.bag.AbstractSortedBagDecorator for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Comparator;
import org.apache.commons.collections4.SortedBag;
import org.apache.commons.collections4.bag.AbstractBagDecorator;
abstract public class AbstractSortedBagDecorator<E> extends AbstractBagDecorator<E> implements SortedBag<E>
{
protected AbstractSortedBagDecorator(){}
protected AbstractSortedBagDecorator(SortedBag<E> p0){}
protected SortedBag<E> decorated(){ return null; }
public Comparator<? super E> comparator(){ return null; }
public E first(){ return null; }
public E last(){ return null; }
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/CollectionBag.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.bag.CollectionBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Collection;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.bag.AbstractBagDecorator;
public class CollectionBag<E> extends AbstractBagDecorator<E>
{
protected CollectionBag() {}
public CollectionBag(Bag<E> p0){}
public boolean add(E p0){ return false; }
public boolean add(E p0, int p1){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <E> Bag<E> collectionBag(Bag<E> p0){ return null; }
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/CollectionSortedBag.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.bag.CollectionSortedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Collection;
import org.apache.commons.collections4.SortedBag;
import org.apache.commons.collections4.bag.AbstractSortedBagDecorator;
public class CollectionSortedBag<E> extends AbstractSortedBagDecorator<E>
{
protected CollectionSortedBag() {}
public CollectionSortedBag(SortedBag<E> p0){}
public boolean add(E p0){ return false; }
public boolean add(E p0, int p1){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <E> SortedBag<E> collectionSortedBag(SortedBag<E> p0){ return null; }
}

13
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/HashBag.java generated Normal file
View File

@@ -0,0 +1,13 @@
// Generated automatically from org.apache.commons.collections4.bag.HashBag for testing purposes
package org.apache.commons.collections4.bag;
import java.io.Serializable;
import java.util.Collection;
import org.apache.commons.collections4.bag.AbstractMapBag;
public class HashBag<E> extends AbstractMapBag<E> implements Serializable
{
public HashBag(){}
public HashBag(Collection<? extends E> p0){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/PredicatedBag.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.bag.PredicatedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Set;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.collection.PredicatedCollection;
public class PredicatedBag<E> extends PredicatedCollection<E> implements Bag<E>
{
protected PredicatedBag() {}
protected Bag<E> decorated(){ return null; }
protected PredicatedBag(Bag<E> p0, Predicate<? super E> p1){}
public Set<E> uniqueSet(){ return null; }
public boolean add(E p0, int p1){ return false; }
public boolean equals(Object p0){ return false; }
public boolean remove(Object p0, int p1){ return false; }
public int getCount(Object p0){ return 0; }
public int hashCode(){ return 0; }
public static <E> PredicatedBag<E> predicatedBag(Bag<E> p0, Predicate<? super E> p1){ return null; }
}

19
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/PredicatedSortedBag.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from org.apache.commons.collections4.bag.PredicatedSortedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Comparator;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.SortedBag;
import org.apache.commons.collections4.bag.PredicatedBag;
public class PredicatedSortedBag<E> extends PredicatedBag<E> implements SortedBag<E>
{
protected PredicatedSortedBag() {}
protected PredicatedSortedBag(SortedBag<E> p0, Predicate<? super E> p1){}
protected SortedBag<E> decorated(){ return null; }
public Comparator<? super E> comparator(){ return null; }
public E first(){ return null; }
public E last(){ return null; }
public static <E> PredicatedSortedBag<E> predicatedSortedBag(SortedBag<E> p0, Predicate<? super E> p1){ return null; }
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/SynchronizedBag.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.bag.SynchronizedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Set;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.collection.SynchronizedCollection;
public class SynchronizedBag<E> extends SynchronizedCollection<E> implements Bag<E>
{
protected SynchronizedBag() {}
protected Bag<E> getBag(){ return null; }
protected SynchronizedBag(Bag<E> p0){}
protected SynchronizedBag(Bag<E> p0, Object p1){}
public Set<E> uniqueSet(){ return null; }
public boolean add(E p0, int p1){ return false; }
public boolean equals(Object p0){ return false; }
public boolean remove(Object p0, int p1){ return false; }
public int getCount(Object p0){ return 0; }
public int hashCode(){ return 0; }
public static <E> SynchronizedBag<E> synchronizedBag(Bag<E> p0){ return null; }
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/SynchronizedSortedBag.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.bag.SynchronizedSortedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Comparator;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.SortedBag;
import org.apache.commons.collections4.bag.SynchronizedBag;
public class SynchronizedSortedBag<E> extends SynchronizedBag<E> implements SortedBag<E>
{
protected SynchronizedSortedBag() {}
protected SortedBag<E> getSortedBag(){ return null; }
protected SynchronizedSortedBag(Bag<E> p0, Object p1){}
protected SynchronizedSortedBag(SortedBag<E> p0){}
public Comparator<? super E> comparator(){ return null; }
public E first(){ return null; }
public E last(){ return null; }
public static <E> SynchronizedSortedBag<E> synchronizedSortedBag(SortedBag<E> p0){ return null; }
}

23
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/TransformedBag.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from org.apache.commons.collections4.bag.TransformedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Set;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.collection.TransformedCollection;
public class TransformedBag<E> extends TransformedCollection<E> implements Bag<E>
{
protected TransformedBag() {}
protected Bag<E> getBag(){ return null; }
protected TransformedBag(Bag<E> p0, Transformer<? super E, ? extends E> p1){}
public Set<E> uniqueSet(){ return null; }
public boolean add(E p0, int p1){ return false; }
public boolean equals(Object p0){ return false; }
public boolean remove(Object p0, int p1){ return false; }
public int getCount(Object p0){ return 0; }
public int hashCode(){ return 0; }
public static <E> Bag<E> transformedBag(Bag<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
public static <E> Bag<E> transformingBag(Bag<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/TransformedSortedBag.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.bag.TransformedSortedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Comparator;
import org.apache.commons.collections4.SortedBag;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.bag.TransformedBag;
public class TransformedSortedBag<E> extends TransformedBag<E> implements SortedBag<E>
{
protected TransformedSortedBag() {}
protected SortedBag<E> getSortedBag(){ return null; }
protected TransformedSortedBag(SortedBag<E> p0, Transformer<? super E, ? extends E> p1){}
public Comparator<? super E> comparator(){ return null; }
public E first(){ return null; }
public E last(){ return null; }
public static <E> TransformedSortedBag<E> transformedSortedBag(SortedBag<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
public static <E> TransformedSortedBag<E> transformingSortedBag(SortedBag<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
}

28
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/UnmodifiableBag.java generated Normal file
View File

@@ -0,0 +1,28 @@
// Generated automatically from org.apache.commons.collections4.bag.UnmodifiableBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Predicate;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.bag.AbstractBagDecorator;
public class UnmodifiableBag<E> extends AbstractBagDecorator<E> implements Unmodifiable
{
protected UnmodifiableBag() {}
public Iterator<E> iterator(){ return null; }
public Set<E> uniqueSet(){ return null; }
public boolean add(E p0){ return false; }
public boolean add(E p0, int p1){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean remove(Object p0, int p1){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <E> Bag<E> unmodifiableBag(Bag<? extends E> p0){ return null; }
public void clear(){}
}

28
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bag/UnmodifiableSortedBag.java generated Normal file
View File

@@ -0,0 +1,28 @@
// Generated automatically from org.apache.commons.collections4.bag.UnmodifiableSortedBag for testing purposes
package org.apache.commons.collections4.bag;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Predicate;
import org.apache.commons.collections4.SortedBag;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.bag.AbstractSortedBagDecorator;
public class UnmodifiableSortedBag<E> extends AbstractSortedBagDecorator<E> implements Unmodifiable
{
protected UnmodifiableSortedBag() {}
public Iterator<E> iterator(){ return null; }
public Set<E> uniqueSet(){ return null; }
public boolean add(E p0){ return false; }
public boolean add(E p0, int p1){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean remove(Object p0, int p1){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <E> SortedBag<E> unmodifiableSortedBag(SortedBag<E> p0){ return null; }
public void clear(){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/AbstractBidiMapDecorator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.bidimap.AbstractBidiMapDecorator for testing purposes
package org.apache.commons.collections4.bidimap;
import java.util.Set;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.map.AbstractMapDecorator;
abstract public class AbstractBidiMapDecorator<K, V> extends AbstractMapDecorator<K, V> implements BidiMap<K, V>
{
protected AbstractBidiMapDecorator() {}
protected AbstractBidiMapDecorator(BidiMap<K, V> p0){}
protected BidiMap<K, V> decorated(){ return null; }
public BidiMap<V, K> inverseBidiMap(){ return null; }
public K getKey(Object p0){ return null; }
public K removeValue(Object p0){ return null; }
public MapIterator<K, V> mapIterator(){ return null; }
public Set<V> values(){ return null; }
}

39
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java generated Normal file
View File

@@ -0,0 +1,39 @@
// Generated automatically from org.apache.commons.collections4.bidimap.AbstractDualBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.MapIterator;
abstract public class AbstractDualBidiMap<K, V> implements BidiMap<K, V>
{
protected AbstractDualBidiMap(){}
protected AbstractDualBidiMap(Map<K, V> p0, Map<V, K> p1){}
protected AbstractDualBidiMap(Map<K, V> p0, Map<V, K> p1, BidiMap<V, K> p2){}
protected Iterator<K> createKeySetIterator(Iterator<K> p0){ return null; }
protected Iterator<Map.Entry<K, V>> createEntrySetIterator(Iterator<Map.Entry<K, V>> p0){ return null; }
protected Iterator<V> createValuesIterator(Iterator<V> p0){ return null; }
protected abstract BidiMap<V, K> createBidiMap(Map<V, K> p0, Map<K, V> p1, BidiMap<K, V> p2);
public BidiMap<V, K> inverseBidiMap(){ return null; }
public K getKey(Object p0){ return null; }
public K removeValue(Object p0){ return null; }
public MapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public Set<V> values(){ return null; }
public String toString(){ return null; }
public V get(Object p0){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public boolean containsKey(Object p0){ return false; }
public boolean containsValue(Object p0){ return false; }
public boolean equals(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public int hashCode(){ return 0; }
public int size(){ return 0; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/AbstractOrderedBidiMapDecorator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.bidimap.AbstractOrderedBidiMapDecorator for testing purposes
package org.apache.commons.collections4.bidimap;
import org.apache.commons.collections4.OrderedBidiMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.bidimap.AbstractBidiMapDecorator;
abstract public class AbstractOrderedBidiMapDecorator<K, V> extends AbstractBidiMapDecorator<K, V> implements OrderedBidiMap<K, V>
{
protected AbstractOrderedBidiMapDecorator() {}
protected AbstractOrderedBidiMapDecorator(OrderedBidiMap<K, V> p0){}
protected OrderedBidiMap<K, V> decorated(){ return null; }
public K firstKey(){ return null; }
public K lastKey(){ return null; }
public K nextKey(K p0){ return null; }
public K previousKey(K p0){ return null; }
public OrderedBidiMap<V, K> inverseBidiMap(){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/AbstractSortedBidiMapDecorator.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.bidimap.AbstractSortedBidiMapDecorator for testing purposes
package org.apache.commons.collections4.bidimap;
import java.util.Comparator;
import java.util.SortedMap;
import org.apache.commons.collections4.SortedBidiMap;
import org.apache.commons.collections4.bidimap.AbstractOrderedBidiMapDecorator;
abstract public class AbstractSortedBidiMapDecorator<K, V> extends AbstractOrderedBidiMapDecorator<K, V> implements SortedBidiMap<K, V>
{
protected AbstractSortedBidiMapDecorator() {}
protected SortedBidiMap<K, V> decorated(){ return null; }
public AbstractSortedBidiMapDecorator(SortedBidiMap<K, V> p0){}
public Comparator<? super K> comparator(){ return null; }
public Comparator<? super V> valueComparator(){ return null; }
public SortedBidiMap<V, K> inverseBidiMap(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
}

16
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/DualHashBidiMap.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from org.apache.commons.collections4.bidimap.DualHashBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.bidimap.AbstractDualBidiMap;
public class DualHashBidiMap<K, V> extends AbstractDualBidiMap<K, V> implements Serializable
{
protected BidiMap<V, K> createBidiMap(Map<V, K> p0, Map<K, V> p1, BidiMap<K, V> p2){ return null; }
protected DualHashBidiMap(Map<K, V> p0, Map<V, K> p1, BidiMap<V, K> p2){}
public DualHashBidiMap(){}
public DualHashBidiMap(Map<? extends K, ? extends V> p0){}
}

16
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/DualLinkedHashBidiMap.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from org.apache.commons.collections4.bidimap.DualLinkedHashBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.bidimap.AbstractDualBidiMap;
public class DualLinkedHashBidiMap<K, V> extends AbstractDualBidiMap<K, V> implements Serializable
{
protected BidiMap<V, K> createBidiMap(Map<V, K> p0, Map<K, V> p1, BidiMap<K, V> p2){ return null; }
protected DualLinkedHashBidiMap(Map<K, V> p0, Map<V, K> p1, BidiMap<V, K> p2){}
public DualLinkedHashBidiMap(){}
public DualLinkedHashBidiMap(Map<? extends K, ? extends V> p0){}
}

35
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/DualTreeBidiMap.java generated Normal file
View File

@@ -0,0 +1,35 @@
// Generated automatically from org.apache.commons.collections4.bidimap.DualTreeBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.io.Serializable;
import java.util.Comparator;
import java.util.Map;
import java.util.SortedMap;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.OrderedBidiMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.SortedBidiMap;
import org.apache.commons.collections4.bidimap.AbstractDualBidiMap;
public class DualTreeBidiMap<K, V> extends AbstractDualBidiMap<K, V> implements Serializable, SortedBidiMap<K, V>
{
protected DualTreeBidiMap(Map<K, V> p0, Map<V, K> p1, BidiMap<V, K> p2){}
protected DualTreeBidiMap<V, K> createBidiMap(Map<V, K> p0, Map<K, V> p1, BidiMap<K, V> p2){ return null; }
public Comparator<? super K> comparator(){ return null; }
public Comparator<? super V> valueComparator(){ return null; }
public DualTreeBidiMap(){}
public DualTreeBidiMap(Comparator<? super K> p0, Comparator<? super V> p1){}
public DualTreeBidiMap(Map<? extends K, ? extends V> p0){}
public K firstKey(){ return null; }
public K lastKey(){ return null; }
public K nextKey(K p0){ return null; }
public K previousKey(K p0){ return null; }
public OrderedBidiMap<V, K> inverseOrderedBidiMap(){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
public SortedBidiMap<V, K> inverseBidiMap(){ return null; }
public SortedBidiMap<V, K> inverseSortedBidiMap(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
}

26
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/UnmodifiableBidiMap.java generated Normal file
View File

@@ -0,0 +1,26 @@
// Generated automatically from org.apache.commons.collections4.bidimap.UnmodifiableBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.bidimap.AbstractBidiMapDecorator;
public class UnmodifiableBidiMap<K, V> extends AbstractBidiMapDecorator<K, V> implements Unmodifiable
{
protected UnmodifiableBidiMap() {}
public BidiMap<V, K> inverseBidiMap(){ return null; }
public K removeValue(Object p0){ return null; }
public MapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public Set<V> values(){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public static <K, V> BidiMap<K, V> unmodifiableBidiMap(BidiMap<? extends K, ? extends V> p0){ return null; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

27
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/UnmodifiableOrderedBidiMap.java generated Normal file
View File

@@ -0,0 +1,27 @@
// Generated automatically from org.apache.commons.collections4.bidimap.UnmodifiableOrderedBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.OrderedBidiMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.bidimap.AbstractOrderedBidiMapDecorator;
public class UnmodifiableOrderedBidiMap<K, V> extends AbstractOrderedBidiMapDecorator<K, V> implements Unmodifiable
{
protected UnmodifiableOrderedBidiMap() {}
public K removeValue(Object p0){ return null; }
public OrderedBidiMap<V, K> inverseBidiMap(){ return null; }
public OrderedBidiMap<V, K> inverseOrderedBidiMap(){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public Set<V> values(){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public static <K, V> OrderedBidiMap<K, V> unmodifiableOrderedBidiMap(OrderedBidiMap<? extends K, ? extends V> p0){ return null; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

30
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/bidimap/UnmodifiableSortedBidiMap.java generated Normal file
View File

@@ -0,0 +1,30 @@
// Generated automatically from org.apache.commons.collections4.bidimap.UnmodifiableSortedBidiMap for testing purposes
package org.apache.commons.collections4.bidimap;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.SortedBidiMap;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.bidimap.AbstractSortedBidiMapDecorator;
public class UnmodifiableSortedBidiMap<K, V> extends AbstractSortedBidiMapDecorator<K, V> implements Unmodifiable
{
protected UnmodifiableSortedBidiMap() {}
public K removeValue(Object p0){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public Set<V> values(){ return null; }
public SortedBidiMap<V, K> inverseBidiMap(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public static <K, V> SortedBidiMap<K, V> unmodifiableSortedBidiMap(SortedBidiMap<K, ? extends V> p0){ return null; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

31
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java generated Normal file
View File

@@ -0,0 +1,31 @@
// Generated automatically from org.apache.commons.collections4.collection.AbstractCollectionDecorator for testing purposes
package org.apache.commons.collections4.collection;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Predicate;
abstract public class AbstractCollectionDecorator<E> implements Collection<E>, Serializable
{
protected AbstractCollectionDecorator(){}
protected AbstractCollectionDecorator(Collection<E> p0){}
protected Collection<E> decorated(){ return null; }
protected void setCollection(Collection<E> p0){}
public <T> T[] toArray(T[] p0){ return null; }
public Iterator<E> iterator(){ return null; }
public Object[] toArray(){ return null; }
public String toString(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean contains(Object p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean isEmpty(){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public int size(){ return 0; }
public void clear(){}
}

45
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/CompositeCollection.java generated Normal file
View File

@@ -0,0 +1,45 @@
// Generated automatically from org.apache.commons.collections4.collection.CompositeCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.function.Predicate;
public class CompositeCollection<E> implements Collection<E>, Serializable
{
protected CompositeCollection.CollectionMutator<E> getMutator(){ return null; }
public <T> T[] toArray(T[] p0){ return null; }
public Collection<E> toCollection(){ return null; }
public CompositeCollection(){}
public CompositeCollection(Collection<E> p0){}
public CompositeCollection(Collection<E> p0, Collection<E> p1){}
public CompositeCollection(Collection<E>... p0){}
public Iterator<E> iterator(){ return null; }
public List<Collection<E>> getCollections(){ return null; }
public Object[] toArray(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean contains(Object p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean isEmpty(){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public int size(){ return 0; }
public void addComposited(Collection<E> p0){}
public void addComposited(Collection<E> p0, Collection<E> p1){}
public void addComposited(Collection<E>... p0){}
public void clear(){}
public void removeComposited(Collection<E> p0){}
public void setMutator(CompositeCollection.CollectionMutator<E> p0){}
static public interface CollectionMutator<E> extends Serializable
{
boolean add(CompositeCollection<E> p0, List<Collection<E>> p1, E p2);
boolean addAll(CompositeCollection<E> p0, List<Collection<E>> p1, Collection<? extends E> p2);
boolean remove(CompositeCollection<E> p0, List<Collection<E>> p1, Object p2);
}
}

29
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/IndexedCollection.java generated Normal file
View File

@@ -0,0 +1,29 @@
// Generated automatically from org.apache.commons.collections4.collection.IndexedCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.util.Collection;
import java.util.function.Predicate;
import org.apache.commons.collections4.MultiMap;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
public class IndexedCollection<K, C> extends AbstractCollectionDecorator<C>
{
protected IndexedCollection() {}
public C get(K p0){ return null; }
public Collection<C> values(K p0){ return null; }
public IndexedCollection(Collection<C> p0, Transformer<C, K> p1, MultiMap<K, C> p2, boolean p3){}
public boolean add(C p0){ return false; }
public boolean addAll(Collection<? extends C> p0){ return false; }
public boolean contains(Object p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super C> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <K, C> IndexedCollection<K, C> nonUniqueIndexedCollection(Collection<C> p0, Transformer<C, K> p1){ return null; }
public static <K, C> IndexedCollection<K, C> uniqueIndexedCollection(Collection<C> p0, Transformer<C, K> p1){ return null; }
public void clear(){}
public void reindex(){}
}

43
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/PredicatedCollection.java generated Normal file
View File

@@ -0,0 +1,43 @@
// Generated automatically from org.apache.commons.collections4.collection.PredicatedCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.util.Collection;
import java.util.List;
import java.util.Queue;
import java.util.Set;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.MultiSet;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
public class PredicatedCollection<E> extends AbstractCollectionDecorator<E>
{
protected PredicatedCollection() {}
protected PredicatedCollection(Collection<E> p0, Predicate<? super E> p1){}
protected final Predicate<? super E> predicate = null;
protected void validate(E p0){}
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public static <E> PredicatedCollection.Builder<E> builder(Predicate<? super E> p0){ return null; }
public static <E> PredicatedCollection.Builder<E> notNullBuilder(){ return null; }
public static <T> PredicatedCollection<T> predicatedCollection(Collection<T> p0, Predicate<? super T> p1){ return null; }
static public class Builder<E>
{
protected Builder() {}
public Bag<E> createPredicatedBag(){ return null; }
public Bag<E> createPredicatedBag(Bag<E> p0){ return null; }
public Builder(Predicate<? super E> p0){}
public Collection<E> rejectedElements(){ return null; }
public List<E> createPredicatedList(){ return null; }
public List<E> createPredicatedList(List<E> p0){ return null; }
public MultiSet<E> createPredicatedMultiSet(){ return null; }
public MultiSet<E> createPredicatedMultiSet(MultiSet<E> p0){ return null; }
public PredicatedCollection.Builder<E> add(E p0){ return null; }
public PredicatedCollection.Builder<E> addAll(Collection<? extends E> p0){ return null; }
public Queue<E> createPredicatedQueue(){ return null; }
public Queue<E> createPredicatedQueue(Queue<E> p0){ return null; }
public Set<E> createPredicatedSet(){ return null; }
public Set<E> createPredicatedSet(Set<E> p0){ return null; }
}
}

35
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/SynchronizedCollection.java generated Normal file
View File

@@ -0,0 +1,35 @@
// Generated automatically from org.apache.commons.collections4.collection.SynchronizedCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Predicate;
public class SynchronizedCollection<E> implements Collection<E>, Serializable
{
protected SynchronizedCollection() {}
protected Collection<E> decorated(){ return null; }
protected SynchronizedCollection(Collection<E> p0){}
protected SynchronizedCollection(Collection<E> p0, Object p1){}
protected final Object lock = null;
public <T> T[] toArray(T[] p0){ return null; }
public Iterator<E> iterator(){ return null; }
public Object[] toArray(){ return null; }
public String toString(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean contains(Object p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean equals(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public int hashCode(){ return 0; }
public int size(){ return 0; }
public static <T> SynchronizedCollection<T> synchronizedCollection(Collection<T> p0){ return null; }
public void clear(){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/TransformedCollection.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.collection.TransformedCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.util.Collection;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
public class TransformedCollection<E> extends AbstractCollectionDecorator<E>
{
protected TransformedCollection() {}
protected Collection<E> transform(Collection<? extends E> p0){ return null; }
protected E transform(E p0){ return null; }
protected TransformedCollection(Collection<E> p0, Transformer<? super E, ? extends E> p1){}
protected final Transformer<? super E, ? extends E> transformer = null;
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public static <E> TransformedCollection<E> transformedCollection(Collection<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
public static <E> TransformedCollection<E> transformingCollection(Collection<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
}

28
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/UnmodifiableBoundedCollection.java generated Normal file
View File

@@ -0,0 +1,28 @@
// Generated automatically from org.apache.commons.collections4.collection.UnmodifiableBoundedCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Predicate;
import org.apache.commons.collections4.BoundedCollection;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
public class UnmodifiableBoundedCollection<E> extends AbstractCollectionDecorator<E> implements BoundedCollection<E>, Unmodifiable
{
protected UnmodifiableBoundedCollection() {}
protected BoundedCollection<E> decorated(){ return null; }
public Iterator<E> iterator(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean isFull(){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public int maxSize(){ return 0; }
public static <E> BoundedCollection<E> unmodifiableBoundedCollection(BoundedCollection<? extends E> p0){ return null; }
public static <E> BoundedCollection<E> unmodifiableBoundedCollection(Collection<? extends E> p0){ return null; }
public void clear(){}
}

23
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/collection/UnmodifiableCollection.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from org.apache.commons.collections4.collection.UnmodifiableCollection for testing purposes
package org.apache.commons.collections4.collection;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Predicate;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
public class UnmodifiableCollection<E> extends AbstractCollectionDecorator<E> implements Unmodifiable
{
protected UnmodifiableCollection() {}
public Iterator<E> iterator(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> p0){ return null; }
public void clear(){}
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/AbstractListIteratorDecorator.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.iterators.AbstractListIteratorDecorator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.ListIterator;
public class AbstractListIteratorDecorator<E> implements ListIterator<E>
{
protected AbstractListIteratorDecorator() {}
protected ListIterator<E> getListIterator(){ return null; }
public AbstractListIteratorDecorator(ListIterator<E> p0){}
public E next(){ return null; }
public E previous(){ return null; }
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void remove(){}
public void set(E p0){}
}

18
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/AbstractMapIteratorDecorator.java generated Normal file
View File

@@ -0,0 +1,18 @@
// Generated automatically from org.apache.commons.collections4.iterators.AbstractMapIteratorDecorator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.MapIterator;
public class AbstractMapIteratorDecorator<K, V> implements MapIterator<K, V>
{
protected AbstractMapIteratorDecorator() {}
protected MapIterator<K, V> getMapIterator(){ return null; }
public AbstractMapIteratorDecorator(MapIterator<K, V> p0){}
public K getKey(){ return null; }
public K next(){ return null; }
public V getValue(){ return null; }
public V setValue(V p0){ return null; }
public boolean hasNext(){ return false; }
public void remove(){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/AbstractOrderedMapIteratorDecorator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.iterators.AbstractOrderedMapIteratorDecorator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.OrderedMapIterator;
public class AbstractOrderedMapIteratorDecorator<K, V> implements OrderedMapIterator<K, V>
{
protected AbstractOrderedMapIteratorDecorator() {}
protected OrderedMapIterator<K, V> getOrderedMapIterator(){ return null; }
public AbstractOrderedMapIteratorDecorator(OrderedMapIterator<K, V> p0){}
public K getKey(){ return null; }
public K next(){ return null; }
public K previous(){ return null; }
public V getValue(){ return null; }
public V setValue(V p0){ return null; }
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public void remove(){}
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/ArrayIterator.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.iterators.ArrayIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.ResettableIterator;
public class ArrayIterator<E> implements ResettableIterator<E>
{
protected ArrayIterator() {}
protected void checkBound(int p0, int p1, String p2){}
public ArrayIterator(Object p0){}
public ArrayIterator(Object p0, int p1){}
public ArrayIterator(Object p0, int p1, int p2){}
public E next(){ return null; }
public Object getArray(){ return null; }
public boolean hasNext(){ return false; }
public int getEndIndex(){ return 0; }
public int getStartIndex(){ return 0; }
public void remove(){}
public void reset(){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/ArrayListIterator.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.iterators.ArrayListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.ResettableListIterator;
import org.apache.commons.collections4.iterators.ArrayIterator;
public class ArrayListIterator<E> extends ArrayIterator<E> implements ResettableListIterator<E>
{
protected ArrayListIterator() {}
public ArrayListIterator(Object p0){}
public ArrayListIterator(Object p0, int p1){}
public ArrayListIterator(Object p0, int p1, int p2){}
public E next(){ return null; }
public E previous(){ return null; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(Object p0){}
public void reset(){}
public void set(Object p0){}
}

27
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/CollatingIterator.java generated Normal file
View File

@@ -0,0 +1,27 @@
// Generated automatically from org.apache.commons.collections4.iterators.CollatingIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
public class CollatingIterator<E> implements Iterator<E>
{
public CollatingIterator(){}
public CollatingIterator(Comparator<? super E> p0){}
public CollatingIterator(Comparator<? super E> p0, Collection<Iterator<? extends E>> p1){}
public CollatingIterator(Comparator<? super E> p0, Iterator<? extends E> p1, Iterator<? extends E> p2){}
public CollatingIterator(Comparator<? super E> p0, Iterator<? extends E>[] p1){}
public CollatingIterator(Comparator<? super E> p0, int p1){}
public Comparator<? super E> getComparator(){ return null; }
public E next(){ return null; }
public List<Iterator<? extends E>> getIterators(){ return null; }
public boolean hasNext(){ return false; }
public int getIteratorIndex(){ return 0; }
public void addIterator(Iterator<? extends E> p0){}
public void remove(){}
public void setComparator(Comparator<? super E> p0){}
public void setIterator(int p0, Iterator<? extends E> p1){}
}

19
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/EnumerationIterator.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from org.apache.commons.collections4.iterators.EnumerationIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
public class EnumerationIterator<E> implements Iterator<E>
{
public E next(){ return null; }
public Enumeration<? extends E> getEnumeration(){ return null; }
public EnumerationIterator(){}
public EnumerationIterator(Enumeration<? extends E> p0){}
public EnumerationIterator(Enumeration<? extends E> p0, Collection<? super E> p1){}
public boolean hasNext(){ return false; }
public void remove(){}
public void setEnumeration(Enumeration<? extends E> p0){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/FilterIterator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.iterators.FilterIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
import org.apache.commons.collections4.Predicate;
public class FilterIterator<E> implements Iterator<E>
{
public E next(){ return null; }
public FilterIterator(){}
public FilterIterator(Iterator<? extends E> p0){}
public FilterIterator(Iterator<? extends E> p0, Predicate<? super E> p1){}
public Iterator<? extends E> getIterator(){ return null; }
public Predicate<? super E> getPredicate(){ return null; }
public boolean hasNext(){ return false; }
public void remove(){}
public void setIterator(Iterator<? extends E> p0){}
public void setPredicate(Predicate<? super E> p0){}
}

27
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/FilterListIterator.java generated Normal file
View File

@@ -0,0 +1,27 @@
// Generated automatically from org.apache.commons.collections4.iterators.FilterListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.ListIterator;
import org.apache.commons.collections4.Predicate;
public class FilterListIterator<E> implements ListIterator<E>
{
public E next(){ return null; }
public E previous(){ return null; }
public FilterListIterator(){}
public FilterListIterator(ListIterator<? extends E> p0){}
public FilterListIterator(ListIterator<? extends E> p0, Predicate<? super E> p1){}
public FilterListIterator(Predicate<? super E> p0){}
public ListIterator<? extends E> getListIterator(){ return null; }
public Predicate<? super E> getPredicate(){ return null; }
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void remove(){}
public void set(E p0){}
public void setListIterator(ListIterator<? extends E> p0){}
public void setPredicate(Predicate<? super E> p0){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/IteratorChain.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.iterators.IteratorChain for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Collection;
import java.util.Iterator;
public class IteratorChain<E> implements Iterator<E>
{
protected void updateCurrentIterator(){}
public E next(){ return null; }
public IteratorChain(){}
public IteratorChain(Collection<Iterator<? extends E>> p0){}
public IteratorChain(Iterator<? extends E> p0){}
public IteratorChain(Iterator<? extends E> p0, Iterator<? extends E> p1){}
public IteratorChain(Iterator<? extends E>... p0){}
public boolean hasNext(){ return false; }
public boolean isLocked(){ return false; }
public int size(){ return 0; }
public void addIterator(Iterator<? extends E> p0){}
public void remove(){}
}

13
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/IteratorIterable.java generated Normal file
View File

@@ -0,0 +1,13 @@
// Generated automatically from org.apache.commons.collections4.iterators.IteratorIterable for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
public class IteratorIterable<E> implements Iterable<E>
{
protected IteratorIterable() {}
public Iterator<E> iterator(){ return null; }
public IteratorIterable(Iterator<? extends E> p0){}
public IteratorIterable(Iterator<? extends E> p0, boolean p1){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/ListIteratorWrapper.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.iterators.ListIteratorWrapper for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
import org.apache.commons.collections4.ResettableListIterator;
public class ListIteratorWrapper<E> implements ResettableListIterator<E>
{
protected ListIteratorWrapper() {}
public E next(){ return null; }
public E previous(){ return null; }
public ListIteratorWrapper(Iterator<? extends E> p0){}
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void remove(){}
public void reset(){}
public void set(E p0){}
}

17
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/LoopingIterator.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from org.apache.commons.collections4.iterators.LoopingIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Collection;
import org.apache.commons.collections4.ResettableIterator;
public class LoopingIterator<E> implements ResettableIterator<E>
{
protected LoopingIterator() {}
public E next(){ return null; }
public LoopingIterator(Collection<? extends E> p0){}
public boolean hasNext(){ return false; }
public int size(){ return 0; }
public void remove(){}
public void reset(){}
}

23
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/LoopingListIterator.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from org.apache.commons.collections4.iterators.LoopingListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.List;
import org.apache.commons.collections4.ResettableListIterator;
public class LoopingListIterator<E> implements ResettableListIterator<E>
{
protected LoopingListIterator() {}
public E next(){ return null; }
public E previous(){ return null; }
public LoopingListIterator(List<E> p0){}
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public int size(){ return 0; }
public void add(E p0){}
public void remove(){}
public void reset(){}
public void set(E p0){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/ObjectArrayIterator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.iterators.ObjectArrayIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.ResettableIterator;
public class ObjectArrayIterator<E> implements ResettableIterator<E>
{
protected ObjectArrayIterator() {}
public E next(){ return null; }
public E[] getArray(){ return null; }
public ObjectArrayIterator(E... p0){}
public ObjectArrayIterator(E[] p0, int p1){}
public ObjectArrayIterator(E[] p0, int p1, int p2){}
public boolean hasNext(){ return false; }
public int getEndIndex(){ return 0; }
public int getStartIndex(){ return 0; }
public void remove(){}
public void reset(){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/ObjectArrayListIterator.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.iterators.ObjectArrayListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.ResettableListIterator;
import org.apache.commons.collections4.iterators.ObjectArrayIterator;
public class ObjectArrayListIterator<E> extends ObjectArrayIterator<E> implements ResettableListIterator<E>
{
protected ObjectArrayListIterator() {}
public E next(){ return null; }
public E previous(){ return null; }
public ObjectArrayListIterator(E... p0){}
public ObjectArrayListIterator(E[] p0, int p1){}
public ObjectArrayListIterator(E[] p0, int p1, int p2){}
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void reset(){}
public void set(E p0){}
}

17
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/PeekingIterator.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from org.apache.commons.collections4.iterators.PeekingIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
public class PeekingIterator<E> implements Iterator<E>
{
protected PeekingIterator() {}
public E element(){ return null; }
public E next(){ return null; }
public E peek(){ return null; }
public PeekingIterator(Iterator<? extends E> p0){}
public boolean hasNext(){ return false; }
public static <E> PeekingIterator<E> peekingIterator(Iterator<? extends E> p0){ return null; }
public void remove(){}
}

16
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/PermutationIterator.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from org.apache.commons.collections4.iterators.PermutationIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
public class PermutationIterator<E> implements Iterator<List<E>>
{
protected PermutationIterator() {}
public List<E> next(){ return null; }
public PermutationIterator(Collection<? extends E> p0){}
public boolean hasNext(){ return false; }
public void remove(){}
}

16
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/PushbackIterator.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from org.apache.commons.collections4.iterators.PushbackIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
public class PushbackIterator<E> implements Iterator<E>
{
protected PushbackIterator() {}
public E next(){ return null; }
public PushbackIterator(Iterator<? extends E> p0){}
public boolean hasNext(){ return false; }
public static <E> PushbackIterator<E> pushbackIterator(Iterator<? extends E> p0){ return null; }
public void pushback(E p0){}
public void remove(){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/ReverseListIterator.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.iterators.ReverseListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.List;
import org.apache.commons.collections4.ResettableListIterator;
public class ReverseListIterator<E> implements ResettableListIterator<E>
{
protected ReverseListIterator() {}
public E next(){ return null; }
public E previous(){ return null; }
public ReverseListIterator(List<E> p0){}
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void remove(){}
public void reset(){}
public void set(E p0){}
}

16
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/SingletonIterator.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from org.apache.commons.collections4.iterators.SingletonIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.ResettableIterator;
public class SingletonIterator<E> implements ResettableIterator<E>
{
protected SingletonIterator() {}
public E next(){ return null; }
public SingletonIterator(E p0){}
public SingletonIterator(E p0, boolean p1){}
public boolean hasNext(){ return false; }
public void remove(){}
public void reset(){}
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/SingletonListIterator.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.iterators.SingletonListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.ResettableListIterator;
public class SingletonListIterator<E> implements ResettableListIterator<E>
{
protected SingletonListIterator() {}
public E next(){ return null; }
public E previous(){ return null; }
public SingletonListIterator(E p0){}
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void remove(){}
public void reset(){}
public void set(E p0){}
}

12
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/UniqueFilterIterator.java generated Normal file
View File

@@ -0,0 +1,12 @@
// Generated automatically from org.apache.commons.collections4.iterators.UniqueFilterIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
import org.apache.commons.collections4.iterators.FilterIterator;
public class UniqueFilterIterator<E> extends FilterIterator<E>
{
protected UniqueFilterIterator() {}
public UniqueFilterIterator(Iterator<? extends E> p0){}
}

15
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/UnmodifiableIterator.java generated Normal file
View File

@@ -0,0 +1,15 @@
// Generated automatically from org.apache.commons.collections4.iterators.UnmodifiableIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.Iterator;
import org.apache.commons.collections4.Unmodifiable;
public class UnmodifiableIterator<E> implements Iterator<E>, Unmodifiable
{
protected UnmodifiableIterator() {}
public E next(){ return null; }
public boolean hasNext(){ return false; }
public static <E> Iterator<E> unmodifiableIterator(Iterator<? extends E> p0){ return null; }
public void remove(){}
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/UnmodifiableListIterator.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.iterators.UnmodifiableListIterator for testing purposes
package org.apache.commons.collections4.iterators;
import java.util.ListIterator;
import org.apache.commons.collections4.Unmodifiable;
public class UnmodifiableListIterator<E> implements ListIterator<E>, Unmodifiable
{
protected UnmodifiableListIterator() {}
public E next(){ return null; }
public E previous(){ return null; }
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public static <E> ListIterator<E> umodifiableListIterator(ListIterator<? extends E> p0){ return null; }
public void add(E p0){}
public void remove(){}
public void set(E p0){}
}

18
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/UnmodifiableMapIterator.java generated Normal file
View File

@@ -0,0 +1,18 @@
// Generated automatically from org.apache.commons.collections4.iterators.UnmodifiableMapIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.Unmodifiable;
public class UnmodifiableMapIterator<K, V> implements MapIterator<K, V>, Unmodifiable
{
protected UnmodifiableMapIterator() {}
public K getKey(){ return null; }
public K next(){ return null; }
public V getValue(){ return null; }
public V setValue(V p0){ return null; }
public boolean hasNext(){ return false; }
public static <K, V> MapIterator<K, V> unmodifiableMapIterator(MapIterator<? extends K, ? extends V> p0){ return null; }
public void remove(){}
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/iterators/UnmodifiableOrderedMapIterator.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.iterators.UnmodifiableOrderedMapIterator for testing purposes
package org.apache.commons.collections4.iterators;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.Unmodifiable;
public class UnmodifiableOrderedMapIterator<K, V> implements OrderedMapIterator<K, V>, Unmodifiable
{
protected UnmodifiableOrderedMapIterator() {}
public K getKey(){ return null; }
public K next(){ return null; }
public K previous(){ return null; }
public V getValue(){ return null; }
public V setValue(V p0){ return null; }
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public static <K, V> OrderedMapIterator<K, V> unmodifiableOrderedMapIterator(OrderedMapIterator<K, ? extends V> p0){ return null; }
public void remove(){}
}

23
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/keyvalue/MultiKey.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from org.apache.commons.collections4.keyvalue.MultiKey for testing purposes
package org.apache.commons.collections4.keyvalue;
import java.io.Serializable;
public class MultiKey<K> implements Serializable
{
protected MultiKey() {}
protected Object readResolve(){ return null; }
public K getKey(int p0){ return null; }
public K[] getKeys(){ return null; }
public MultiKey(K p0, K p1){}
public MultiKey(K p0, K p1, K p2){}
public MultiKey(K p0, K p1, K p2, K p3){}
public MultiKey(K p0, K p1, K p2, K p3, K p4){}
public MultiKey(K[] p0){}
public MultiKey(K[] p0, boolean p1){}
public String toString(){ return null; }
public boolean equals(Object p0){ return false; }
public int hashCode(){ return 0; }
public int size(){ return 0; }
}

119
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/AbstractLinkedList.java generated Normal file
View File

@@ -0,0 +1,119 @@
// Generated automatically from org.apache.commons.collections4.list.AbstractLinkedList for testing purposes
package org.apache.commons.collections4.list;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import org.apache.commons.collections4.OrderedIterator;
abstract public class AbstractLinkedList<E> implements List<E>
{
protected AbstractLinkedList(){}
protected AbstractLinkedList(Collection<? extends E> p0){}
protected AbstractLinkedList.Node<E> createHeaderNode(){ return null; }
protected AbstractLinkedList.Node<E> createNode(E p0){ return null; }
protected AbstractLinkedList.Node<E> getNode(int p0, boolean p1){ return null; }
protected Iterator<E> createSubListIterator(AbstractLinkedList.LinkedSubList<E> p0){ return null; }
protected ListIterator<E> createSubListListIterator(AbstractLinkedList.LinkedSubList<E> p0, int p1){ return null; }
protected boolean isEqualValue(Object p0, Object p1){ return false; }
protected void addNode(AbstractLinkedList.Node<E> p0, AbstractLinkedList.Node<E> p1){}
protected void addNodeAfter(AbstractLinkedList.Node<E> p0, E p1){}
protected void addNodeBefore(AbstractLinkedList.Node<E> p0, E p1){}
protected void doReadObject(ObjectInputStream p0){}
protected void doWriteObject(ObjectOutputStream p0){}
protected void init(){}
protected void removeAllNodes(){}
protected void removeNode(AbstractLinkedList.Node<E> p0){}
protected void updateNode(AbstractLinkedList.Node<E> p0, E p1){}
public <T> T[] toArray(T[] p0){ return null; }
public E get(int p0){ return null; }
public E getFirst(){ return null; }
public E getLast(){ return null; }
public E remove(int p0){ return null; }
public E removeFirst(){ return null; }
public E removeLast(){ return null; }
public E set(int p0, E p1){ return null; }
public Iterator<E> iterator(){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public Object[] toArray(){ return null; }
public String toString(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean addFirst(E p0){ return false; }
public boolean addLast(E p0){ return false; }
public boolean contains(Object p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean equals(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public int hashCode(){ return 0; }
public int indexOf(Object p0){ return 0; }
public int lastIndexOf(Object p0){ return 0; }
public int size(){ return 0; }
public void add(int p0, E p1){}
public void clear(){}
static class LinkedListIterator<E> implements ListIterator<E>, OrderedIterator<E>
{
protected LinkedListIterator() {}
protected AbstractLinkedList.Node<E> current = null;
protected AbstractLinkedList.Node<E> getLastNodeReturned(){ return null; }
protected AbstractLinkedList.Node<E> next = null;
protected LinkedListIterator(AbstractLinkedList<E> p0, int p1){}
protected final AbstractLinkedList<E> parent = null;
protected int expectedModCount = 0;
protected int nextIndex = 0;
protected void checkModCount(){}
public E next(){ return null; }
public E previous(){ return null; }
public boolean hasNext(){ return false; }
public boolean hasPrevious(){ return false; }
public int nextIndex(){ return 0; }
public int previousIndex(){ return 0; }
public void add(E p0){}
public void remove(){}
public void set(E p0){}
}
static class LinkedSubList<E> extends AbstractList<E>
{
protected LinkedSubList() {}
protected LinkedSubList(AbstractLinkedList<E> p0, int p1, int p2){}
protected void checkModCount(){}
protected void rangeCheck(int p0, int p1){}
public E get(int p0){ return null; }
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public Iterator<E> iterator(){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public int size(){ return 0; }
public void add(int p0, E p1){}
public void clear(){}
}
static class Node<E>
{
protected AbstractLinkedList.Node<E> getNextNode(){ return null; }
protected AbstractLinkedList.Node<E> getPreviousNode(){ return null; }
protected AbstractLinkedList.Node<E> next = null;
protected AbstractLinkedList.Node<E> previous = null;
protected E getValue(){ return null; }
protected E value = null;
protected Node(){}
protected Node(AbstractLinkedList.Node<E> p0, AbstractLinkedList.Node<E> p1, E p2){}
protected Node(E p0){}
protected void setNextNode(AbstractLinkedList.Node<E> p0){}
protected void setPreviousNode(AbstractLinkedList.Node<E> p0){}
protected void setValue(E p0){}
}
}

27
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/AbstractListDecorator.java generated Normal file
View File

@@ -0,0 +1,27 @@
// Generated automatically from org.apache.commons.collections4.list.AbstractListDecorator for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
abstract public class AbstractListDecorator<E> extends AbstractCollectionDecorator<E> implements List<E>
{
protected AbstractListDecorator(){}
protected AbstractListDecorator(List<E> p0){}
protected List<E> decorated(){ return null; }
public E get(int p0){ return null; }
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean equals(Object p0){ return false; }
public int hashCode(){ return 0; }
public int indexOf(Object p0){ return 0; }
public int lastIndexOf(Object p0){ return 0; }
public void add(int p0, E p1){}
}

12
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/AbstractSerializableListDecorator.java generated Normal file
View File

@@ -0,0 +1,12 @@
// Generated automatically from org.apache.commons.collections4.list.AbstractSerializableListDecorator for testing purposes
package org.apache.commons.collections4.list;
import java.util.List;
import org.apache.commons.collections4.list.AbstractListDecorator;
abstract public class AbstractSerializableListDecorator<E> extends AbstractListDecorator<E>
{
protected AbstractSerializableListDecorator() {}
protected AbstractSerializableListDecorator(List<E> p0){}
}

44
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/CursorableLinkedList.java generated Normal file
View File

@@ -0,0 +1,44 @@
// Generated automatically from org.apache.commons.collections4.list.CursorableLinkedList for testing purposes
package org.apache.commons.collections4.list;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.ListIterator;
import org.apache.commons.collections4.list.AbstractLinkedList;
public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Serializable
{
protected ListIterator<E> createSubListListIterator(AbstractLinkedList.LinkedSubList<E> p0, int p1){ return null; }
protected void addNode(AbstractLinkedList.Node<E> p0, AbstractLinkedList.Node<E> p1){}
protected void broadcastNodeChanged(AbstractLinkedList.Node<E> p0){}
protected void broadcastNodeInserted(AbstractLinkedList.Node<E> p0){}
protected void broadcastNodeRemoved(AbstractLinkedList.Node<E> p0){}
protected void init(){}
protected void registerCursor(CursorableLinkedList.Cursor<E> p0){}
protected void removeAllNodes(){}
protected void removeNode(AbstractLinkedList.Node<E> p0){}
protected void unregisterCursor(CursorableLinkedList.Cursor<E> p0){}
protected void updateNode(AbstractLinkedList.Node<E> p0, E p1){}
public CursorableLinkedList(){}
public CursorableLinkedList(Collection<? extends E> p0){}
public CursorableLinkedList.Cursor<E> cursor(){ return null; }
public CursorableLinkedList.Cursor<E> cursor(int p0){ return null; }
public Iterator<E> iterator(){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
static public class Cursor<E> extends AbstractLinkedList.LinkedListIterator<E>
{
protected Cursor() {}
protected Cursor(CursorableLinkedList<E> p0, int p1){}
protected void checkModCount(){}
protected void nodeChanged(AbstractLinkedList.Node<E> p0){}
protected void nodeInserted(AbstractLinkedList.Node<E> p0){}
protected void nodeRemoved(AbstractLinkedList.Node<E> p0){}
public int nextIndex(){ return 0; }
public void add(E p0){}
public void close(){}
public void remove(){}
}
}

38
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/FixedSizeList.java generated Normal file
View File

@@ -0,0 +1,38 @@
// Generated automatically from org.apache.commons.collections4.list.FixedSizeList for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Predicate;
import org.apache.commons.collections4.BoundedCollection;
import org.apache.commons.collections4.list.AbstractSerializableListDecorator;
public class FixedSizeList<E> extends AbstractSerializableListDecorator<E> implements BoundedCollection<E>
{
protected FixedSizeList() {}
protected FixedSizeList(List<E> p0){}
public E get(int p0){ return null; }
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public Iterator<E> iterator(){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean isFull(){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public int indexOf(Object p0){ return 0; }
public int lastIndexOf(Object p0){ return 0; }
public int maxSize(){ return 0; }
public static <E> FixedSizeList<E> fixedSizeList(List<E> p0){ return null; }
public void add(int p0, E p1){}
public void clear(){}
}

18
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/GrowthList.java generated Normal file
View File

@@ -0,0 +1,18 @@
// Generated automatically from org.apache.commons.collections4.list.GrowthList for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.List;
import org.apache.commons.collections4.list.AbstractSerializableListDecorator;
public class GrowthList<E> extends AbstractSerializableListDecorator<E>
{
protected GrowthList(List<E> p0){}
public E set(int p0, E p1){ return null; }
public GrowthList(){}
public GrowthList(int p0){}
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public static <E> GrowthList<E> growthList(List<E> p0){ return null; }
public void add(int p0, E p1){}
}

19
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/LazyList.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from org.apache.commons.collections4.list.LazyList for testing purposes
package org.apache.commons.collections4.list;
import java.util.List;
import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.list.AbstractSerializableListDecorator;
public class LazyList<E> extends AbstractSerializableListDecorator<E>
{
protected LazyList() {}
protected LazyList(List<E> p0, Factory<? extends E> p1){}
protected LazyList(List<E> p0, Transformer<Integer, ? extends E> p1){}
public E get(int p0){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public static <E> LazyList<E> lazyList(List<E> p0, Factory<? extends E> p1){ return null; }
public static <E> LazyList<E> lazyList(List<E> p0, Transformer<Integer, ? extends E> p1){ return null; }
}

23
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/NodeCachingLinkedList.java generated Normal file
View File

@@ -0,0 +1,23 @@
// Generated automatically from org.apache.commons.collections4.list.NodeCachingLinkedList for testing purposes
package org.apache.commons.collections4.list;
import java.io.Serializable;
import java.util.Collection;
import org.apache.commons.collections4.list.AbstractLinkedList;
public class NodeCachingLinkedList<E> extends AbstractLinkedList<E> implements Serializable
{
protected AbstractLinkedList.Node<E> createNode(E p0){ return null; }
protected AbstractLinkedList.Node<E> getNodeFromCache(){ return null; }
protected boolean isCacheFull(){ return false; }
protected int getMaximumCacheSize(){ return 0; }
protected void addNodeToCache(AbstractLinkedList.Node<E> p0){}
protected void removeAllNodes(){}
protected void removeNode(AbstractLinkedList.Node<E> p0){}
protected void setMaximumCacheSize(int p0){}
protected void shrinkCacheToMaximumSize(){}
public NodeCachingLinkedList(){}
public NodeCachingLinkedList(Collection<? extends E> p0){}
public NodeCachingLinkedList(int p0){}
}

29
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/PredicatedList.java generated Normal file
View File

@@ -0,0 +1,29 @@
// Generated automatically from org.apache.commons.collections4.list.PredicatedList for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.collection.PredicatedCollection;
public class PredicatedList<E> extends PredicatedCollection<E> implements List<E>
{
protected PredicatedList() {}
protected List<E> decorated(){ return null; }
protected PredicatedList(List<E> p0, Predicate<? super E> p1){}
public E get(int p0){ return null; }
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean equals(Object p0){ return false; }
public int hashCode(){ return 0; }
public int indexOf(Object p0){ return 0; }
public int lastIndexOf(Object p0){ return 0; }
public static <T> PredicatedList<T> predicatedList(List<T> p0, Predicate<? super T> p1){ return null; }
public void add(int p0, E p1){}
}

37
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/SetUniqueList.java generated Normal file
View File

@@ -0,0 +1,37 @@
// Generated automatically from org.apache.commons.collections4.list.SetUniqueList for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.function.Predicate;
import org.apache.commons.collections4.list.AbstractSerializableListDecorator;
public class SetUniqueList<E> extends AbstractSerializableListDecorator<E>
{
protected SetUniqueList() {}
protected Set<E> createSetBasedOnList(Set<E> p0, List<E> p1){ return null; }
protected SetUniqueList(List<E> p0, Set<E> p1){}
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public Iterator<E> iterator(){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public Set<E> asSet(){ return null; }
public boolean add(E p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean contains(Object p0){ return false; }
public boolean containsAll(Collection<? extends Object> p0){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <E> SetUniqueList<E> setUniqueList(List<E> p0){ return null; }
public void add(int p0, E p1){}
public void clear(){}
}

30
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/TransformedList.java generated Normal file
View File

@@ -0,0 +1,30 @@
// Generated automatically from org.apache.commons.collections4.list.TransformedList for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.collection.TransformedCollection;
public class TransformedList<E> extends TransformedCollection<E> implements List<E>
{
protected TransformedList() {}
protected List<E> getList(){ return null; }
protected TransformedList(List<E> p0, Transformer<? super E, ? extends E> p1){}
public E get(int p0){ return null; }
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean equals(Object p0){ return false; }
public int hashCode(){ return 0; }
public int indexOf(Object p0){ return 0; }
public int lastIndexOf(Object p0){ return 0; }
public static <E> TransformedList<E> transformedList(List<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
public static <E> TransformedList<E> transformingList(List<E> p0, Transformer<? super E, ? extends E> p1){ return null; }
public void add(int p0, E p1){}
}

27
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/TreeList.java generated Normal file
View File

@@ -0,0 +1,27 @@
// Generated automatically from org.apache.commons.collections4.list.TreeList for testing purposes
package org.apache.commons.collections4.list;
import java.util.AbstractList;
import java.util.Collection;
import java.util.Iterator;
import java.util.ListIterator;
public class TreeList<E> extends AbstractList<E>
{
public E get(int p0){ return null; }
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public Iterator<E> iterator(){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public Object[] toArray(){ return null; }
public TreeList(){}
public TreeList(Collection<? extends E> p0){}
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean contains(Object p0){ return false; }
public int indexOf(Object p0){ return 0; }
public int size(){ return 0; }
public void add(int p0, E p1){}
public void clear(){}
}

33
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/list/UnmodifiableList.java generated Normal file
View File

@@ -0,0 +1,33 @@
// Generated automatically from org.apache.commons.collections4.list.UnmodifiableList for testing purposes
package org.apache.commons.collections4.list;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Predicate;
import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.list.AbstractSerializableListDecorator;
public class UnmodifiableList<E> extends AbstractSerializableListDecorator<E> implements Unmodifiable
{
protected UnmodifiableList() {}
public E remove(int p0){ return null; }
public E set(int p0, E p1){ return null; }
public Iterator<E> iterator(){ return null; }
public List<E> subList(int p0, int p1){ return null; }
public ListIterator<E> listIterator(){ return null; }
public ListIterator<E> listIterator(int p0){ return null; }
public UnmodifiableList(List<? extends E> p0){}
public boolean add(Object p0){ return false; }
public boolean addAll(Collection<? extends E> p0){ return false; }
public boolean addAll(int p0, Collection<? extends E> p1){ return false; }
public boolean remove(Object p0){ return false; }
public boolean removeAll(Collection<? extends Object> p0){ return false; }
public boolean removeIf(Predicate<? super E> p0){ return false; }
public boolean retainAll(Collection<? extends Object> p0){ return false; }
public static <E> List<E> unmodifiableList(List<? extends E> p0){ return null; }
public void add(int p0, E p1){}
public void clear(){}
}

16
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/AbstractInputCheckedMapDecorator.java generated Normal file
View File

@@ -0,0 +1,16 @@
// Generated automatically from org.apache.commons.collections4.map.AbstractInputCheckedMapDecorator for testing purposes
package org.apache.commons.collections4.map;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.map.AbstractMapDecorator;
abstract class AbstractInputCheckedMapDecorator<K, V> extends AbstractMapDecorator<K, V>
{
protected AbstractInputCheckedMapDecorator(){}
protected AbstractInputCheckedMapDecorator(Map<K, V> p0){}
protected abstract V checkSetValue(V p0);
protected boolean isSetValueChecking(){ return false; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
}

19
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/AbstractOrderedMapDecorator.java generated Normal file
View File

@@ -0,0 +1,19 @@
// Generated automatically from org.apache.commons.collections4.map.AbstractOrderedMapDecorator for testing purposes
package org.apache.commons.collections4.map;
import org.apache.commons.collections4.OrderedMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.map.AbstractMapDecorator;
abstract public class AbstractOrderedMapDecorator<K, V> extends AbstractMapDecorator<K, V> implements OrderedMap<K, V>
{
protected AbstractOrderedMapDecorator(){}
protected OrderedMap<K, V> decorated(){ return null; }
public AbstractOrderedMapDecorator(OrderedMap<K, V> p0){}
public K firstKey(){ return null; }
public K lastKey(){ return null; }
public K nextKey(K p0){ return null; }
public K previousKey(K p0){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
}

25
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/AbstractSortedMapDecorator.java generated Normal file
View File

@@ -0,0 +1,25 @@
// Generated automatically from org.apache.commons.collections4.map.AbstractSortedMapDecorator for testing purposes
package org.apache.commons.collections4.map;
import java.util.Comparator;
import java.util.SortedMap;
import org.apache.commons.collections4.IterableSortedMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.map.AbstractMapDecorator;
abstract public class AbstractSortedMapDecorator<K, V> extends AbstractMapDecorator<K, V> implements IterableSortedMap<K, V>
{
protected AbstractSortedMapDecorator(){}
protected SortedMap<K, V> decorated(){ return null; }
public AbstractSortedMapDecorator(SortedMap<K, V> p0){}
public Comparator<? super K> comparator(){ return null; }
public K firstKey(){ return null; }
public K lastKey(){ return null; }
public K nextKey(K p0){ return null; }
public K previousKey(K p0){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
}

17
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/CaseInsensitiveMap.java generated Normal file
View File

@@ -0,0 +1,17 @@
// Generated automatically from org.apache.commons.collections4.map.CaseInsensitiveMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.map.AbstractHashedMap;
public class CaseInsensitiveMap<K, V> extends AbstractHashedMap<K, V> implements Cloneable, Serializable
{
protected Object convertKey(Object p0){ return null; }
public CaseInsensitiveMap(){}
public CaseInsensitiveMap(Map<? extends K, ? extends V> p0){}
public CaseInsensitiveMap(int p0){}
public CaseInsensitiveMap(int p0, float p1){}
public CaseInsensitiveMap<K, V> clone(){ return null; }
}

41
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/CompositeMap.java generated Normal file
View File

@@ -0,0 +1,41 @@
// Generated automatically from org.apache.commons.collections4.map.CompositeMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.map.AbstractIterableMap;
public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Serializable
{
public Collection<V> values(){ return null; }
public CompositeMap(){}
public CompositeMap(Map<K, V> p0, Map<K, V> p1){}
public CompositeMap(Map<K, V> p0, Map<K, V> p1, CompositeMap.MapMutator<K, V> p2){}
public CompositeMap(Map<K, V>... p0){}
public CompositeMap(Map<K, V>[] p0, CompositeMap.MapMutator<K, V> p1){}
public Map<K, V> removeComposited(Map<K, V> p0){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public V get(Object p0){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public boolean containsKey(Object p0){ return false; }
public boolean containsValue(Object p0){ return false; }
public boolean equals(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public int hashCode(){ return 0; }
public int size(){ return 0; }
public void addComposited(Map<K, V> p0){}
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
public void setMutator(CompositeMap.MapMutator<K, V> p0){}
static public interface MapMutator<K, V> extends Serializable
{
V put(CompositeMap<K, V> p0, Map<K, V>[] p1, K p2, V p3);
void putAll(CompositeMap<K, V> p0, Map<K, V>[] p1, Map<? extends K, ? extends V> p2);
void resolveCollision(CompositeMap<K, V> p0, Map<K, V> p1, Map<K, V> p2, Collection<K> p3);
}
}

21
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/DefaultedMap.java generated Normal file
View File

@@ -0,0 +1,21 @@
// Generated automatically from org.apache.commons.collections4.map.DefaultedMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.map.AbstractMapDecorator;
public class DefaultedMap<K, V> extends AbstractMapDecorator<K, V> implements Serializable
{
protected DefaultedMap() {}
protected DefaultedMap(Map<K, V> p0, Transformer<? super K, ? extends V> p1){}
public DefaultedMap(Transformer<? super K, ? extends V> p0){}
public DefaultedMap(V p0){}
public V get(Object p0){ return null; }
public static <K, V> DefaultedMap<K, V> defaultedMap(Map<K, V> p0, Factory<? extends V> p1){ return null; }
public static <K, V> DefaultedMap<K, V> defaultedMap(Map<K, V> p0, V p1){ return null; }
public static <K, V> Map<K, V> defaultedMap(Map<K, V> p0, Transformer<? super K, ? extends V> p1){ return null; }
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/EntrySetToMapIteratorAdapter.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.map.EntrySetToMapIteratorAdapter for testing purposes
package org.apache.commons.collections4.map;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.ResettableIterator;
public class EntrySetToMapIteratorAdapter<K, V> implements MapIterator<K, V>, ResettableIterator<K>
{
protected EntrySetToMapIteratorAdapter() {}
protected Map.Entry<K, V> current(){ return null; }
public EntrySetToMapIteratorAdapter(Set<Map.Entry<K, V>> p0){}
public K getKey(){ return null; }
public K next(){ return null; }
public V getValue(){ return null; }
public V setValue(V p0){ return null; }
public boolean hasNext(){ return false; }
public void remove(){}
public void reset(){}
}

26
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/FixedSizeMap.java generated Normal file
View File

@@ -0,0 +1,26 @@
// Generated automatically from org.apache.commons.collections4.map.FixedSizeMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.BoundedMap;
import org.apache.commons.collections4.map.AbstractMapDecorator;
public class FixedSizeMap<K, V> extends AbstractMapDecorator<K, V> implements BoundedMap<K, V>, Serializable
{
protected FixedSizeMap() {}
protected FixedSizeMap(Map<K, V> p0){}
public Collection<V> values(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public boolean isFull(){ return false; }
public int maxSize(){ return 0; }
public static <K, V> FixedSizeMap<K, V> fixedSizeMap(Map<K, V> p0){ return null; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

31
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/FixedSizeSortedMap.java generated Normal file
View File

@@ -0,0 +1,31 @@
// Generated automatically from org.apache.commons.collections4.map.FixedSizeSortedMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import org.apache.commons.collections4.BoundedMap;
import org.apache.commons.collections4.map.AbstractSortedMapDecorator;
public class FixedSizeSortedMap<K, V> extends AbstractSortedMapDecorator<K, V> implements BoundedMap<K, V>, Serializable
{
protected FixedSizeSortedMap() {}
protected FixedSizeSortedMap(SortedMap<K, V> p0){}
protected SortedMap<K, V> getSortedMap(){ return null; }
public Collection<V> values(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public boolean isFull(){ return false; }
public int maxSize(){ return 0; }
public static <K, V> FixedSizeSortedMap<K, V> fixedSizeSortedMap(SortedMap<K, V> p0){ return null; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

35
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/Flat3Map.java generated Normal file
View File

@@ -0,0 +1,35 @@
// Generated automatically from org.apache.commons.collections4.map.Flat3Map for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.IterableMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.map.AbstractHashedMap;
public class Flat3Map<K, V> implements Cloneable, IterableMap<K, V>, Serializable
{
protected AbstractHashedMap<K, V> createDelegateMap(){ return null; }
public Collection<V> values(){ return null; }
public Flat3Map(){}
public Flat3Map(Map<? extends K, ? extends V> p0){}
public Flat3Map<K, V> clone(){ return null; }
public MapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public String toString(){ return null; }
public V get(Object p0){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public boolean containsKey(Object p0){ return false; }
public boolean containsValue(Object p0){ return false; }
public boolean equals(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public int hashCode(){ return 0; }
public int size(){ return 0; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

39
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/LRUMap.java generated Normal file
View File

@@ -0,0 +1,39 @@
// Generated automatically from org.apache.commons.collections4.map.LRUMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.BoundedMap;
import org.apache.commons.collections4.map.AbstractHashedMap;
import org.apache.commons.collections4.map.AbstractLinkedMap;
public class LRUMap<K, V> extends AbstractLinkedMap<K, V> implements BoundedMap<K, V>, Cloneable, Serializable
{
protected boolean removeLRU(AbstractLinkedMap.LinkEntry<K, V> p0){ return false; }
protected static int DEFAULT_MAX_SIZE = 0;
protected void addMapping(int p0, int p1, K p2, V p3){}
protected void doReadObject(ObjectInputStream p0){}
protected void doWriteObject(ObjectOutputStream p0){}
protected void moveToMRU(AbstractLinkedMap.LinkEntry<K, V> p0){}
protected void reuseMapping(AbstractLinkedMap.LinkEntry<K, V> p0, int p1, int p2, K p3, V p4){}
protected void updateEntry(AbstractHashedMap.HashEntry<K, V> p0, V p1){}
public LRUMap(){}
public LRUMap(Map<? extends K, ? extends V> p0){}
public LRUMap(Map<? extends K, ? extends V> p0, boolean p1){}
public LRUMap(int p0){}
public LRUMap(int p0, boolean p1){}
public LRUMap(int p0, float p1){}
public LRUMap(int p0, float p1, boolean p2){}
public LRUMap(int p0, int p1){}
public LRUMap(int p0, int p1, float p2){}
public LRUMap(int p0, int p1, float p2, boolean p3){}
public LRUMap<K, V> clone(){ return null; }
public V get(Object p0){ return null; }
public V get(Object p0, boolean p1){ return null; }
public boolean isFull(){ return false; }
public boolean isScanUntilRemovable(){ return false; }
public int maxSize(){ return 0; }
}

20
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/LazyMap.java generated Normal file
View File

@@ -0,0 +1,20 @@
// Generated automatically from org.apache.commons.collections4.map.LazyMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.map.AbstractMapDecorator;
public class LazyMap<K, V> extends AbstractMapDecorator<K, V> implements Serializable
{
protected LazyMap() {}
protected LazyMap(Map<K, V> p0, Factory<? extends V> p1){}
protected LazyMap(Map<K, V> p0, Transformer<? super K, ? extends V> p1){}
protected final Transformer<? super K, ? extends V> factory = null;
public V get(Object p0){ return null; }
public static <K, V> LazyMap<K, V> lazyMap(Map<K, V> p0, Factory<? extends V> p1){ return null; }
public static <V, K> LazyMap<K, V> lazyMap(Map<K, V> p0, Transformer<? super K, ? extends V> p1){ return null; }
}

25
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/LazySortedMap.java generated Normal file
View File

@@ -0,0 +1,25 @@
// Generated automatically from org.apache.commons.collections4.map.LazySortedMap for testing purposes
package org.apache.commons.collections4.map;
import java.util.Comparator;
import java.util.SortedMap;
import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.map.LazyMap;
public class LazySortedMap<K, V> extends LazyMap<K, V> implements SortedMap<K, V>
{
protected LazySortedMap() {}
protected LazySortedMap(SortedMap<K, V> p0, Factory<? extends V> p1){}
protected LazySortedMap(SortedMap<K, V> p0, Transformer<? super K, ? extends V> p1){}
protected SortedMap<K, V> getSortedMap(){ return null; }
public Comparator<? super K> comparator(){ return null; }
public K firstKey(){ return null; }
public K lastKey(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
public static <K, V> LazySortedMap<K, V> lazySortedMap(SortedMap<K, V> p0, Factory<? extends V> p1){ return null; }
public static <K, V> LazySortedMap<K, V> lazySortedMap(SortedMap<K, V> p0, Transformer<? super K, ? extends V> p1){ return null; }
}

42
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/ListOrderedMap.java generated Normal file
View File

@@ -0,0 +1,42 @@
// Generated automatically from org.apache.commons.collections4.map.ListOrderedMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.OrderedMap;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.map.AbstractMapDecorator;
public class ListOrderedMap<K, V> extends AbstractMapDecorator<K, V> implements OrderedMap<K, V>, Serializable
{
protected ListOrderedMap(Map<K, V> p0){}
public Collection<V> values(){ return null; }
public K firstKey(){ return null; }
public K get(int p0){ return null; }
public K lastKey(){ return null; }
public K nextKey(Object p0){ return null; }
public K previousKey(Object p0){ return null; }
public List<K> asList(){ return null; }
public List<K> keyList(){ return null; }
public List<V> valueList(){ return null; }
public ListOrderedMap(){}
public OrderedMapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public String toString(){ return null; }
public V getValue(int p0){ return null; }
public V put(K p0, V p1){ return null; }
public V put(int p0, K p1, V p2){ return null; }
public V remove(Object p0){ return null; }
public V remove(int p0){ return null; }
public V setValue(int p0, V p1){ return null; }
public int indexOf(Object p0){ return 0; }
public static <K, V> ListOrderedMap<K, V> listOrderedMap(Map<K, V> p0){ return null; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
public void putAll(int p0, Map<? extends K, ? extends V> p1){}
}

51
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/MultiKeyMap.java generated Normal file
View File

@@ -0,0 +1,51 @@
// Generated automatically from org.apache.commons.collections4.map.MultiKeyMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.keyvalue.MultiKey;
import org.apache.commons.collections4.map.AbstractHashedMap;
import org.apache.commons.collections4.map.AbstractMapDecorator;
public class MultiKeyMap<K, V> extends AbstractMapDecorator<MultiKey<? extends K>, V> implements Cloneable, Serializable
{
protected AbstractHashedMap<MultiKey<? extends K>, V> decorated(){ return null; }
protected MultiKeyMap(AbstractHashedMap<MultiKey<? extends K>, V> p0){}
protected boolean isEqualKey(AbstractHashedMap.HashEntry<MultiKey<? extends K>, V> p0, Object p1, Object p2){ return false; }
protected boolean isEqualKey(AbstractHashedMap.HashEntry<MultiKey<? extends K>, V> p0, Object p1, Object p2, Object p3){ return false; }
protected boolean isEqualKey(AbstractHashedMap.HashEntry<MultiKey<? extends K>, V> p0, Object p1, Object p2, Object p3, Object p4){ return false; }
protected boolean isEqualKey(AbstractHashedMap.HashEntry<MultiKey<? extends K>, V> p0, Object p1, Object p2, Object p3, Object p4, Object p5){ return false; }
protected int hash(Object p0, Object p1){ return 0; }
protected int hash(Object p0, Object p1, Object p2){ return 0; }
protected int hash(Object p0, Object p1, Object p2, Object p3){ return 0; }
protected int hash(Object p0, Object p1, Object p2, Object p3, Object p4){ return 0; }
protected void checkKey(MultiKey<? extends Object> p0){}
public MapIterator<MultiKey<? extends K>, V> mapIterator(){ return null; }
public MultiKeyMap(){}
public MultiKeyMap<K, V> clone(){ return null; }
public V get(Object p0, Object p1){ return null; }
public V get(Object p0, Object p1, Object p2){ return null; }
public V get(Object p0, Object p1, Object p2, Object p3){ return null; }
public V get(Object p0, Object p1, Object p2, Object p3, Object p4){ return null; }
public V put(K p0, K p1, K p2, K p3, K p4, V p5){ return null; }
public V put(K p0, K p1, K p2, K p3, V p4){ return null; }
public V put(K p0, K p1, K p2, V p3){ return null; }
public V put(K p0, K p1, V p2){ return null; }
public V put(MultiKey<? extends K> p0, V p1){ return null; }
public V removeMultiKey(Object p0, Object p1){ return null; }
public V removeMultiKey(Object p0, Object p1, Object p2){ return null; }
public V removeMultiKey(Object p0, Object p1, Object p2, Object p3){ return null; }
public V removeMultiKey(Object p0, Object p1, Object p2, Object p3, Object p4){ return null; }
public boolean containsKey(Object p0, Object p1){ return false; }
public boolean containsKey(Object p0, Object p1, Object p2){ return false; }
public boolean containsKey(Object p0, Object p1, Object p2, Object p3){ return false; }
public boolean containsKey(Object p0, Object p1, Object p2, Object p3, Object p4){ return false; }
public boolean removeAll(Object p0){ return false; }
public boolean removeAll(Object p0, Object p1){ return false; }
public boolean removeAll(Object p0, Object p1, Object p2){ return false; }
public boolean removeAll(Object p0, Object p1, Object p2, Object p3){ return false; }
public static <K, V> MultiKeyMap<K, V> multiKeyMap(AbstractHashedMap<MultiKey<? extends K>, V> p0){ return null; }
public void putAll(Map<? extends MultiKey<? extends K>, ? extends V> p0){}
}

38
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/PassiveExpiringMap.java generated Normal file
View File

@@ -0,0 +1,38 @@
// Generated automatically from org.apache.commons.collections4.map.PassiveExpiringMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.apache.commons.collections4.map.AbstractMapDecorator;
public class PassiveExpiringMap<K, V> extends AbstractMapDecorator<K, V> implements Serializable
{
public Collection<V> values(){ return null; }
public PassiveExpiringMap(){}
public PassiveExpiringMap(Map<K, V> p0){}
public PassiveExpiringMap(PassiveExpiringMap.ExpirationPolicy<K, V> p0){}
public PassiveExpiringMap(PassiveExpiringMap.ExpirationPolicy<K, V> p0, Map<K, V> p1){}
public PassiveExpiringMap(long p0){}
public PassiveExpiringMap(long p0, Map<K, V> p1){}
public PassiveExpiringMap(long p0, TimeUnit p1){}
public PassiveExpiringMap(long p0, TimeUnit p1, Map<K, V> p2){}
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public V get(Object p0){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public boolean containsKey(Object p0){ return false; }
public boolean containsValue(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public int size(){ return 0; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
static public interface ExpirationPolicy<K, V> extends Serializable
{
long expirationTime(K p0, V p1);
}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/PredicatedMap.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.map.PredicatedMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.map.AbstractInputCheckedMapDecorator;
public class PredicatedMap<K, V> extends AbstractInputCheckedMapDecorator<K, V> implements Serializable
{
protected PredicatedMap() {}
protected PredicatedMap(Map<K, V> p0, Predicate<? super K> p1, Predicate<? super V> p2){}
protected V checkSetValue(V p0){ return null; }
protected boolean isSetValueChecking(){ return false; }
protected final Predicate<? super K> keyPredicate = null;
protected final Predicate<? super V> valuePredicate = null;
protected void validate(K p0, V p1){}
public V put(K p0, V p1){ return null; }
public static <K, V> PredicatedMap<K, V> predicatedMap(Map<K, V> p0, Predicate<? super K> p1, Predicate<? super V> p2){ return null; }
public void putAll(Map<? extends K, ? extends V> p0){}
}

22
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/PredicatedSortedMap.java generated Normal file
View File

@@ -0,0 +1,22 @@
// Generated automatically from org.apache.commons.collections4.map.PredicatedSortedMap for testing purposes
package org.apache.commons.collections4.map;
import java.util.Comparator;
import java.util.SortedMap;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.map.PredicatedMap;
public class PredicatedSortedMap<K, V> extends PredicatedMap<K, V> implements SortedMap<K, V>
{
protected PredicatedSortedMap() {}
protected PredicatedSortedMap(SortedMap<K, V> p0, Predicate<? super K> p1, Predicate<? super V> p2){}
protected SortedMap<K, V> getSortedMap(){ return null; }
public Comparator<? super K> comparator(){ return null; }
public K firstKey(){ return null; }
public K lastKey(){ return null; }
public SortedMap<K, V> headMap(K p0){ return null; }
public SortedMap<K, V> subMap(K p0, K p1){ return null; }
public SortedMap<K, V> tailMap(K p0){ return null; }
public static <K, V> PredicatedSortedMap<K, V> predicatedSortedMap(SortedMap<K, V> p0, Predicate<? super K> p1, Predicate<? super V> p2){ return null; }
}

49
java/ql/test/stubs/apache-commons-collections4-4.4/org/apache/commons/collections4/map/SingletonMap.java generated Normal file
View File

@@ -0,0 +1,49 @@
// Generated automatically from org.apache.commons.collections4.map.SingletonMap for testing purposes
package org.apache.commons.collections4.map;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.apache.commons.collections4.BoundedMap;
import org.apache.commons.collections4.KeyValue;
import org.apache.commons.collections4.OrderedMap;
import org.apache.commons.collections4.OrderedMapIterator;
public class SingletonMap<K, V> implements BoundedMap<K, V>, Cloneable, KeyValue<K, V>, OrderedMap<K, V>, Serializable
{
protected boolean isEqualKey(Object p0){ return false; }
protected boolean isEqualValue(Object p0){ return false; }
public Collection<V> values(){ return null; }
public K firstKey(){ return null; }
public K getKey(){ return null; }
public K lastKey(){ return null; }
public K nextKey(K p0){ return null; }
public K previousKey(K p0){ return null; }
public OrderedMapIterator<K, V> mapIterator(){ return null; }
public Set<K> keySet(){ return null; }
public Set<Map.Entry<K, V>> entrySet(){ return null; }
public SingletonMap(){}
public SingletonMap(K p0, V p1){}
public SingletonMap(KeyValue<K, V> p0){}
public SingletonMap(Map.Entry<? extends K, ? extends V> p0){}
public SingletonMap(Map<? extends K, ? extends V> p0){}
public SingletonMap<K, V> clone(){ return null; }
public String toString(){ return null; }
public V get(Object p0){ return null; }
public V getValue(){ return null; }
public V put(K p0, V p1){ return null; }
public V remove(Object p0){ return null; }
public V setValue(V p0){ return null; }
public boolean containsKey(Object p0){ return false; }
public boolean containsValue(Object p0){ return false; }
public boolean equals(Object p0){ return false; }
public boolean isEmpty(){ return false; }
public boolean isFull(){ return false; }
public int hashCode(){ return 0; }
public int maxSize(){ return 0; }
public int size(){ return 0; }
public void clear(){}
public void putAll(Map<? extends K, ? extends V> p0){}
}

Some files were not shown because too many files have changed in this diff Show More