Add additional tests for http stuff + corresponding stubs

java/ql/test/library-tests/frameworks/netty/manual/Test.java

@@ -1,7 +1,10 @@
 import io.netty.channel.*;
 import io.netty.buffer.ByteBuf;
-// import io.netty.handler.codec.*;
-// import io.netty.handler.codec.http.*;
+import io.netty.handler.codec.*;
+import io.netty.handler.codec.http.*;
+import io.netty.handler.codec.http2.*;
+
+import java.util.List;
 
 class Test {
     static <T> T source() { return null; }
@@ -28,4 +31,46 @@ class Test {
         sink(bb); // $ hasTaintFlow
         sink(x);
     }
+
+    class C extends ByteToMessageDecoder {
+        public void callDecode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
+            sink(msg); // $ hasTaintFlow
+        }
+
+        public void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
+            sink(msg); // $ hasTaintFlow
+        }
+
+        public void decodeLast(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
+            sink(msg); // $ hasTaintFlow
+        }
+    }
+
+    class D extends SimpleChannelInboundHandler<FullHttpRequest> {
+        public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) {
+            sink(msg.uri()); // $ hasTaintFlow
+            sink(msg.headers().get("X-blah")); // $ hasTaintFlow
+            sink(msg.content()); // $ hasTaintFlow
+        }
+    }
+
+    class E extends Http2FrameAdapter {
+        public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding, boolean endOfStream) {
+            sink(data); // $ hasTaintFlow
+            return 0;
+        }
+
+        public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int padding, boolean endStream) {
+            sink(headers.get("X-blah")); // $ hasTaintFlow
+            sink(headers.path()); // $ hasTaintFlow
+        }
+
+        public void onPushPromiseRead(ChannelHandlerContext ctx, int streamId, int promisedStreamId, Http2Headers headers, int padding) {
+            sink(headers); // $ hasTaintFlow
+        }
+
+        public void onUnknownFrame(ChannelHandlerContext ctx, byte frameType, int streamId, Http2Flags flags, ByteBuf payload) {
+            sink(payload); // $ hasTaintFlow
+        }
+    }
 }

java/ql/test/stubs/netty-4.1.x/io/netty/buffer/ByteBufHolder.java

@@ -0,0 +1,19 @@
+// Generated automatically from io.netty.buffer.ByteBufHolder for testing purposes
+
+package io.netty.buffer;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.util.ReferenceCounted;
+
+public interface ByteBufHolder extends ReferenceCounted
+{
+    ByteBuf content();
+    ByteBufHolder copy();
+    ByteBufHolder duplicate();
+    ByteBufHolder replace(ByteBuf p0);
+    ByteBufHolder retain();
+    ByteBufHolder retain(int p0);
+    ByteBufHolder retainedDuplicate();
+    ByteBufHolder touch();
+    ByteBufHolder touch(Object p0);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/channel/SimpleChannelInboundHandler.java

@@ -0,0 +1,17 @@
+// Generated automatically from io.netty.channel.SimpleChannelInboundHandler for testing purposes
+
+package io.netty.channel;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+abstract public class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter
+{
+    protected SimpleChannelInboundHandler(){}
+    protected SimpleChannelInboundHandler(Class<? extends I> p0){}
+    protected SimpleChannelInboundHandler(Class<? extends I> p0, boolean p1){}
+    protected SimpleChannelInboundHandler(boolean p0){}
+    protected abstract void channelRead0(ChannelHandlerContext p0, I p1);
+    public boolean acceptInboundMessage(Object p0){ return false; }
+    public void channelRead(ChannelHandlerContext p0, Object p1){}
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/ByteToMessageDecoder.java

@@ -0,0 +1,36 @@
+// Generated automatically from io.netty.handler.codec.ByteToMessageDecoder for testing purposes
+
+package io.netty.handler.codec;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import java.util.List;
+
+abstract public class ByteToMessageDecoder extends ChannelInboundHandlerAdapter
+{
+    protected ByteBuf internalBuffer(){ return null; }
+    protected ByteToMessageDecoder(){}
+    protected abstract void decode(ChannelHandlerContext p0, ByteBuf p1, List<Object> p2);
+    protected final void discardSomeReadBytes(){}
+    protected int actualReadableBytes(){ return 0; }
+    protected void callDecode(ChannelHandlerContext p0, ByteBuf p1, List<Object> p2){}
+    protected void decodeLast(ChannelHandlerContext p0, ByteBuf p1, List<Object> p2){}
+    protected void handlerRemoved0(ChannelHandlerContext p0){}
+    public boolean isSingleDecode(){ return false; }
+    public final void handlerRemoved(ChannelHandlerContext p0){}
+    public static ByteToMessageDecoder.Cumulator COMPOSITE_CUMULATOR = null;
+    public static ByteToMessageDecoder.Cumulator MERGE_CUMULATOR = null;
+    public void channelInactive(ChannelHandlerContext p0){}
+    public void channelRead(ChannelHandlerContext p0, Object p1){}
+    public void channelReadComplete(ChannelHandlerContext p0){}
+    public void setCumulator(ByteToMessageDecoder.Cumulator p0){}
+    public void setDiscardAfterReads(int p0){}
+    public void setSingleDecode(boolean p0){}
+    public void userEventTriggered(ChannelHandlerContext p0, Object p1){}
+    static public interface Cumulator
+    {
+        ByteBuf cumulate(ByteBufAllocator p0, ByteBuf p1, ByteBuf p2);
+    }
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/DecoderResult.java

@@ -0,0 +1,21 @@
+// Generated automatically from io.netty.handler.codec.DecoderResult for testing purposes
+
+package io.netty.handler.codec;
+
+import io.netty.util.Signal;
+
+public class DecoderResult
+{
+    protected DecoderResult() {}
+    protected DecoderResult(Throwable p0){}
+    protected static Signal SIGNAL_SUCCESS = null;
+    protected static Signal SIGNAL_UNFINISHED = null;
+    public String toString(){ return null; }
+    public Throwable cause(){ return null; }
+    public boolean isFailure(){ return false; }
+    public boolean isFinished(){ return false; }
+    public boolean isSuccess(){ return false; }
+    public static DecoderResult SUCCESS = null;
+    public static DecoderResult UNFINISHED = null;
+    public static DecoderResult failure(Throwable p0){ return null; }
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/DecoderResultProvider.java

@@ -0,0 +1,11 @@
+// Generated automatically from io.netty.handler.codec.DecoderResultProvider for testing purposes
+
+package io.netty.handler.codec;
+
+import io.netty.handler.codec.DecoderResult;
+
+public interface DecoderResultProvider
+{
+    DecoderResult decoderResult();
+    void setDecoderResult(DecoderResult p0);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/Headers.java

@@ -0,0 +1,105 @@
+// Generated automatically from io.netty.handler.codec.Headers for testing purposes
+
+package io.netty.handler.codec;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface Headers<K, V, T extends Headers<K, V, T>> extends Iterable<Map.Entry<K, V>>
+{
+    Boolean getBoolean(K p0);
+    Boolean getBooleanAndRemove(K p0);
+    Byte getByte(K p0);
+    Byte getByteAndRemove(K p0);
+    Character getChar(K p0);
+    Character getCharAndRemove(K p0);
+    Double getDouble(K p0);
+    Double getDoubleAndRemove(K p0);
+    Float getFloat(K p0);
+    Float getFloatAndRemove(K p0);
+    Integer getInt(K p0);
+    Integer getIntAndRemove(K p0);
+    Iterator<Map.Entry<K, V>> iterator();
+    List<V> getAll(K p0);
+    List<V> getAllAndRemove(K p0);
+    Long getLong(K p0);
+    Long getLongAndRemove(K p0);
+    Long getTimeMillis(K p0);
+    Long getTimeMillisAndRemove(K p0);
+    Set<K> names();
+    Short getShort(K p0);
+    Short getShortAndRemove(K p0);
+    T add(Headers<? extends K, ? extends V, ? extends Object> p0);
+    T add(K p0, Iterable<? extends V> p1);
+    T add(K p0, V p1);
+    T add(K p0, V... p1);
+    T addBoolean(K p0, boolean p1);
+    T addByte(K p0, byte p1);
+    T addChar(K p0, char p1);
+    T addDouble(K p0, double p1);
+    T addFloat(K p0, float p1);
+    T addInt(K p0, int p1);
+    T addLong(K p0, long p1);
+    T addObject(K p0, Iterable<? extends Object> p1);
+    T addObject(K p0, Object p1);
+    T addObject(K p0, Object... p1);
+    T addShort(K p0, short p1);
+    T addTimeMillis(K p0, long p1);
+    T clear();
+    T set(Headers<? extends K, ? extends V, ? extends Object> p0);
+    T set(K p0, Iterable<? extends V> p1);
+    T set(K p0, V p1);
+    T set(K p0, V... p1);
+    T setAll(Headers<? extends K, ? extends V, ? extends Object> p0);
+    T setBoolean(K p0, boolean p1);
+    T setByte(K p0, byte p1);
+    T setChar(K p0, char p1);
+    T setDouble(K p0, double p1);
+    T setFloat(K p0, float p1);
+    T setInt(K p0, int p1);
+    T setLong(K p0, long p1);
+    T setObject(K p0, Iterable<? extends Object> p1);
+    T setObject(K p0, Object p1);
+    T setObject(K p0, Object... p1);
+    T setShort(K p0, short p1);
+    T setTimeMillis(K p0, long p1);
+    V get(K p0);
+    V get(K p0, V p1);
+    V getAndRemove(K p0);
+    V getAndRemove(K p0, V p1);
+    boolean contains(K p0);
+    boolean contains(K p0, V p1);
+    boolean containsBoolean(K p0, boolean p1);
+    boolean containsByte(K p0, byte p1);
+    boolean containsChar(K p0, char p1);
+    boolean containsDouble(K p0, double p1);
+    boolean containsFloat(K p0, float p1);
+    boolean containsInt(K p0, int p1);
+    boolean containsLong(K p0, long p1);
+    boolean containsObject(K p0, Object p1);
+    boolean containsShort(K p0, short p1);
+    boolean containsTimeMillis(K p0, long p1);
+    boolean getBoolean(K p0, boolean p1);
+    boolean getBooleanAndRemove(K p0, boolean p1);
+    boolean isEmpty();
+    boolean remove(K p0);
+    byte getByte(K p0, byte p1);
+    byte getByteAndRemove(K p0, byte p1);
+    char getChar(K p0, char p1);
+    char getCharAndRemove(K p0, char p1);
+    double getDouble(K p0, double p1);
+    double getDoubleAndRemove(K p0, double p1);
+    float getFloat(K p0, float p1);
+    float getFloatAndRemove(K p0, float p1);
+    int getInt(K p0, int p1);
+    int getIntAndRemove(K p0, int p1);
+    int size();
+    long getLong(K p0, long p1);
+    long getLongAndRemove(K p0, long p1);
+    long getTimeMillis(K p0, long p1);
+    long getTimeMillisAndRemove(K p0, long p1);
+    short getShort(K p0, short p1);
+    short getShortAndRemove(K p0, short p1);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/FullHttpMessage.java

@@ -0,0 +1,19 @@
+// Generated automatically from io.netty.handler.codec.http.FullHttpMessage for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.http.HttpMessage;
+import io.netty.handler.codec.http.LastHttpContent;
+
+public interface FullHttpMessage extends HttpMessage, LastHttpContent
+{
+    FullHttpMessage copy();
+    FullHttpMessage duplicate();
+    FullHttpMessage replace(ByteBuf p0);
+    FullHttpMessage retain();
+    FullHttpMessage retain(int p0);
+    FullHttpMessage retainedDuplicate();
+    FullHttpMessage touch();
+    FullHttpMessage touch(Object p0);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/FullHttpRequest.java

@@ -0,0 +1,24 @@
+// Generated automatically from io.netty.handler.codec.http.FullHttpRequest for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.http.FullHttpMessage;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http.HttpVersion;
+
+public interface FullHttpRequest extends FullHttpMessage, HttpRequest
+{
+    FullHttpRequest copy();
+    FullHttpRequest duplicate();
+    FullHttpRequest replace(ByteBuf p0);
+    FullHttpRequest retain();
+    FullHttpRequest retain(int p0);
+    FullHttpRequest retainedDuplicate();
+    FullHttpRequest setMethod(HttpMethod p0);
+    FullHttpRequest setProtocolVersion(HttpVersion p0);
+    FullHttpRequest setUri(String p0);
+    FullHttpRequest touch();
+    FullHttpRequest touch(Object p0);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpContent.java

@@ -0,0 +1,19 @@
+// Generated automatically from io.netty.handler.codec.http.HttpContent for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufHolder;
+import io.netty.handler.codec.http.HttpObject;
+
+public interface HttpContent extends ByteBufHolder, HttpObject
+{
+    HttpContent copy();
+    HttpContent duplicate();
+    HttpContent replace(ByteBuf p0);
+    HttpContent retain();
+    HttpContent retain(int p0);
+    HttpContent retainedDuplicate();
+    HttpContent touch();
+    HttpContent touch(Object p0);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpHeaders.java

@@ -0,0 +1,119 @@
+// Generated automatically from io.netty.handler.codec.http.HttpHeaders for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.http.HttpMessage;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+abstract public class HttpHeaders implements Iterable<Map.Entry<String, String>>
+{
+    protected HttpHeaders(){}
+    public HttpHeaders add(CharSequence p0, Iterable<? extends Object> p1){ return null; }
+    public HttpHeaders add(CharSequence p0, Object p1){ return null; }
+    public HttpHeaders add(HttpHeaders p0){ return null; }
+    public HttpHeaders copy(){ return null; }
+    public HttpHeaders remove(CharSequence p0){ return null; }
+    public HttpHeaders set(CharSequence p0, Iterable<? extends Object> p1){ return null; }
+    public HttpHeaders set(CharSequence p0, Object p1){ return null; }
+    public HttpHeaders set(HttpHeaders p0){ return null; }
+    public HttpHeaders setAll(HttpHeaders p0){ return null; }
+    public Iterator<? extends CharSequence> valueCharSequenceIterator(CharSequence p0){ return null; }
+    public Iterator<String> valueStringIterator(CharSequence p0){ return null; }
+    public List<String> getAll(CharSequence p0){ return null; }
+    public String get(CharSequence p0){ return null; }
+    public String get(CharSequence p0, String p1){ return null; }
+    public String toString(){ return null; }
+    public abstract HttpHeaders add(String p0, Iterable<? extends Object> p1);
+    public abstract HttpHeaders add(String p0, Object p1);
+    public abstract HttpHeaders addInt(CharSequence p0, int p1);
+    public abstract HttpHeaders addShort(CharSequence p0, short p1);
+    public abstract HttpHeaders clear();
+    public abstract HttpHeaders remove(String p0);
+    public abstract HttpHeaders set(String p0, Iterable<? extends Object> p1);
+    public abstract HttpHeaders set(String p0, Object p1);
+    public abstract HttpHeaders setInt(CharSequence p0, int p1);
+    public abstract HttpHeaders setShort(CharSequence p0, short p1);
+    public abstract Integer getInt(CharSequence p0);
+    public abstract Iterator<Map.Entry<CharSequence, CharSequence>> iteratorCharSequence();
+    public abstract Iterator<Map.Entry<String, String>> iterator();
+    public abstract List<Map.Entry<String, String>> entries();
+    public abstract List<String> getAll(String p0);
+    public abstract Long getTimeMillis(CharSequence p0);
+    public abstract Set<String> names();
+    public abstract Short getShort(CharSequence p0);
+    public abstract String get(String p0);
+    public abstract boolean contains(String p0);
+    public abstract boolean isEmpty();
+    public abstract int getInt(CharSequence p0, int p1);
+    public abstract int size();
+    public abstract long getTimeMillis(CharSequence p0, long p1);
+    public abstract short getShort(CharSequence p0, short p1);
+    public boolean contains(CharSequence p0){ return false; }
+    public boolean contains(CharSequence p0, CharSequence p1, boolean p2){ return false; }
+    public boolean contains(String p0, String p1, boolean p2){ return false; }
+    public boolean containsValue(CharSequence p0, CharSequence p1, boolean p2){ return false; }
+    public final Iterator<Map.Entry<String, String>> iteratorAsString(){ return null; }
+    public final List<String> getAllAsString(CharSequence p0){ return null; }
+    public final String getAsString(CharSequence p0){ return null; }
+    public static CharSequence newEntity(String p0){ return null; }
+    public static Date getDate(HttpMessage p0){ return null; }
+    public static Date getDate(HttpMessage p0, Date p1){ return null; }
+    public static Date getDateHeader(HttpMessage p0, CharSequence p1){ return null; }
+    public static Date getDateHeader(HttpMessage p0, CharSequence p1, Date p2){ return null; }
+    public static Date getDateHeader(HttpMessage p0, String p1){ return null; }
+    public static Date getDateHeader(HttpMessage p0, String p1, Date p2){ return null; }
+    public static HttpHeaders EMPTY_HEADERS = null;
+    public static String getHeader(HttpMessage p0, CharSequence p1){ return null; }
+    public static String getHeader(HttpMessage p0, CharSequence p1, String p2){ return null; }
+    public static String getHeader(HttpMessage p0, String p1){ return null; }
+    public static String getHeader(HttpMessage p0, String p1, String p2){ return null; }
+    public static String getHost(HttpMessage p0){ return null; }
+    public static String getHost(HttpMessage p0, String p1){ return null; }
+    public static boolean equalsIgnoreCase(CharSequence p0, CharSequence p1){ return false; }
+    public static boolean is100ContinueExpected(HttpMessage p0){ return false; }
+    public static boolean isContentLengthSet(HttpMessage p0){ return false; }
+    public static boolean isKeepAlive(HttpMessage p0){ return false; }
+    public static boolean isTransferEncodingChunked(HttpMessage p0){ return false; }
+    public static int getIntHeader(HttpMessage p0, CharSequence p1){ return 0; }
+    public static int getIntHeader(HttpMessage p0, CharSequence p1, int p2){ return 0; }
+    public static int getIntHeader(HttpMessage p0, String p1){ return 0; }
+    public static int getIntHeader(HttpMessage p0, String p1, int p2){ return 0; }
+    public static long getContentLength(HttpMessage p0){ return 0; }
+    public static long getContentLength(HttpMessage p0, long p1){ return 0; }
+    public static void addDateHeader(HttpMessage p0, CharSequence p1, Date p2){}
+    public static void addDateHeader(HttpMessage p0, String p1, Date p2){}
+    public static void addHeader(HttpMessage p0, CharSequence p1, Object p2){}
+    public static void addHeader(HttpMessage p0, String p1, Object p2){}
+    public static void addIntHeader(HttpMessage p0, CharSequence p1, int p2){}
+    public static void addIntHeader(HttpMessage p0, String p1, int p2){}
+    public static void clearHeaders(HttpMessage p0){}
+    public static void encodeAscii(CharSequence p0, ByteBuf p1){}
+    public static void removeHeader(HttpMessage p0, CharSequence p1){}
+    public static void removeHeader(HttpMessage p0, String p1){}
+    public static void removeTransferEncodingChunked(HttpMessage p0){}
+    public static void set100ContinueExpected(HttpMessage p0){}
+    public static void set100ContinueExpected(HttpMessage p0, boolean p1){}
+    public static void setContentLength(HttpMessage p0, long p1){}
+    public static void setDate(HttpMessage p0, Date p1){}
+    public static void setDateHeader(HttpMessage p0, CharSequence p1, Date p2){}
+    public static void setDateHeader(HttpMessage p0, CharSequence p1, Iterable<Date> p2){}
+    public static void setDateHeader(HttpMessage p0, String p1, Date p2){}
+    public static void setDateHeader(HttpMessage p0, String p1, Iterable<Date> p2){}
+    public static void setHeader(HttpMessage p0, CharSequence p1, Iterable<? extends Object> p2){}
+    public static void setHeader(HttpMessage p0, CharSequence p1, Object p2){}
+    public static void setHeader(HttpMessage p0, String p1, Iterable<? extends Object> p2){}
+    public static void setHeader(HttpMessage p0, String p1, Object p2){}
+    public static void setHost(HttpMessage p0, CharSequence p1){}
+    public static void setHost(HttpMessage p0, String p1){}
+    public static void setIntHeader(HttpMessage p0, CharSequence p1, Iterable<Integer> p2){}
+    public static void setIntHeader(HttpMessage p0, CharSequence p1, int p2){}
+    public static void setIntHeader(HttpMessage p0, String p1, Iterable<Integer> p2){}
+    public static void setIntHeader(HttpMessage p0, String p1, int p2){}
+    public static void setKeepAlive(HttpMessage p0, boolean p1){}
+    public static void setTransferEncodingChunked(HttpMessage p0){}
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpMessage.java

@@ -0,0 +1,15 @@
+// Generated automatically from io.netty.handler.codec.http.HttpMessage for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.handler.codec.http.HttpHeaders;
+import io.netty.handler.codec.http.HttpObject;
+import io.netty.handler.codec.http.HttpVersion;
+
+public interface HttpMessage extends HttpObject
+{
+    HttpHeaders headers();
+    HttpMessage setProtocolVersion(HttpVersion p0);
+    HttpVersion getProtocolVersion();
+    HttpVersion protocolVersion();
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpMethod.java

@@ -0,0 +1,27 @@
+// Generated automatically from io.netty.handler.codec.http.HttpMethod for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.util.AsciiString;
+
+public class HttpMethod implements Comparable<HttpMethod>
+{
+    protected HttpMethod() {}
+    public AsciiString asciiName(){ return null; }
+    public HttpMethod(String p0){}
+    public String name(){ return null; }
+    public String toString(){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public int compareTo(HttpMethod p0){ return 0; }
+    public int hashCode(){ return 0; }
+    public static HttpMethod CONNECT = null;
+    public static HttpMethod DELETE = null;
+    public static HttpMethod GET = null;
+    public static HttpMethod HEAD = null;
+    public static HttpMethod OPTIONS = null;
+    public static HttpMethod PATCH = null;
+    public static HttpMethod POST = null;
+    public static HttpMethod PUT = null;
+    public static HttpMethod TRACE = null;
+    public static HttpMethod valueOf(String p0){ return null; }
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpObject.java

@@ -0,0 +1,11 @@
+// Generated automatically from io.netty.handler.codec.http.HttpObject for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.handler.codec.DecoderResult;
+import io.netty.handler.codec.DecoderResultProvider;
+
+public interface HttpObject extends DecoderResultProvider
+{
+    DecoderResult getDecoderResult();
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpRequest.java

@@ -0,0 +1,18 @@
+// Generated automatically from io.netty.handler.codec.http.HttpRequest for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.handler.codec.http.HttpMessage;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpVersion;
+
+public interface HttpRequest extends HttpMessage
+{
+    HttpMethod getMethod();
+    HttpMethod method();
+    HttpRequest setMethod(HttpMethod p0);
+    HttpRequest setProtocolVersion(HttpVersion p0);
+    HttpRequest setUri(String p0);
+    String getUri();
+    String uri();
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/HttpVersion.java

@@ -0,0 +1,23 @@
+// Generated automatically from io.netty.handler.codec.http.HttpVersion for testing purposes
+
+package io.netty.handler.codec.http;
+
+
+public class HttpVersion implements Comparable<HttpVersion>
+{
+    protected HttpVersion() {}
+    public HttpVersion(String p0, boolean p1){}
+    public HttpVersion(String p0, int p1, int p2, boolean p3){}
+    public String protocolName(){ return null; }
+    public String text(){ return null; }
+    public String toString(){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public boolean isKeepAliveDefault(){ return false; }
+    public int compareTo(HttpVersion p0){ return 0; }
+    public int hashCode(){ return 0; }
+    public int majorVersion(){ return 0; }
+    public int minorVersion(){ return 0; }
+    public static HttpVersion HTTP_1_0 = null;
+    public static HttpVersion HTTP_1_1 = null;
+    public static HttpVersion valueOf(String p0){ return null; }
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http/LastHttpContent.java

@@ -0,0 +1,21 @@
+// Generated automatically from io.netty.handler.codec.http.LastHttpContent for testing purposes
+
+package io.netty.handler.codec.http;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.http.HttpContent;
+import io.netty.handler.codec.http.HttpHeaders;
+
+public interface LastHttpContent extends HttpContent
+{
+    HttpHeaders trailingHeaders();
+    LastHttpContent copy();
+    LastHttpContent duplicate();
+    LastHttpContent replace(ByteBuf p0);
+    LastHttpContent retain();
+    LastHttpContent retain(int p0);
+    LastHttpContent retainedDuplicate();
+    LastHttpContent touch();
+    LastHttpContent touch(Object p0);
+    static LastHttpContent EMPTY_LAST_CONTENT = null;
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http2/Http2Flags.java

@@ -0,0 +1,33 @@
+// Generated automatically from io.netty.handler.codec.http2.Http2Flags for testing purposes
+
+package io.netty.handler.codec.http2;
+
+
+public class Http2Flags
+{
+    public Http2Flags ack(boolean p0){ return null; }
+    public Http2Flags endOfHeaders(boolean p0){ return null; }
+    public Http2Flags endOfStream(boolean p0){ return null; }
+    public Http2Flags paddingPresent(boolean p0){ return null; }
+    public Http2Flags priorityPresent(boolean p0){ return null; }
+    public Http2Flags setFlag(boolean p0, short p1){ return null; }
+    public Http2Flags(){}
+    public Http2Flags(short p0){}
+    public String toString(){ return null; }
+    public boolean ack(){ return false; }
+    public boolean endOfHeaders(){ return false; }
+    public boolean endOfStream(){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public boolean isFlagSet(short p0){ return false; }
+    public boolean paddingPresent(){ return false; }
+    public boolean priorityPresent(){ return false; }
+    public int getNumPriorityBytes(){ return 0; }
+    public int getPaddingPresenceFieldLength(){ return 0; }
+    public int hashCode(){ return 0; }
+    public short value(){ return 0; }
+    public static short ACK = 0;
+    public static short END_HEADERS = 0;
+    public static short END_STREAM = 0;
+    public static short PADDED = 0;
+    public static short PRIORITY = 0;
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http2/Http2FrameAdapter.java

@@ -0,0 +1,28 @@
+// Generated automatically from io.netty.handler.codec.http2.Http2FrameAdapter for testing purposes
+
+package io.netty.handler.codec.http2;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http2.Http2Flags;
+import io.netty.handler.codec.http2.Http2FrameListener;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.handler.codec.http2.Http2Settings;
+
+public class Http2FrameAdapter implements Http2FrameListener
+{
+    public Http2FrameAdapter(){}
+    public int onDataRead(ChannelHandlerContext p0, int p1, ByteBuf p2, int p3, boolean p4){ return 0; }
+    public void onGoAwayRead(ChannelHandlerContext p0, int p1, long p2, ByteBuf p3){}
+    public void onHeadersRead(ChannelHandlerContext p0, int p1, Http2Headers p2, int p3, boolean p4){}
+    public void onHeadersRead(ChannelHandlerContext p0, int p1, Http2Headers p2, int p3, short p4, boolean p5, int p6, boolean p7){}
+    public void onPingAckRead(ChannelHandlerContext p0, long p1){}
+    public void onPingRead(ChannelHandlerContext p0, long p1){}
+    public void onPriorityRead(ChannelHandlerContext p0, int p1, int p2, short p3, boolean p4){}
+    public void onPushPromiseRead(ChannelHandlerContext p0, int p1, int p2, Http2Headers p3, int p4){}
+    public void onRstStreamRead(ChannelHandlerContext p0, int p1, long p2){}
+    public void onSettingsAckRead(ChannelHandlerContext p0){}
+    public void onSettingsRead(ChannelHandlerContext p0, Http2Settings p1){}
+    public void onUnknownFrame(ChannelHandlerContext p0, byte p1, int p2, Http2Flags p3, ByteBuf p4){}
+    public void onWindowUpdateRead(ChannelHandlerContext p0, int p1, int p2){}
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http2/Http2FrameListener.java

@@ -0,0 +1,26 @@
+// Generated automatically from io.netty.handler.codec.http2.Http2FrameListener for testing purposes
+
+package io.netty.handler.codec.http2;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http2.Http2Flags;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.handler.codec.http2.Http2Settings;
+
+public interface Http2FrameListener
+{
+    int onDataRead(ChannelHandlerContext p0, int p1, ByteBuf p2, int p3, boolean p4);
+    void onGoAwayRead(ChannelHandlerContext p0, int p1, long p2, ByteBuf p3);
+    void onHeadersRead(ChannelHandlerContext p0, int p1, Http2Headers p2, int p3, boolean p4);
+    void onHeadersRead(ChannelHandlerContext p0, int p1, Http2Headers p2, int p3, short p4, boolean p5, int p6, boolean p7);
+    void onPingAckRead(ChannelHandlerContext p0, long p1);
+    void onPingRead(ChannelHandlerContext p0, long p1);
+    void onPriorityRead(ChannelHandlerContext p0, int p1, int p2, short p3, boolean p4);
+    void onPushPromiseRead(ChannelHandlerContext p0, int p1, int p2, Http2Headers p3, int p4);
+    void onRstStreamRead(ChannelHandlerContext p0, int p1, long p2);
+    void onSettingsAckRead(ChannelHandlerContext p0);
+    void onSettingsRead(ChannelHandlerContext p0, Http2Settings p1);
+    void onUnknownFrame(ChannelHandlerContext p0, byte p1, int p2, Http2Flags p3, ByteBuf p4);
+    void onWindowUpdateRead(ChannelHandlerContext p0, int p1, int p2);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http2/Http2Headers.java

@@ -0,0 +1,24 @@
+// Generated automatically from io.netty.handler.codec.http2.Http2Headers for testing purposes
+
+package io.netty.handler.codec.http2;
+
+import io.netty.handler.codec.Headers;
+import java.util.Iterator;
+import java.util.Map;
+
+public interface Http2Headers extends Headers<CharSequence, CharSequence, Http2Headers>
+{
+    CharSequence authority();
+    CharSequence method();
+    CharSequence path();
+    CharSequence scheme();
+    CharSequence status();
+    Http2Headers authority(CharSequence p0);
+    Http2Headers method(CharSequence p0);
+    Http2Headers path(CharSequence p0);
+    Http2Headers scheme(CharSequence p0);
+    Http2Headers status(CharSequence p0);
+    Iterator<CharSequence> valueIterator(CharSequence p0);
+    Iterator<Map.Entry<CharSequence, CharSequence>> iterator();
+    boolean contains(CharSequence p0, CharSequence p1, boolean p2);
+}

java/ql/test/stubs/netty-4.1.x/io/netty/handler/codec/http2/Http2Settings.java

@@ -0,0 +1,29 @@
+// Generated automatically from io.netty.handler.codec.http2.Http2Settings for testing purposes
+
+package io.netty.handler.codec.http2;
+
+import io.netty.util.collection.CharObjectHashMap;
+
+public class Http2Settings extends CharObjectHashMap<Long>
+{
+    protected String keyToString(char p0){ return null; }
+    public Boolean pushEnabled(){ return null; }
+    public Http2Settings copyFrom(Http2Settings p0){ return null; }
+    public Http2Settings headerTableSize(long p0){ return null; }
+    public Http2Settings initialWindowSize(int p0){ return null; }
+    public Http2Settings maxConcurrentStreams(long p0){ return null; }
+    public Http2Settings maxFrameSize(int p0){ return null; }
+    public Http2Settings maxHeaderListSize(long p0){ return null; }
+    public Http2Settings pushEnabled(boolean p0){ return null; }
+    public Http2Settings(){}
+    public Http2Settings(int p0){}
+    public Http2Settings(int p0, float p1){}
+    public Integer getIntValue(char p0){ return null; }
+    public Integer initialWindowSize(){ return null; }
+    public Integer maxFrameSize(){ return null; }
+    public Long headerTableSize(){ return null; }
+    public Long maxConcurrentStreams(){ return null; }
+    public Long maxHeaderListSize(){ return null; }
+    public Long put(char p0, Long p1){ return null; }
+    public static Http2Settings defaultSettings(){ return null; }
+}

java/ql/test/stubs/netty-4.1.x/io/netty/util/AsciiString.java

@@ -0,0 +1,119 @@
+// Generated automatically from io.netty.util.AsciiString for testing purposes
+
+package io.netty.util;
+
+import io.netty.util.ByteProcessor;
+import io.netty.util.HashingStrategy;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.Collection;
+
+public class AsciiString implements CharSequence, Comparable<CharSequence>
+{
+    protected AsciiString() {}
+    public AsciiString concat(CharSequence p0){ return null; }
+    public AsciiString replace(char p0, char p1){ return null; }
+    public AsciiString subSequence(int p0){ return null; }
+    public AsciiString subSequence(int p0, int p1){ return null; }
+    public AsciiString subSequence(int p0, int p1, boolean p2){ return null; }
+    public AsciiString toLowerCase(){ return null; }
+    public AsciiString toUpperCase(){ return null; }
+    public AsciiString trim(){ return null; }
+    public AsciiString(ByteBuffer p0){}
+    public AsciiString(ByteBuffer p0, boolean p1){}
+    public AsciiString(ByteBuffer p0, int p1, int p2, boolean p3){}
+    public AsciiString(CharSequence p0){}
+    public AsciiString(CharSequence p0, Charset p1){}
+    public AsciiString(CharSequence p0, Charset p1, int p2, int p3){}
+    public AsciiString(CharSequence p0, int p1, int p2){}
+    public AsciiString(byte[] p0){}
+    public AsciiString(byte[] p0, boolean p1){}
+    public AsciiString(byte[] p0, int p1, int p2, boolean p3){}
+    public AsciiString(char[] p0){}
+    public AsciiString(char[] p0, Charset p1){}
+    public AsciiString(char[] p0, Charset p1, int p2, int p3){}
+    public AsciiString(char[] p0, int p1, int p2){}
+    public AsciiString[] split(String p0, int p1){ return null; }
+    public AsciiString[] split(char p0){ return null; }
+    public String toString(){ return null; }
+    public String toString(int p0){ return null; }
+    public String toString(int p0, int p1){ return null; }
+    public boolean contains(CharSequence p0){ return false; }
+    public boolean contentEquals(CharSequence p0){ return false; }
+    public boolean contentEqualsIgnoreCase(CharSequence p0){ return false; }
+    public boolean endsWith(CharSequence p0){ return false; }
+    public boolean equals(Object p0){ return false; }
+    public boolean isEmpty(){ return false; }
+    public boolean isEntireArrayUsed(){ return false; }
+    public boolean matches(String p0){ return false; }
+    public boolean parseBoolean(){ return false; }
+    public boolean regionMatches(boolean p0, int p1, CharSequence p2, int p3, int p4){ return false; }
+    public boolean regionMatches(int p0, CharSequence p1, int p2, int p3){ return false; }
+    public boolean startsWith(CharSequence p0){ return false; }
+    public boolean startsWith(CharSequence p0, int p1){ return false; }
+    public byte byteAt(int p0){ return 0; }
+    public byte[] array(){ return null; }
+    public byte[] toByteArray(){ return null; }
+    public byte[] toByteArray(int p0, int p1){ return null; }
+    public char charAt(int p0){ return '0'; }
+    public char parseChar(){ return '0'; }
+    public char parseChar(int p0){ return '0'; }
+    public char[] toCharArray(){ return null; }
+    public char[] toCharArray(int p0, int p1){ return null; }
+    public double parseDouble(){ return 0; }
+    public double parseDouble(int p0, int p1){ return 0; }
+    public float parseFloat(){ return 0; }
+    public float parseFloat(int p0, int p1){ return 0; }
+    public int arrayOffset(){ return 0; }
+    public int compareTo(CharSequence p0){ return 0; }
+    public int forEachByte(ByteProcessor p0){ return 0; }
+    public int forEachByte(int p0, int p1, ByteProcessor p2){ return 0; }
+    public int forEachByteDesc(ByteProcessor p0){ return 0; }
+    public int forEachByteDesc(int p0, int p1, ByteProcessor p2){ return 0; }
+    public int hashCode(){ return 0; }
+    public int indexOf(CharSequence p0){ return 0; }
+    public int indexOf(CharSequence p0, int p1){ return 0; }
+    public int indexOf(char p0, int p1){ return 0; }
+    public int lastIndexOf(CharSequence p0){ return 0; }
+    public int lastIndexOf(CharSequence p0, int p1){ return 0; }
+    public int length(){ return 0; }
+    public int parseInt(){ return 0; }
+    public int parseInt(int p0){ return 0; }
+    public int parseInt(int p0, int p1){ return 0; }
+    public int parseInt(int p0, int p1, int p2){ return 0; }
+    public long parseLong(){ return 0; }
+    public long parseLong(int p0){ return 0; }
+    public long parseLong(int p0, int p1){ return 0; }
+    public long parseLong(int p0, int p1, int p2){ return 0; }
+    public short parseShort(){ return 0; }
+    public short parseShort(int p0){ return 0; }
+    public short parseShort(int p0, int p1){ return 0; }
+    public short parseShort(int p0, int p1, int p2){ return 0; }
+    public static AsciiString EMPTY_STRING = null;
+    public static AsciiString cached(String p0){ return null; }
+    public static AsciiString of(CharSequence p0){ return null; }
+    public static CharSequence trim(CharSequence p0){ return null; }
+    public static HashingStrategy<CharSequence> CASE_INSENSITIVE_HASHER = null;
+    public static HashingStrategy<CharSequence> CASE_SENSITIVE_HASHER = null;
+    public static boolean contains(CharSequence p0, CharSequence p1){ return false; }
+    public static boolean containsAllContentEqualsIgnoreCase(Collection<CharSequence> p0, Collection<CharSequence> p1){ return false; }
+    public static boolean containsContentEqualsIgnoreCase(Collection<CharSequence> p0, CharSequence p1){ return false; }
+    public static boolean containsIgnoreCase(CharSequence p0, CharSequence p1){ return false; }
+    public static boolean contentEquals(CharSequence p0, CharSequence p1){ return false; }
+    public static boolean contentEqualsIgnoreCase(CharSequence p0, CharSequence p1){ return false; }
+    public static boolean isUpperCase(byte p0){ return false; }
+    public static boolean isUpperCase(char p0){ return false; }
+    public static boolean regionMatches(CharSequence p0, boolean p1, int p2, CharSequence p3, int p4, int p5){ return false; }
+    public static boolean regionMatchesAscii(CharSequence p0, boolean p1, int p2, CharSequence p3, int p4, int p5){ return false; }
+    public static byte c2b(char p0){ return 0; }
+    public static char b2c(byte p0){ return '0'; }
+    public static char toLowerCase(char p0){ return '0'; }
+    public static int INDEX_NOT_FOUND = 0;
+    public static int hashCode(CharSequence p0){ return 0; }
+    public static int indexOf(CharSequence p0, char p1, int p2){ return 0; }
+    public static int indexOfIgnoreCase(CharSequence p0, CharSequence p1, int p2){ return 0; }
+    public static int indexOfIgnoreCaseAscii(CharSequence p0, CharSequence p1, int p2){ return 0; }
+    public void arrayChanged(){}
+    public void copy(int p0, byte[] p1, int p2, int p3){}
+    public void copy(int p0, char[] p1, int p2, int p3){}
+}

java/ql/test/stubs/netty-4.1.x/io/netty/util/HashingStrategy.java

@@ -0,0 +1,11 @@
+// Generated automatically from io.netty.util.HashingStrategy for testing purposes
+
+package io.netty.util;
+
+
+public interface HashingStrategy<T>
+{
+    boolean equals(T p0, T p1);
+    int hashCode(T p0);
+    static HashingStrategy JAVA_HASHER = null;
+}

java/ql/test/stubs/netty-4.1.x/io/netty/util/Signal.java

@@ -0,0 +1,21 @@
+// Generated automatically from io.netty.util.Signal for testing purposes
+
+package io.netty.util;
+
+import io.netty.util.Constant;
+
+public class Signal extends Error implements Constant<Signal>
+{
+    protected Signal() {}
+    public String name(){ return null; }
+    public String toString(){ return null; }
+    public Throwable fillInStackTrace(){ return null; }
+    public Throwable initCause(Throwable p0){ return null; }
+    public boolean equals(Object p0){ return false; }
+    public int compareTo(Signal p0){ return 0; }
+    public int hashCode(){ return 0; }
+    public int id(){ return 0; }
+    public static Signal valueOf(Class<? extends Object> p0, String p1){ return null; }
+    public static Signal valueOf(String p0){ return null; }
+    public void expect(Signal p0){}
+}

java/ql/test/stubs/netty-4.1.x/io/netty/util/collection/CharObjectHashMap.java

@@ -0,0 +1,38 @@
+// Generated automatically from io.netty.util.collection.CharObjectHashMap for testing purposes
+
+package io.netty.util.collection;
+
+import io.netty.util.collection.CharObjectMap;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+public class CharObjectHashMap<V> implements CharObjectMap<V>
+{
+    protected String keyToString(char p0){ return null; }
+    public CharObjectHashMap(){}
+    public CharObjectHashMap(int p0){}
+    public CharObjectHashMap(int p0, float p1){}
+    public Collection<V> values(){ return null; }
+    public Iterable<CharObjectMap.PrimitiveEntry<V>> entries(){ return null; }
+    public Set<Character> keySet(){ return null; }
+    public Set<Map.Entry<Character, V>> entrySet(){ return null; }
+    public String toString(){ return null; }
+    public V get(Object p0){ return null; }
+    public V get(char p0){ return null; }
+    public V put(Character p0, V p1){ return null; }
+    public V put(char p0, V p1){ return null; }
+    public V remove(Object p0){ return null; }
+    public V remove(char p0){ return null; }
+    public boolean containsKey(Object p0){ return false; }
+    public boolean containsKey(char 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 static float DEFAULT_LOAD_FACTOR = 0;
+    public static int DEFAULT_CAPACITY = 0;
+    public void clear(){}
+    public void putAll(Map<? extends Character, ? extends V> p0){}
+}

java/ql/test/stubs/netty-4.1.x/io/netty/util/collection/CharObjectMap.java

@@ -0,0 +1,20 @@
+// Generated automatically from io.netty.util.collection.CharObjectMap for testing purposes
+
+package io.netty.util.collection;
+
+import java.util.Map;
+
+public interface CharObjectMap<V> extends Map<Character, V>
+{
+    Iterable<CharObjectMap.PrimitiveEntry<V>> entries();
+    V get(char p0);
+    V put(char p0, V p1);
+    V remove(char p0);
+    boolean containsKey(char p0);
+    static public interface PrimitiveEntry<V>
+    {
+        V value();
+        char key();
+        void setValue(V p0);
+    }
+}