int start = bufferIndex;

        // StructureSize (2 bytes) - must be 44
        this.structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (this.structureSize != 44) {
            throw new SMBProtocolDecodingException("Invalid lease break structure size: " + this.structureSize);
        }
        bufferIndex += 2;

        assertTrue(body != null, "CSV response should not be null");
    }

    @Test
    void testUploadCsv_ok() {
        // Create CSV content with format: suggest_word,reading,boost
        String csvContent = NAME_PREFIX + "uploadTest1,,10\n" + NAME_PREFIX + "uploadTest2,,20\n";

        // Upload CSV
        Response response = given().header("Authorization", getTestToken())

	readerIndex := 0
	var wg sync.WaitGroup
	// if readTrigger is true, it implies next disk.ReadAt() should be tried
	// if readTrigger is false, it implies previous disk.ReadAt() was successful and there is no need
	// to try reading the next disk.
	for readTrigger := range readTriggerCh {
		newBufLK.RLock()
		canDecode := p.canDecode(newBuf)
		newBufLK.RUnlock()
		if canDecode {
			break
		}
		if readerIndex == len(p.readers) {

		if f, err := os.Open(sessionPolicyFile); err != nil {
			log.Fatalf("Unable to open session policy file: %v", err)
		} else {
			defer f.Close()
			bs, err := io.ReadAll(f)
			if err != nil {
				log.Fatalf("Error reading session policy file: %v", err)
			}
			policy = string(bs)
		}
		stsOpts.Policy = policy
	}
	if expiryDuration != 0 {
		stsOpts.DurationSeconds = int(expiryDuration.Seconds())
	}

        bufferIndex += 4;

        // Skip reserved (2 bytes)
        bufferIndex += 2;

        // Read flags
        header.flags = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        // Read session ID
        header.sessionId = SMBUtil.readInt8(buffer, bufferIndex);

        return header;
    }

    /**

        assertEquals(smbComNtTransaction.setupCount, dst[35], "setupCount should be written correctly");
        assertEquals(smbComNtTransaction.function, SmbComTransaction.readInt2(dst, 36), "function should be written correctly");
    }

    @Test
    void testWriteParameterWordsWireFormat_SecondaryTransaction() {
        // Test the writeParameterWordsWireFormat for a secondary transaction.

            doColumn("createdTime");
        }

        public void columnPermissions() {
            doColumn("permissions");
        }

        public void columnReading() {
            doColumn("reading");
        }

        public void columnSuggestWord() {
            doColumn("suggestWord");
        }

        public void columnUpdatedBy() {
            doColumn("updatedBy");
        }

        urlIterator.remove()
      }
    }
```

### Troubleshooting

1. Valid cacheable responses are not being cached

Make sure you are reading responses fully as unless they are read fully, cancelled or stalled Responses will not be cached.

### Overriding normal cache behaviour

import jcifs.Configuration;

/**
 * SMB1 transaction subcommand for calling a named pipe.
 *
 * This class implements the TRANS_CALL_NAMED_PIPE transaction which allows
 * writing data to and reading data from a named pipe in a single operation.
 */
public class TransCallNamedPipe extends SmbComTransaction {

    private static final Logger log = LoggerFactory.getLogger(TransCallNamedPipe.class);

import jcifs.internal.util.SMBUtil;

/**
 * SMB1 transaction subcommand for transacting with a named pipe.
 *
 * This class implements the TRANS_TRANSACT_NAMED_PIPE transaction which
 * combines writing data to a pipe and reading the response in a single operation.
 * This is more efficient than separate write and read operations.
 */
public class TransTransactNamedPipe extends SmbComTransaction {