}
		return err
	}

	if target.natsConn != nil && args.JetStream.Enable {
		var jstream nats.JetStream
		jstream, err = target.natsConn.JetStream()
		if err != nil {
			if err.Error() != nats.ErrNoServers.Error() {
				target.loggerOnce(context.Background(), err, target.ID().String())
			}
			return err
		}
		target.jstream = jstream
	}

	yes, err := target.isActive()
	if err != nil {

			Description: "client cert key for NATS mTLS auth",
			Optional:    true,
			Type:        "string",
			Sensitive:   true,
		},
		config.HelpKV{
			Key:         target.NATSJetStream,
			Description: "enable JetStream support",
			Optional:    true,
			Type:        "on|off",
		},
		config.HelpKV{
			Key:         target.NATSQueueDir,
			Description: queueDirComment,
			Optional:    true,
			Type:        "path",

			PingInterval:      pingInterval,
			QueueDir:          env.Get(queueDirEnv, kv.Get(target.NATSQueueDir)),
			QueueLimit:        queueLimit,
			RootCAs:           rootCAs,
		}
		natsArgs.JetStream.Enable = env.Get(jetStreamEnableEnv, kv.Get(target.NATSJetStream)) == config.EnableOn

		streamingEnableEnv := target.EnvNATSStreaming
		if k != config.Default {

      stream!!.receiveHeaders(headerBlock.toHeaders(), inFinished)
    }

    override fun rstStream(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      if (pushedStream(streamId)) {
        pushResetLater(streamId, errorCode)
        return
      }
      val rstStream = removeStream(streamId)
      rstStream?.receiveRstStream(errorCode)
    }

    override fun settings(

    // Verify the peer received what was expected.
    val rstStream = peer.takeFrame()
    assertThat(rstStream.type).isEqualTo(Http2.TYPE_RST_STREAM)
    assertThat(rstStream.streamId).isEqualTo(2)
    assertThat(rstStream.errorCode).isEqualTo(ErrorCode.CANCEL)
  }

  /**

	if false {
		sr.SkipEncrypted(true)
		return sr.DebugStream(os.Stdout)
	}
	extracted := false
	for {
		stream, err := sr.NextStream()
		if err != nil {
			if err == io.EOF {
				if extracted {
					return nil
				}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {
				fmt.Println("Skipping", stream.Name, "no private key")
				if err := stream.Skip(); err != nil {

    assertThat(iia.asList()).containsExactly(0, 1, 3).inOrder();
  }

  public void testCopyOf_stream() {
    assertThat(ImmutableIntArray.copyOf(IntStream.empty()))
        .isSameInstanceAs(ImmutableIntArray.of());
    assertThat(ImmutableIntArray.copyOf(IntStream.of(0, 1, 3)).asList())
        .containsExactly(0, 1, 3)
        .inOrder();
  }

  public void testBuilder_presize_zero() {

    assertThat(iia.asList()).containsExactly(0, 1, 3).inOrder();
  }

  public void testCopyOf_stream() {
    assertThat(ImmutableIntArray.copyOf(IntStream.empty()))
        .isSameInstanceAs(ImmutableIntArray.of());
    assertThat(ImmutableIntArray.copyOf(IntStream.of(0, 1, 3)).asList())
        .containsExactly(0, 1, 3)
        .inOrder();
  }

  public void testBuilder_presize_zero() {

                            val entryName = dir.relativize(file).joinToString(separator = "/") { it.toString() }
                            jarStream.putNextEntry(JarEntry(entryName))
                            Files.copy(file, jarStream)
                            jarStream.closeEntry()
                            return FileVisitResult.CONTINUE
                        }
                    })
                }

        void readNullArrayThrows() throws Exception {
            SmbFileInputStream in = newStream();
            assertThrows(NullPointerException.class, () -> in.read(null));
        }

        @Test
        @DisplayName("readDirect with len <= 0 returns 0")
        void readDirectZeroLen() throws Exception {
            SmbFileInputStream in = newStream();
            byte[] buf = new byte[4];