// Override getBatchLimit to allow batching
        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25, andxBlock) {
            @Override
            protected int getBatchLimit(Configuration cfg, byte cmd) {
                return 1; // Allow one batched message
            }
        };

        byte[] buffer = new byte[1024];
        int length = testBlock.encode(buffer, 0);

            return new PluginDescriptor(pd);
        } else {
            XmlNode node = XmlService.read(xsr);
            PlexusConfiguration cfg = XmlPlexusConfiguration.toPlexusConfiguration(node);
            return build(source, cfg);
        }
    }

    private PluginDescriptor build(String source, PlexusConfiguration c) throws PlexusConfigurationException {

        SmbFile file = mock(SmbFile.class);
        SmbTreeHandleImpl tree = mock(SmbTreeHandleImpl.class);
        Configuration cfg = mock(Configuration.class);
        SmbFileHandleImpl fh = mock(SmbFileHandleImpl.class);

        when(file.ensureTreeConnected()).thenReturn(tree);
        when(tree.getConfig()).thenReturn(cfg);
        when(tree.getReceiveBufferSize()).thenReturn(1024);
        when(tree.getSendBufferSize()).thenReturn(1024);

image/x-xwindowdump            xwd              #
text/css                       css              # Cascading Style Sheet
text/html                      html htm         # HTML Document
text/plain                     txt ini log in cfg m4 sh     # Plain Text File
text/richtext                  rtx              # Rich Text File
text/tab-separated-values      tsv              #
text/x-setext                  etx              #

	ctx = logger.SetReqInfo(ctx, &logger.ReqInfo{})

	var vc *versioning.Versioning
	var lc *lifecycle.Lifecycle
	var lr objectlock.Retention
	var rcfg *replication.Config
	if bucket != minioMetaBucket {
		vc, err = globalBucketVersioningSys.Get(bucket)
		if err != nil {
			return err
		}

		// Check if the current bucket has a configured lifecycle policy

				} else {
					console.Debugf(applyActionsLogPrefix+" lifecycle: %s is locked, not deleting\n", obj.Name)
				}
			}
			return lifecycle.Event{Action: lifecycle.NoneAction}
		}
		if rcfg != nil && !obj.VersionPurgeStatus.Empty() && rcfg.HasActiveRules(obj.Name, true) {
			return lifecycle.Event{Action: lifecycle.NoneAction}
		}
	}

	return event
}

	// If source has versioning enabled, target must have versioning enabled
	if minioType && ((info.Versioning && !vcfg.Enabled() && !isRemoteToLocal) || (!info.Versioning && vcfg.Enabled() && isRemoteToLocal)) {
		return batchReplicationJobError{
			Code: "InvalidBucketState",

	}

	var lc *lifecycle.Lifecycle
	var rcfg lock.Retention
	var replcfg *replication.Config
	if opts.Expiration.Expire {
		// Check if the current bucket has a configured lifecycle policy
		lc, err = globalLifecycleSys.Get(bucket)
		if err != nil && !errors.Is(err, BucketLifecycleNotFound{Bucket: bucket}) {
			return objInfo, err
		}
		rcfg, err = globalBucketObjectLockSys.Get(bucket)
		if err != nil {

	// Check if bucket is object locked.
	rcfg, _ := globalBucketObjectLockSys.Get(o.Bucket)
	replCfg, _, _ := globalBucketMetadataSys.GetReplicationConfig(ctx, o.Bucket)
	tgts, _ := globalBucketTargetSys.ListBucketTargets(ctx, o.Bucket)
	o.Lifecycle = lc
	o.Versioning = vc
	o.Replication = replicationConfig{
		Config:  replCfg,
		remotes: tgts,
	}
	o.Retention = rcfg
}

			[]string{
				"<Contents><Key>pfx/a/1.txt</Key>",
			},
			"Hadoop 3.3.2, aws-sdk-java/1.12.262 Linux/5.14.0-362.24.1.el9_3.x86_64 OpenJDK_64-Bit_Server_VM/11.0.22+7 java/11.0.22 scala/2.12.15 vendor/Eclipse_Adoptium cfg/retry-mode/legacy",
		},
		{
			getListObjectsV2URL(s.endPoint, bucketName, "pfx/a/", "2", "", "", "/"),
			[]string{
				"<Prefix>pfx/a/</Prefix>",
				"<Contents><Key>pfx/a/1.txt</Key>",
			},