exit_1
fi

# "Test if most recent tag update is replicated"
./mc tag set minio2/newbucket "key=val1"
if [ $? -ne 0 ]; then
	echo "expecting tag set to be successful. exiting.."
	exit_1
fi

sleep 10
val=$(./mc tag list minio1/newbucket --json | jq -r .tagset | jq -r .key)
if [ "${val}" != "val1" ]; then
	echo "expected bucket tag to have replicated, exiting..."

  }
}

@Throws(IOException::class)
internal fun BufferedSource.skipAll() {
  while (!exhausted()) {
    skip(buffer.size)
  }
}

/**
 * Attempts to exhaust this, returning true if successful. This is useful when reading a complete
 * source is helpful, such as when doing so completes a cache body or frees a socket connection for
 * reuse.
 */
internal fun Source.discard(
  timeout: Int,

        SuggestCreator.Options options = new SuggestCreator.Options();
        assertNotNull(options);
    }

    // Test purge success
    public void test_purge_success() {
        // Test successful purge operation
        SuggestCreator.Options options = new SuggestCreator.Options();
        assertNotNull(options);
    }

    // Test purge with exception
    public void test_purge_withException() {

                    "schema": {
                        "$ref": "#/components/schemas/Message"
                    }
                }
            }
        },
        "200": {
            "description": "Successful Response",
            "content": {
                "application/json": {
                    "schema": {
                        "$ref": "#/components/schemas/Item"
                    }
                }

   * all instances of [ResponseBody].
   */
  @get:JvmName("body") val body: ResponseBody,
  /**
   * Non-null if this response is a successful upgrade ...
   */
  @get:JvmName("socket") val socket: Socket?,
  /**
   * Returns the raw response received from the network. Will be null if this response didn't use

        // Prepare input SIDs
        SID s1 = sid("S-1-5-21-1-2-3-1001");
        SID s2 = sid("S-1-5-21-1-2-3-1002");
        jcifs.SID[] in = new jcifs.SID[] { s1, s2 };

        // Stub sendrecv to emulate successful RPC response
        doAnswer(inv -> {
            // Capture the outgoing RPC and populate result fields as the server would
            Object msg = inv.getArgument(0);

            fileIdField.setAccessible(true);
            assertArrayEquals(fileId2, (byte[]) fileIdField.get(notification));
        }

        @Test
        @DisplayName("Should maintain state after successful read")
        void testStateMaintenanceAfterRead() throws Exception {
            byte oplockLevel = 0x02;
            byte[] fileId = createTestData(16);

	}
	return strings.TrimRight(fmt.Sprintf("%s%d.%09d", sign, secs, nsecs), "0")
}

// parsePAXRecord parses the input PAX record string into a key-value pair.
// If parsing is successful, it will slice off the currently read record and
// return the remainder as r.
func parsePAXRecord(s string) (k, v, r string, err error) {
	// The size field ends at the first space.
	nStr, rest, ok := strings.Cut(s, " ")

 * mask of the ACE, the whole access check fails. If the ACE is an "allow"
 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>

 */
class SrvPipePeekResponseTest {

    private SrvPipePeekResponse response;

    @BeforeEach
    void setUp() {
        response = new SrvPipePeekResponse();
    }

    @Test
    @DisplayName("Test successful decode with data")
    void testDecodeWithData() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[24]; // 16 bytes header + 8 bytes data
        int bufferIndex = 0;