if err != nil {
				logger.FatalIf(err, "Unable to get free port for Console UI on the host")
			}
			// hold the port
			l, err := net.Listen("TCP", fmt.Sprintf(":%s", p.String()))
			if err == nil {
				defer l.Close()
			}
			consoleAddr = net.JoinHostPort("", p.String())
		}

		if _, _, err := net.SplitHostPort(consoleAddr); err != nil {
			logger.FatalIf(err, "Unable to start listening on console port")
		}

            this.stream = stream;
            this.collector = collector;
        }


        @Override
        public void close () throws IOException {
            this.stream.close();
            this.collector.close();
        }


        @Override
        public void flush () throws IOException {
            this.stream.flush();
            this.collector.flush();

        out.append(lines.next()).append(lineSeparator);
      }
    }
  }

  /**
   * Writes all the text from the given {@link Readable} (such as a {@link Reader}) to this sink.
   * Does not close {@code readable} if it is {@code Closeable}.
   *
   * @return the number of characters written
   * @throws IOException if an I/O error occurs while reading from {@code readable} or writing to
   *     this sink
   */

                logger.info("Close {}", docIndex);
                searchEngineClient.admin().indices().prepareOpen(docIndex).execute(
                        ActionListener.wrap(res2 -> logger.info("Open {}", docIndex), e -> logger.warn("Failed to open {}", docIndex, e)));
            }, e -> logger.warn("Failed to close {}", docIndex, e)));
        });

        resource.setContentLength(size - 1);

        DefaultRepositorySystemSession session = new DefaultRepositorySystemSession(h -> false); // no close handle

        // warm up
        test(listener, session, resource, 0);

        for (int i = 1; i < size; i++) {
            final int bytes = i;

            service.execute(() -> {

				Key:       entry.Name,
				Size:      entry.Size,
				ModTime:   entry.ModTime,
				VersionID: entry.VersionID,
				Content:   gr,
				Headers:   make(http.Header),
				Close: func() {
					gr.Close()
				},
			}

			opts, err := batchReplicationOpts(ctx, "", gr.ObjInfo)
			if err != nil {
				batchLogIf(ctx, err)
				continue
			}

			for k, vals := range opts.Header() {

                        this.tree = null;
                        this.treeAcquired = false;
                        et.close();
                        et.disconnect(false, false);
                    }
                    catch ( Exception e ) {
                        log.error("Failed to close exclusive transport", e);
                    }
                }
            }
        }
        else if ( usage < 0 ) {

					f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_SYNC, 0)
					if err != nil {
						t.Fatalf("Failed to open %s: %s\n", filePath, err)
					}
					f.WriteString("oops") // Will cause bitrot error
					f.Close()
					break
				}

			}

			rQuorum := len(errs) - z.serverPools[0].sets[0].defaultParityCount
			onlineDisks, modTime, _ := listOnlineDisks(erasureDisks, partsMetadata, test.errs, rQuorum)

    // one. (StringCoding$StringDecoder vs. StreamDecoder).  StringCoding has a ton of special cases
    // theoretically we could duplicate all that logic here to try to beat 'new String' or at least
    // come close.
    USING_DECODER_WITH_SIZE_HINT {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        Optional<Long> size = byteSource.sizeIfKnown();

            inLen += n;
        }
        if( inLen < 100 || inLen == IN_SIZE ) {
            throw new IOException( "Error reading jcifs/smb1/util/mime.map resource" );
        }
        is.close();
    }

    public String getMimeType( String extension ) throws IOException {
        return getMimeType( extension, "application/octet-stream" );
    }