notZero = notZero || !zero
			}

			if notZero {
				dataKey := utils.ToStringKey(fieldValues...)
				if _, ok := dataResults[dataKey]; !ok {
					results = append(results, fieldValues)
					dataResults[dataKey] = []reflect.Value{elem}
				} else {
					dataResults[dataKey] = append(dataResults[dataKey], elem)
				}
			}
		}
	}

	return dataResults, results
}

                dstIndex += 4;
                SMBUtil.writeInt4(0, dst, dstIndex);
                dstIndex += 4; // Reserved
                final int dataLen = size8(nc.encode(dst, dstIndex));
                SMBUtil.writeInt2(dataLen, dst, lenOffset);
                dstIndex += dataLen;
            }
        }
        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *

     */
    private static byte[] createBuffer(int dataLen, byte[] dataBytes, String params) throws UnsupportedEncodingException {
        final byte[] paramBytes = params.getBytes(SmbConstants.DEFAULT_OEM_ENCODING);
        byte[] buffer = new byte[10 + paramBytes.length + dataLen];
        // copy params
        System.arraycopy(paramBytes, 0, buffer, 10, paramBytes.length);

                final int dataLen = SMBUtil.readInt2(buffer, ncpos + 2);

                // Validate context data length
                if (dataLen < 0 || dataLen > 1024) { // 1KB max per context
                    throw new SMBProtocolDecodingException(
                            "Invalid negotiate context data length: " + dataLen + " at position " + i + " (must be 0-1024)");
                }

        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_MEAN);
    assertThat(manyValuesAccumulatorByAddAllStatsAccumulator.mean())
        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_MEAN);
    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();

        // Test when data length exceeds outputBuffer size
        byte[] buffer = new byte[2000];
        int dataLen = outputBuffer.length + 100; // Exceeds outputBuffer size

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readDataWireFormat(buffer, 0, dataLen));

        assertEquals("Payload exceeds buffer size", exception.getMessage());
    }

    assertThat(manyValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance())
        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT);
    // For datasets of many double values, we test many combinations of finite and non-finite
    // x-values:
    for (ManyValues values : ALL_MANY_VALUES) {
      PairedStatsAccumulator accumulator =

				int64(testCase.dataLen), testCase.chunkSize, bytes.NewReader(testCase.data),
				testCase.accessKey, testCase.secretKey)
		case testCase.contentEncoding == "":
			req, err = newTestStreamingSignedRequest(http.MethodPut,
				getPutObjectURL("", testCase.bucketName, testCase.objectName),
				int64(testCase.dataLen), testCase.chunkSize, bytes.NewReader(testCase.data),

        byte[] dataHmac = getHmac(dataChecksum, codeHmac);
        SecretKeySpec dataKey = new SecretKeySpec(dataHmac, KerberosConstants.RC4_ALGORITHM);

        cipher = Cipher.getInstance(KerberosConstants.RC4_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, dataKey);

        int plainDataLength = data.length - KerberosConstants.CHECKSUM_SIZE;

    assertThat(body!!.contentType().toString()).isEqualTo(
      "application/x-www-form-urlencoded; charset=utf-8",
    )
    assertThat(bodyAsString(body)).isEqualTo("foo")
  }

  @Test
  fun dataPut() {
    val request = fromArgs("-d", "foo", "-X", "PUT", "http://example.com").createRequest()
    val body = request.body
    assertThat(request.method).isEqualTo("PUT")