final String term = termTokenList.get(i).getTerm();
                    String reading = readingTokenList.get(i).getTerm();
                    if (Strings.isNullOrEmpty(reading)) {
                        reading = term;
                    }
                    reading = transliterator.transliterate(reading);

                    final int pos = text.indexOf(term, offset);
                    if (pos > 0) {

    }

    public void setReading_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setReading_Terms("reading", opLambda, null);
    }

    public void setReading_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsElevateWordCA> aggsLambda) {
        setReading_Terms("reading", opLambda, aggsLambda);
    }

                if (readings != null && readings.length > i && readings[i].length > 0) {
                    for (final String reading : readings[i]) {
                        if (!l.contains(reading)) {
                            l.add(reading);
                        }
                    }
                }

                wordsList.add(word);

            this.sid = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
        }
        this.setNumEntries(SMBUtil.readInt2(buffer, bufferIndex));
        bufferIndex += 2;
        this.isEndOfSearch = ( buffer[ bufferIndex ] & 0x01 ) == 0x01 ? true : false;
        bufferIndex += 2;
        this.eaErrorOffset = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        int start = bufferIndex;
        this.namedPipeState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.readDataAvailable = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.numberOfMessages = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.messageLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

                    continue;
                }

                String reading = getReadingFromAttribute(stream);
                if (Strings.isNullOrEmpty(reading)) {
                    reading = transliterator.transliterate(att.toString());
                }
                kanaBuf.append(reading);
                offset += term.length();
            }
        }

        return kanaBuf.toString();

        int start = bufferIndex;

        bufferIndex += 2; // reserved
        this.dataCompactionMode = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 4; // 2 reserved
        this.dataLength = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.dataOffset = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 12; // 10 reserved

        return bufferIndex - start;
    }

	}
	r, err := NewReader(bytes.NewReader(data), int64(len(data)))
	if err != ErrInsecurePath {
		t.Fatalf("Error reading the archive: %v", err)
	}
	_, err = r.Open("test.txt")
	if err != nil {
		t.Errorf("Error reading file: %v", err)
	}
	if len(r.File) != 1 {
		t.Fatalf("No entries in the file list")
	}
	if r.File[0].Name != "../test.txt" {

        int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if ( structureSize != 9 ) {
            throw new SMBProtocolDecodingException("Structure size != 9");
        }

        this.sessionFlags = SMBUtil.readInt2(buffer, bufferIndex + 2);
        bufferIndex += 4;

        int securityBufferOffset = SMBUtil.readInt2(buffer, bufferIndex);

   */
  object DisconnectAtEnd : SocketPolicy

  /**
   * Request immediate close of connection without even reading the request. Use to simulate buggy
   * SSL servers closing connections in response to unrecognized TLS extensions.
   */
  object DisconnectAtStart : SocketPolicy

  /**
   * Close connection after reading the request but before writing the response. Use this to
   * simulate late connection pool failures.
   */