C#/Java: Rename the directories containing the model generator and tests.

java/ql/test/utils/modelgenerator/dataflow/CaptureNeutralModels.expected

@@ -0,0 +1,27 @@
+| p;Factory;getIntValue;();generated |
+| p;FinalClass;returnsConstant;();generated |
+| p;FluentAPI$Inner;notThis;(String);generated |
+| p;ImmutablePojo;getX;();generated |
+| p;Joiner;length;();generated |
+| p;MultipleImpls$Strategy;doSomething;(String);generated |
+| p;ParamFlow;ignorePrimitiveReturnValue;(String);generated |
+| p;ParamFlow;mapType;(Class);generated |
+| p;Pojo;doNotSetValue;(String);generated |
+| p;Pojo;getBigDecimal;();generated |
+| p;Pojo;getBigInt;();generated |
+| p;Pojo;getBoxedArray;();generated |
+| p;Pojo;getBoxedCollection;();generated |
+| p;Pojo;getBoxedValue;();generated |
+| p;Pojo;getFloatArray;();generated |
+| p;Pojo;getIntValue;();generated |
+| p;Pojo;getPrimitiveArray;();generated |
+| p;PrivateFlowViaPublicInterface$SPI;openStream;();generated |
+| p;PrivateFlowViaPublicInterface$SPI;openStreamNone;();generated |
+| p;PrivateFlowViaPublicInterface;createAnSPIWithoutTrackingFile;(File);generated |
+| p;Sinks;copyFileToDirectory;(Path,Path,CopyOption[]);generated |
+| p;Sinks;propagate;(String);generated |
+| p;Sinks;readUrl;(URL,Charset);generated |
+| p;Sources;readUrl;(URL);generated |
+| p;Sources;socketStream;();generated |
+| p;Sources;sourceToParameter;(InputStream[],List);generated |
+| p;Sources;wrappedSocketStream;();generated |

java/ql/test/utils/modelgenerator/dataflow/CaptureNeutralModels.qlref

@@ -0,0 +1 @@
+utils/modelgenerator/CaptureNeutralModels.ql

java/ql/test/utils/modelgenerator/dataflow/CaptureSinkModels.expected

@@ -0,0 +1,4 @@
+| p;PrivateFlowViaPublicInterface$SPI;true;openStream;();;Argument[-1];create-file;generated |
+| p;Sinks;true;copyFileToDirectory;(Path,Path,CopyOption[]);;Argument[1];create-file;generated |
+| p;Sinks;true;readUrl;(URL,Charset);;Argument[0];open-url;generated |
+| p;Sources;true;readUrl;(URL);;Argument[0];open-url;generated |

java/ql/test/utils/modelgenerator/dataflow/CaptureSinkModels.qlref

@@ -0,0 +1 @@
+utils/modelgenerator/CaptureSinkModels.ql

java/ql/test/utils/modelgenerator/dataflow/CaptureSourceModels.expected

@@ -0,0 +1,5 @@
+| p;Sources;true;readUrl;(URL);;ReturnValue;remote;generated |
+| p;Sources;true;socketStream;();;ReturnValue;remote;generated |
+| p;Sources;true;sourceToParameter;(InputStream[],List);;Argument[0].ArrayElement;remote;generated |
+| p;Sources;true;sourceToParameter;(InputStream[],List);;Argument[1].Element;remote;generated |
+| p;Sources;true;wrappedSocketStream;();;ReturnValue;remote;generated |

java/ql/test/utils/modelgenerator/dataflow/CaptureSourceModels.qlref

@@ -0,0 +1 @@
+utils/modelgenerator/CaptureSourceModels.ql

java/ql/test/utils/modelgenerator/dataflow/CaptureSummaryModels.expected

@@ -0,0 +1,46 @@
+| p;Factory;false;create;(String);;Argument[0];ReturnValue;taint;generated |
+| p;Factory;false;create;(String,int);;Argument[0];ReturnValue;taint;generated |
+| p;Factory;false;getValue;();;Argument[-1];ReturnValue;taint;generated |
+| p;FinalClass;false;returnsInput;(String);;Argument[0];ReturnValue;taint;generated |
+| p;FluentAPI;false;returnsThis;(String);;Argument[-1];ReturnValue;value;generated |
+| p;ImmutablePojo;false;ImmutablePojo;(String,int);;Argument[0];Argument[-1];taint;generated |
+| p;ImmutablePojo;false;getValue;();;Argument[-1];ReturnValue;taint;generated |
+| p;ImmutablePojo;false;or;(String);;Argument[-1];ReturnValue;taint;generated |
+| p;ImmutablePojo;false;or;(String);;Argument[0];ReturnValue;taint;generated |
+| p;InnerClasses$CaptureMe;true;yesCm;(String);;Argument[0];ReturnValue;taint;generated |
+| p;InnerClasses;true;yes;(String);;Argument[0];ReturnValue;taint;generated |
+| p;InnerHolder;false;append;(String);;Argument[0];Argument[-1];taint;generated |
+| p;InnerHolder;false;explicitSetContext;(String);;Argument[0];Argument[-1];taint;generated |
+| p;InnerHolder;false;getValue;();;Argument[-1];ReturnValue;taint;generated |
+| p;InnerHolder;false;setContext;(String);;Argument[0];Argument[-1];taint;generated |
+| p;Joiner;false;Joiner;(CharSequence);;Argument[0];Argument[-1];taint;generated |
+| p;Joiner;false;Joiner;(CharSequence,CharSequence,CharSequence);;Argument[0];Argument[-1];taint;generated |
+| p;Joiner;false;Joiner;(CharSequence,CharSequence,CharSequence);;Argument[1];Argument[-1];taint;generated |
+| p;Joiner;false;Joiner;(CharSequence,CharSequence,CharSequence);;Argument[2];Argument[-1];taint;generated |
+| p;Joiner;false;add;(CharSequence);;Argument[-1];ReturnValue;value;generated |
+| p;Joiner;false;merge;(Joiner);;Argument[-1];ReturnValue;value;generated |
+| p;Joiner;false;setEmptyValue;(CharSequence);;Argument[-1];ReturnValue;value;generated |
+| p;Joiner;false;setEmptyValue;(CharSequence);;Argument[0];Argument[-1];taint;generated |
+| p;Joiner;false;toString;();;Argument[-1];ReturnValue;taint;generated |
+| p;MultipleImpls$Strat2;true;getValue;();;Argument[-1];ReturnValue;taint;generated |
+| p;MultipleImpls$Strategy;true;doSomething;(String);;Argument[0];Argument[-1];taint;generated |
+| p;MultipleImpls$Strategy;true;doSomething;(String);;Argument[0];ReturnValue;taint;generated |
+| p;ParamFlow;true;addTo;(String,List);;Argument[0];Argument[1].Element;taint;generated |
+| p;ParamFlow;true;returnArrayElement;(String[]);;Argument[0].ArrayElement;ReturnValue;taint;generated |
+| p;ParamFlow;true;returnCollectionElement;(List);;Argument[0].Element;ReturnValue;taint;generated |
+| p;ParamFlow;true;returnIterableElement;(Iterable);;Argument[0].Element;ReturnValue;taint;generated |
+| p;ParamFlow;true;returnIteratorElement;(Iterator);;Argument[0].Element;ReturnValue;taint;generated |
+| p;ParamFlow;true;returnMultipleParameters;(String,String);;Argument[0];ReturnValue;taint;generated |
+| p;ParamFlow;true;returnMultipleParameters;(String,String);;Argument[1];ReturnValue;taint;generated |
+| p;ParamFlow;true;returnVarArgElement;(String[]);;Argument[0].ArrayElement;ReturnValue;taint;generated |
+| p;ParamFlow;true;returnsInput;(String);;Argument[0];ReturnValue;taint;generated |
+| p;ParamFlow;true;writeChunked;(byte[],OutputStream);;Argument[0];Argument[1];taint;generated |
+| p;ParamFlow;true;writeChunked;(char[],OutputStream);;Argument[0];Argument[1];taint;generated |
+| p;Pojo;false;fillIn;(List);;Argument[-1];Argument[0].Element;taint;generated |
+| p;Pojo;false;getBoxedBytes;();;Argument[-1];ReturnValue;taint;generated |
+| p;Pojo;false;getBoxedChars;();;Argument[-1];ReturnValue;taint;generated |
+| p;Pojo;false;getByteArray;();;Argument[-1];ReturnValue;taint;generated |
+| p;Pojo;false;getCharArray;();;Argument[-1];ReturnValue;taint;generated |
+| p;Pojo;false;getValue;();;Argument[-1];ReturnValue;taint;generated |
+| p;Pojo;false;setValue;(String);;Argument[0];Argument[-1];taint;generated |
+| p;PrivateFlowViaPublicInterface;true;createAnSPI;(File);;Argument[0];ReturnValue;taint;generated |

java/ql/test/utils/modelgenerator/dataflow/CaptureSummaryModels.qlref

@@ -0,0 +1 @@
+utils/modelgenerator/CaptureSummaryModels.ql

java/ql/test/utils/modelgenerator/dataflow/p/AbstractImplOfExternalSPI.java

@@ -0,0 +1,13 @@
+package p;
+
+import java.io.File;
+import java.io.FileFilter;
+
+public abstract class AbstractImplOfExternalSPI implements FileFilter {
+
+    @Override
+    public boolean accept(File pathname) {
+        return false;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/Factory.java

@@ -0,0 +1,30 @@
+package p;
+
+public final class Factory {
+
+    private String value;
+
+    private int intValue;
+
+    public static Factory create(String value, int foo) {
+        return new Factory(value, foo);
+    }
+
+    public static Factory create(String value) {
+        return new Factory(value, 0);
+    }
+
+    private Factory(String value, int intValue) {
+        this.value = value;
+        this.intValue = intValue;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public int getIntValue() {
+        return intValue;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/FinalClass.java

@@ -0,0 +1,15 @@
+package p;
+
+public final class FinalClass {
+
+    private static final String C = "constant";
+
+    public String returnsInput(String input) {
+        return input;
+    }
+
+    public String returnsConstant() {
+        return C;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/FluentAPI.java

@@ -0,0 +1,15 @@
+package p;
+
+public final class FluentAPI {
+
+    public FluentAPI returnsThis(String input) {
+        return this;
+    }
+
+    public class Inner {
+        public FluentAPI notThis(String input) {
+            return FluentAPI.this;
+        }
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/ImmutablePojo.java

@@ -0,0 +1,26 @@
+package p;
+
+public final class ImmutablePojo {
+
+    private final String value;
+
+    private final long x;
+
+    public ImmutablePojo(String value, int x) {
+        this.value = value;
+        this.x = x;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public long getX() {
+        return x;
+    }
+
+    public String or(String defaultValue) {
+        return value != null ? value : defaultValue;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/ImplOfExternalSPI.java

@@ -0,0 +1,19 @@
+package p;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
+public class ImplOfExternalSPI extends AbstractImplOfExternalSPI {
+
+    @Override
+    public boolean accept(File pathname) {
+        try {
+            Files.createFile(pathname.toPath());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/InnerClasses.java

@@ -0,0 +1,21 @@
+package p;
+
+public class InnerClasses {
+    
+    class IgnoreMe {
+        public String no(String input) {
+            return input;
+        }
+    }
+    
+    public class CaptureMe {
+        public String yesCm(String input) {
+            return input;
+        }
+    }
+
+    public String yes(String input) {
+        return input;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/InnerHolder.java

@@ -0,0 +1,37 @@
+package p;
+
+public final class InnerHolder {
+
+    private class Context {
+        private String value;
+
+        Context(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    private Context context = null;
+
+    private StringBuilder sb = new StringBuilder();
+
+    public void setContext(String value) {
+        context = new Context(value);
+    }
+
+    public void explicitSetContext(String value) {
+        this.context = new Context(value);
+    }
+
+    public void append(String value) {
+        sb.append(value);
+    }
+
+    public String getValue() {
+        return context.getValue();
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/Joiner.java

@@ -0,0 +1,118 @@
+package p;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+public final class Joiner {
+    private final String prefix;
+    private final String delimiter;
+    private final String suffix;
+    private String[] elts;
+    private int size;
+    private int len;
+    private String emptyValue;
+    public Joiner(CharSequence delimiter) {
+        this(delimiter, "", "");
+    }
+
+    public Joiner(CharSequence delimiter,
+                        CharSequence prefix,
+                        CharSequence suffix) {
+        Objects.requireNonNull(prefix, "The prefix must not be null");
+        Objects.requireNonNull(delimiter, "The delimiter must not be null");
+        Objects.requireNonNull(suffix, "The suffix must not be null");
+        this.prefix = prefix.toString();
+        this.delimiter = delimiter.toString();
+        this.suffix = suffix.toString();
+        checkAddLength(0, 0);
+    }
+
+    public Joiner setEmptyValue(CharSequence emptyValue) {
+        this.emptyValue = Objects.requireNonNull(emptyValue,
+            "The empty value must not be null").toString();
+        return this;
+    }
+
+    private static int getChars(String s, char[] chars, int start) {
+        int len = s.length();
+        s.getChars(0, len, chars, start);
+        return len;
+    }
+
+    @Override
+    public String toString() {
+        final String[] elts = this.elts;
+        if (elts == null && emptyValue != null) {
+            return emptyValue;
+        }
+        final int size = this.size;
+        final int addLen = prefix.length() + suffix.length();
+        if (addLen == 0) {
+            compactElts();
+            return size == 0 ? "" : elts[0];
+        }
+        final String delimiter = this.delimiter;
+        final char[] chars = new char[len + addLen];
+        int k = getChars(prefix, chars, 0);
+        if (size > 0) {
+            k += getChars(elts[0], chars, k);
+            for (int i = 1; i < size; i++) {
+                k += getChars(delimiter, chars, k);
+                k += getChars(elts[i], chars, k);
+            }
+        }
+        k += getChars(suffix, chars, k);
+        return new String(chars);
+    }
+
+    public Joiner add(CharSequence newElement) {
+        final String elt = String.valueOf(newElement);
+        if (elts == null) {
+            elts = new String[8];
+        } else {
+            if (size == elts.length)
+                elts = Arrays.copyOf(elts, 2 * size);
+            len = checkAddLength(len, delimiter.length());
+        }
+        len = checkAddLength(len, elt.length());
+        elts[size++] = elt;
+        return this;
+    }
+
+    private int checkAddLength(int oldLen, int inc) {
+        long newLen = (long)oldLen + (long)inc;
+        long tmpLen = newLen + (long)prefix.length() + (long)suffix.length();
+        if (tmpLen != (int)tmpLen) {
+            throw new OutOfMemoryError("Requested array size exceeds VM limit");
+        }
+        return (int)newLen;
+    }
+
+    public Joiner merge(Joiner other) {
+        Objects.requireNonNull(other);
+        if (other.elts == null) {
+            return this;
+        }
+        other.compactElts();
+        return add(other.elts[0]);
+    }
+
+    private void compactElts() {
+        if (size > 1) {
+            final char[] chars = new char[len];
+            int i = 1, k = getChars(elts[0], chars, 0);
+            do {
+                k += getChars(delimiter, chars, k);
+                k += getChars(elts[i], chars, k);
+                elts[i] = null;
+            } while (++i < size);
+            size = 1;
+            elts[0] = new String(chars);
+        }
+    }
+
+    public int length() {
+        return (size == 0 && emptyValue != null) ? emptyValue.length() :
+            len + prefix.length() + suffix.length();
+    }
+}

java/ql/test/utils/modelgenerator/dataflow/p/MultipleImpls.java

@@ -0,0 +1,38 @@
+package p;
+
+import java.util.concurrent.Callable;
+
+public class MultipleImpls {
+
+    public static interface Strategy {
+        String doSomething(String value);
+    }
+
+    public static class Strat1 implements Strategy {
+        public String doSomething(String value) {
+            return value;
+        }
+    }
+
+    // implements in different library should not count as impl
+    public static class Strat3 implements Callable<String> {
+
+        @Override
+        public String call() throws Exception {
+            return null;
+        }
+
+    }    
+    public static class Strat2 implements Strategy {
+        private String foo;
+
+        public String doSomething(String value) {
+            this.foo = value;
+            return "none";
+        }
+        
+        public String getValue() {
+            return this.foo;
+        }
+    }
+}

java/ql/test/utils/modelgenerator/dataflow/p/ParamFlow.java

@@ -0,0 +1,64 @@
+package p;
+
+import java.util.Iterator;
+import java.util.List;
+import java.io.IOException;
+import java.io.OutputStream;
+
+
+public class ParamFlow {
+
+    public String returnsInput(String input) {
+        return input;
+    }
+
+    public int ignorePrimitiveReturnValue(String input) {
+        return input.length();
+    }
+
+    public String returnMultipleParameters(String one, String two) {
+        if (System.currentTimeMillis() > 100) {
+            return two;
+        }
+        return one;
+    }
+
+    public String returnArrayElement(String[] input) {
+        return input[0];
+    }
+
+    public String returnVarArgElement(String... input) {
+        return input[0];
+    }
+
+    public String returnCollectionElement(List<String> input) {
+        return input.get(0);
+    }
+
+    public String returnIteratorElement(Iterator<String> input) {
+        return input.next();
+    }
+
+    public String returnIterableElement(Iterable<String> input) {
+        return input.iterator().next();
+    }
+
+    public Class<?> mapType(Class<?> input) {
+        return input;
+    }
+
+    public void writeChunked(byte[] data, OutputStream output)
+            throws IOException {
+        output.write(data, 0, data.length);
+    }
+    
+    public void writeChunked(char[] data, OutputStream output)
+            throws IOException {
+        output.write(String.valueOf(data).getBytes(), 0, data.length);
+    }
+
+    public void addTo(String data, List<String> target) {
+        target.add(data);
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/Pojo.java

@@ -0,0 +1,98 @@
+package p;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+public final class Pojo {
+
+    private class Holder {
+        private String value;
+
+        Holder(String value) {
+            this.value = value;
+        }
+
+        int length() {
+            return value.length();
+        }
+    }
+
+    private String value;
+
+    private int intValue = 2;
+
+    private byte[] byteArray = new byte[] {1, 2, 3} ;
+    private float[] floatArray = new float[] {1, 2, 3} ;
+    private char[] charArray = new char[] {'a', 'b', 'c'} ;
+    private List<Character> charList = Arrays.asList('a', 'b', 'c');
+    private Byte[] byteObjectArray = new Byte[] { 1, 2, 3 };
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    public int doNotSetValue(String value) {
+        Holder h = new Holder(value);
+        return h.length();
+    }
+
+    public int getIntValue() {
+        return intValue;
+    }
+
+    public Integer getBoxedValue() {
+        return Integer.valueOf(intValue);
+    }
+
+    public int[] getPrimitiveArray() {
+        return new int[] { intValue };
+    }
+
+    public char[] getCharArray() {
+        return charArray;
+    }
+
+    public byte[] getByteArray() {
+        return byteArray;
+    }
+    
+    public float[] getFloatArray() {
+        return floatArray;
+    }
+
+    public Integer[] getBoxedArray() {
+        return new Integer[] { Integer.valueOf(intValue) };
+    }
+    
+    public Collection<Integer> getBoxedCollection() {
+        return List.of(Integer.valueOf(intValue));
+    }
+
+    public List<Character> getBoxedChars() {
+        return charList;
+    }
+
+    public Byte[] getBoxedBytes() {
+        return byteObjectArray;
+    }
+    
+    public BigInteger getBigInt() {
+        return BigInteger.valueOf(intValue);
+    }
+
+    public BigDecimal getBigDecimal() {
+        return new BigDecimal(value);
+    }
+
+    public void fillIn(List<String> target) {
+        target.add(value);
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/PrivateFlowViaPublicInterface.java

@@ -0,0 +1,61 @@
+package p;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+public class PrivateFlowViaPublicInterface {
+
+    static class RandomPojo {
+        public File someFile = new File("someFile");
+    }
+    public static interface SPI {
+        OutputStream openStream() throws IOException;
+
+        default OutputStream openStreamNone() throws IOException {
+            return null;
+        };
+    }
+
+    private static final class PrivateImplWithSink implements SPI {
+
+        private File file;
+
+        public PrivateImplWithSink(File file) {
+            this.file = file;
+        }
+
+        @Override
+        public OutputStream openStream() throws IOException {
+            return new FileOutputStream(file);
+        }
+
+    }
+    
+    private static final class PrivateImplWithRandomField implements SPI {
+
+        public PrivateImplWithRandomField(File file) {
+        }
+
+        @Override
+        public OutputStream openStream() throws IOException {
+            return null;
+        }
+        
+        @Override
+        public OutputStream openStreamNone() throws IOException {
+            return new FileOutputStream(new RandomPojo().someFile);
+        }
+
+    }
+
+    public static SPI createAnSPI(File file) {
+        return new PrivateImplWithSink(file);
+    }
+    
+    public static SPI createAnSPIWithoutTrackingFile(File file) {
+        return new PrivateImplWithRandomField(file);
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/Sinks.java

@@ -0,0 +1,34 @@
+package p;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.CopyOption;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.logging.Logger;
+
+public class Sinks {
+    
+    public Path copyFileToDirectory(final Path sourceFile, final Path targetFile, final CopyOption... copyOptions) throws IOException {
+        return Files.copy(sourceFile, targetFile, copyOptions);
+    }
+
+    public String readUrl(final URL url, Charset encoding) throws IOException {
+        try (InputStream in = url.openStream()) {
+            byte[] bytes = in.readAllBytes();
+            return new String(bytes, encoding);
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        String foo = new Sinks().readUrl(new URL(args[0]), Charset.defaultCharset());
+    }
+
+    public void propagate(String s) {
+        Logger logger = Logger.getLogger(Sinks.class.getSimpleName());
+        logger.warning(s);
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/SomeEnum.java

@@ -0,0 +1,17 @@
+package p;
+
+enum SomeEnum {
+
+    FOO("input");
+
+    private String input;
+
+    private SomeEnum(String input) {
+        this.input = input;
+    }
+
+    public String getValue() {
+        return input;
+    }
+
+}

java/ql/test/utils/modelgenerator/dataflow/p/Sources.java

@@ -0,0 +1,32 @@
+package p;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.ServerSocket;
+import java.net.URL;
+import java.util.function.Consumer;
+import java.util.List;
+
+
+public class Sources {
+    
+    public InputStream readUrl(final URL url) throws IOException {
+        return url.openConnection().getInputStream();
+    }
+
+    public InputStream socketStream() throws IOException {
+        ServerSocket socket = new ServerSocket(123);
+        return socket.accept().getInputStream();
+    }
+
+    public InputStream wrappedSocketStream() throws IOException {
+        return socketStream();
+    }
+
+    public void sourceToParameter(InputStream[] streams, List<InputStream> otherStreams) throws IOException {
+        ServerSocket socket = new ServerSocket(123);
+        streams[0] = socket.accept().getInputStream();
+        otherStreams.add(socket.accept().getInputStream());
+    }
+
+}