Sets the input streams for the expect instance.

@param index the number of the input stream
@param is    the input stream
@see net.sf.expectit.ExpectBuilder#withInputs(java.io.InputStream...)
435856
public void setInput(int index, InputStream is) {
        if (index >= inputStreams.length) {
            inputStreams = Arrays.copyOf(inputStreams, index + 1);
        }
        this.inputStreams[index] = is;
    }
758443
public void set(int index, byte value) {
        Preconditions.checkState(!this.readOnly, "Cannot modify a read-only ByteArraySegment.");
        Preconditions.checkElementIndex(index, this.length, "index");
        this.array[index + this.startOffset] = value;
    }
690008
public void set(int index, SoyData value) {
    if (index == list.size()) {
      list.add(ensureValidValue(value));
    } else {
      list.set(index, ensureValidValue(value));
    }
  }
684961
public void setAll(int index, Collection<? extends Byte> items) {
    rangeCheck(index, index + items.size());
    for (byte e : items) {
      elements[index++] = e;
    }
  }
302651
public void write(final AbstractIndex index)
		throws IOException
	{

		StringBuilder cmd;

		while (index.size() > 0) {

			System.out.println("Transmit Index [" + index + "]");

			cmd = index.remove();
			// System.out.println(cmd.toString());

			cmd.append("\r\n");
			writer.write(cmd.toString());
		}

		writer.flush();
	}
342762
public void createIndex(String index, boolean ignoreErrors, String indexSettings) throws IOException {
        logger.debug("create index [{}]", index);
        logger.trace("index settings: [{}]", indexSettings);

        try {
            Response response = lowLevelClient.performRequest("PUT", "/" + index,
                    Collections.emptyMap(), createEntity(indexSettings));
            logger.trace("create index response: {}", asMap(response));
        } catch (ResponseException e) {
            if (e.getResponse().getStatusLine().getStatusCode() == 400 &&
                    (e.getMessage().contains("index_already_exists_exception"))) {
                if (!ignoreErrors) {
                    throw new RuntimeException("index already exists");
                }
                logger.trace("index already exists. Ignoring error...");
                return;
            }
            throw e;
        }
        waitForHealthyIndex(index);
    }
1061604
public XEvent set(int index, XEvent event) {
		try {
			XEvent result = events.replace(event, index);
			return result;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}
622329
@Override
    public void set(int index, boolean value) {
        int i = Arrays.binarySearch(trueBits, index);
        // bit at index is set to true and shall be set to false
        if (i >= 0 && !value) {
            int[] tmp = new int[trueBits.length - 1];
            System.arraycopy(trueBits, 0, tmp, 0, i);
            System.arraycopy(trueBits, i + 1, tmp, i, trueBits.length - i - 1);
            trueBits = tmp;
        }
        // bit at index is set to false and shall be set to true
        else if (i < 0 && value) {
            int[] tmp = new int[trueBits.length + 1];
            System.arraycopy(trueBits, 0, tmp, 0, trueBits.length);
            tmp[tmp.length - 1] = index;
            trueBits = tmp;
            Arrays.sort(trueBits);
        }
    }
600532
def set_index(self, index):
        
        item = index.internalPointer()
        self.actionunit = item.internal_data()
        self.setEnabled(bool(self.actionunit.status.traceback))
284365
public void setCurrentIndex(int index) {

    // yes, index == getLength() is allowed - that is the state when the end is reached and
    // setCurrentIndex(getCurrentPosition()) should NOT cause an exception...
    if ((index < 0) || (index > getLength())) {
      throw new IndexOutOfBoundsException(Integer.toString(index));
    }
    this.offset = this.initialOffset + index;
  }
206192
public void setArg(int index,String arg){
        if(args==null){
            args = new String[index];
        }else if(args.length<index){
            String[] newArgs  = new String[index];
            System.arraycopy(args,0,newArgs,0,args.length);
            args = newArgs;
        }
        args[index-1]=arg;
    }
131388
public void
jump(int index) {
	if (index >= byteBuffer.capacity()) {
		throw new IllegalArgumentException("cannot jump past " +
						   "end of input");
	}
	byteBuffer.position(index);
	byteBuffer.limit(byteBuffer.capacity());
}
562353
public void init(InputStream is)
    {
        _is = is;
        _method = null;
        _isLastChunk = true;
        _chunkLength = 0;
        _peek = -1;
        _refs = null;
        _replyFault = null;

        if (_serializerFactory == null)
            _serializerFactory = new SerializerFactory();
    }
954959
public final OutputStream openOutputStream(int index)
  {
    Column column = _row.columns()[index];
    
    return column.openOutputStream(this);
  }
373902
public void setGetterOrSetter(String name, int index,
                                  Callable getterOrSetter, boolean isSetter)
    {
        setGetterOrSetter(name, index, getterOrSetter, isSetter, false);
    }
233239
void setChild(int index, Node child){
        if ((this.splitTest.maxBranches() >= 0)
                && (index >= this.splitTest.maxBranches())) {
            throw new IndexOutOfBoundsException();
        }
        this.children.set(index, child);
	}
626190
public StepExecution withInputs(java.util.Map<String, String> inputs) {
        setInputs(inputs);
        return this;
    }