// Process AAD (not included in output)
        cipher.processAADBytes(associatedData, 0, associatedData.length);

        // Process message (will be encrypted)
        final byte[] output = new byte[cipher.getOutputSize(message.length)];
        int len = cipher.processBytes(message, 0, message.length, output, 0);
        len += cipher.doFinal(output, len);

        // Split ciphertext and authentication tag

		if err == nil || !wantErr.MatchString(err.Error()) {
			t.Errorf("want error matching %s, got %s", wantErr, err)
		}
		// And it should flush all output (even if it looks
		// like we may be getting an exit code)
		if got := out.String(); text != got {
			t.Errorf("want full output %q, got %q", text, got)
		}
	}
	wantErr = regexp.MustCompile("^no exit code")
	check("abc")
	check("exitcode")
	check("exitcode=")

        @Test
        @DisplayName("Should decode output parameters correctly")
        void testDecodeOut() throws NdrException {
            // Given: Close handle message with mocked return value
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);
            when(mockNdrBuffer.dec_ndr_long()).thenReturn(0);

            // When: Decoding output
            message.decode_out(mockNdrBuffer);

     * Uses the default buffer size and no output callback.
     *
     * @param process the system process to wrap
     */
    public JobProcess(final Process process) {
        this(process, InputStreamThread.MAX_BUFFER_SIZE, null);
    }

    /**
     * Constructs a new JobProcess with the specified process, buffer size, and output callback.
     *
     * @param process the system process to wrap

  @Override
  Iterator<E> elementIterator() {
    return new Itr<E>() {
      @Override
      E output(int index) {
        return enumConstants[index];
      }
    };
  }

  @Override
  Iterator<Entry<E>> entryIterator() {
    return new Itr<Entry<E>>() {
      @Override
      Entry<E> output(int index) {
        return new Multisets.AbstractEntry<E>() {
          @Override

    if (collection == null) {
      return createUnmodifiableEmptyCollection();
    }

    Collection<V> output = createCollection();
    output.addAll(collection);
    totalSize -= collection.size();
    collection.clear();

    return unmodifiableCollectionSubclass(output);
  }

  <E extends @Nullable Object> Collection<E> unmodifiableCollectionSubclass(
      Collection<E> collection) {

     * @param length the length of compressed data
     * @param outputBuffer the output buffer for decompressed data
     * @param outputOffset the offset in the output buffer
     * @param algorithm the compression algorithm that was used
     * @return the number of bytes written to the output buffer
     * @throws CIFSException if decompression fails
     */

	out, err := cmd.Output()
	if err != nil {
		if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
			return errorf("%v: %s", cmd, ee.Stderr)
		}
		return errorf("%v: %w", cmd, err)
	}

	parts := strings.SplitN(string(bytes.TrimSpace(out)), ":", 4)
	if len(parts) < 2 {
		return errorf("%v: missing ':' in output: %q", cmd, out)
	}
	importPath = parts[0]

        byte[] outBuf = new byte[output.length];
        Smb2IoctlResponse resp = new Smb2IoctlResponse(config, outBuf);

        resp.decode(packet, 0);
        assertEquals(output.length, resp.getOutputLength());
        assertArrayEquals(output, outBuf, "Output should be copied into provided buffer");
        // No Decodable output when buffer is provided
        assertNull(resp.getOutputData());

            // Redirect to ByteArrayOutputStream to avoid console output
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            java.io.PrintStream ps = new java.io.PrintStream(baos);
            exception.printStackTrace(ps);

            String output = baos.toString();
            assertNotNull(output);
            assertTrue(output.contains("DictionaryExpiredException"));
        } catch (Exception e) {