/// <summary>
        /// TRANS2_SET_FS_INFORMATION Request.
        /// </summary>
        /// <param name="messageId">This is used to associate a response with a request.</param>
        /// <param name="sessionId">
        /// Set this value to 0 to request a new session setup, or set this value to a previously established session 
        /// identifier to request reauthenticate to an existing session.
        /// </param>
        /// <param name="treeId">
        /// This field identifies the subdirectory (or tree) (also referred as a share in this document) on the 
        /// server that the client is accessing.
        /// </param>
        /// <param name="isSigned">
        /// Indicate whether the SUT has message signing enabled or required.
        /// </param>
        /// <param name="isUsePassthrough">
        /// Indicate whether adding SMB_INFO_PASSTHROUGH in InformationLevel field of the request.
        /// </param>
        /// <param name="isRequireDisconnectTreeFlags">Indicate whether flags set to Disconnect_TID.</param>
        /// <param name="isRequireNoResponseFlags">Indicate whether flags set to NO_RESPONSE.</param>
        /// <param name="informationLevel">This can be used to query information from the server.</param>
        /// <param name="fid">The file identifier.</param>
        /// <param name="otherBits">If it contains other bits.</param>
        /// <param name="reserved">The reserved int value.</param>
        public void Trans2SetFsInfoRequest(
            int messageId,
            int sessionId,
            int treeId,
            bool isSigned,
            bool isUsePassthrough,
            bool isRequireDisconnectTreeFlags,
            bool isRequireNoResponseFlags,
            InformationLevel informationLevel,
            int fid,
            bool otherBits,
            int reserved)
        {
            #region Create Packet

            SmbTrans2SetFsInformationRequestPacket smbPacket = new SmbTrans2SetFsInformationRequestPacket();
            ushort uid = (ushort)this.uId[(uint)sessionId];
            ushort fileId = (ushort)this.fId[(uint)fid];

            NamespaceCifs.Trans2SmbParametersFlags transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE;

            if (isRequireDisconnectTreeFlags && isRequireNoResponseFlags)
            {
                transactOptions = NamespaceCifs.Trans2SmbParametersFlags.DISCONNECT_TID
                    | NamespaceCifs.Trans2SmbParametersFlags.NO_RESPONSE;
            }

            if (isRequireDisconnectTreeFlags && !isRequireNoResponseFlags)
            {
                transactOptions = NamespaceCifs.Trans2SmbParametersFlags.DISCONNECT_TID;
            }

            if (!isRequireDisconnectTreeFlags && isRequireNoResponseFlags)
            {
                transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NO_RESPONSE;
            }

            if (!isRequireDisconnectTreeFlags && !isRequireNoResponseFlags)
            {
                transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE;
            }

            ushort level = this.informationLevelBytes[(ushort)informationLevel];
            if (isUsePassthrough)
            {
                level += InformationLevelPathThrouth;
            }
            // FILE_FS_CONTROL_INFORMATION data
            NamespaceFscc.FileFsControlInformation fileFsControlInformation =
                new NamespaceFscc.FileFsControlInformation();

            fileFsControlInformation.DefaultQuotaLimit = uint.MinValue;
            fileFsControlInformation.DefaultQuotaThreshold = uint.MinValue;

            fileFsControlInformation.FileSystemControlFlags =
                NamespaceFscc.FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT;

            fileFsControlInformation.FreeSpaceStartFiltering = uint.MinValue;
            fileFsControlInformation.FreeSpaceStopFiltering = uint.MinValue;
            fileFsControlInformation.FreeSpaceThreshold = uint.MinValue;

            NamespaceFscc.FsccFileFsControlInformationRequestPacket fsControlPacket
                = new NamespaceFscc.FsccFileFsControlInformationRequestPacket();

            fsControlPacket.Payload = fileFsControlInformation;

            byte[] data = new byte[DataCount];
            data = fsControlPacket.ToBytes();

            smbPacket = this.smbClientStack.CreateTrans2SetFileSystemInformationRequest(
                fileId,
                transactOptions,
                (NamespaceCifs.QueryFSInformationLevel)level,
                data);

            NamespaceCifs.SMB_COM_TRANSACTION2_Request_SMB_Parameters smbParameters = smbPacket.SmbParameters;
            smbParameters.DataCount = DataCount;
            smbPacket.SmbParameters = smbParameters;

            if (isSigned)
            {
                NamespaceCifs.CifsClientPerConnection connection =
                    this.smbClientStack.Context.GetConnection(ConnectionId);

                NamespaceCifs.CifsClientPerSession session =
                    this.smbClientStack.Context.GetSession(ConnectionId, uid);

                smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
            }

            #endregion

            #region Send and Receive ExpectPacket

            this.smbClientStack.SendPacket(smbPacket);
            StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);

            NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;

            this.QueryUidTable(smbPacketResponse);
            this.QueryTidTable(smbPacketResponse);

            VerifyTransport(smbPacketResponse);
            VerifyCommonMessageSyntax(smbPacketResponse);

            if (response.GetType() == typeof(SmbErrorResponsePacket))
            {
                SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
                NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;

                if (smbErrorHeader.Status == (uint)MessageStatus.StatusInvalidInfoClass)
                {
                    smbErrorHeader.Status = (uint)MessageStatus.NotSupported;
                }

                //Workaround temp code (SetFsInfo Unknown Error TDQ)
                if (informationLevel == InformationLevel.FileFsControlInformaiton &&
                    !bool.Parse(Site.Properties["IsTDQ33016Fixed"]))
                {
                    this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, MessageStatus.AccessDenied);
                }
                else
                {
                    this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);
                }
            }
            else
            {
                SmbTrans2SetFsInformationResponsePacket smbTrans2SetFsInformationPacket
                    = response as SmbTrans2SetFsInformationResponsePacket;

                NamespaceCifs.SmbHeader trans2SetFsInformationResponseHeader =
                    smbTrans2SetFsInformationPacket.SmbHeader;

                if (this.Trans2SetFsInfoResponse != null)
                {
                    this.Trans2SetFsInfoResponse(
                        trans2SetFsInformationResponseHeader.Mid + this.addMidMark,
                        this.QueryUidTable(smbPacketResponse),
                        this.QueryTidTable(smbPacketResponse),
                        (smbPacketResponse).IsSignRequired,
                        (MessageStatus)trans2SetFsInformationResponseHeader.Status);
                }
                else
                {
                    this.Trans2SetFsInfoResponseAdditional(
                        trans2SetFsInformationResponseHeader.Mid + this.addMidMark,
                        this.QueryUidTable(smbPacketResponse),
                        this.QueryTidTable(smbPacketResponse),
                        (smbPacketResponse).IsSignRequired,
                        (MessageStatus)trans2SetFsInformationResponseHeader.Status);
                }
            }

            #endregion
        }
        /// <summary>
        /// Verify data type FileFsControlInformation
        /// </summary>
        /// <param name="fileFsControlInformation"> FileFsControlInformation type data </param>
        /// <param name="freeSpaceThreshold"> A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the indexing service to continue to filter documents and merge word lists. </param>
        /// <param name="freeSpaceStopFiltering"> A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the content indexing service to continue filtering. </param>
        /// <param name="defaultQuotaLimit"> A 64-bit signed integer that contains the default per-user disk quota limit in bytes for the volume. </param>
        public void VerifyDataTypeFileFsControlInformationForOld(
            FileFsControlInformation fileFsControlInformation,
            // long freeSpaceThreshold,
            long defaultQuotaLimit)
        {
            Site.DefaultProtocolDocShortName = "MS-FSCC";
            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug,
                "Verify MS-FSCC_R1720 ");
            //
            // Verify requirement 1720
            //
            Site.CaptureRequirementIfAreEqual<Type>(
                typeof(FileFsControlInformation),
                fileFsControlInformation.GetType(),
                1720,
                @"The message[FileFsControlInformation] contains a FILE_FS_CONTROL_INFORMATION data element.");

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug,
                "Verify MS-FSCC_R1734 Actual DefaultQuotaLimit: {0}, Expected DefaultQuotaLimit: {1}.",
                fileFsControlInformation.DefaultQuotaLimit, defaultQuotaLimit);
            //
            // Verify requirement 1734
            //
            // Verify the type and the value of the DefaultQuotaLimit
            bool isVerifyR1734 = (
                fileFsControlInformation.DefaultQuotaLimit.GetType() == typeof(Int64) &&
                fileFsControlInformation.DefaultQuotaLimit == (ulong)defaultQuotaLimit);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1734,
                1734,
                @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaLimit (8 bytes):  A 64-bit signed integer that contains
                the default per-user disk quota limit in bytes for the volume.");

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug,
                "Verify MS-FSCC_R1736 actual FileSystemControlFlags is : {0}",
                fileFsControlInformation.FileSystemControlFlags);
            //
            // Verify requirement 1736
            //
            // Verify the type of FileSystemControlFlags
            // And for the value of it, we'll verify in the next rs
            Site.CaptureRequirementIfAreEqual<Type>(
                typeof(FileSystemControlFlags_Values),
                fileFsControlInformation.FileSystemControlFlags.GetType(),
                1736,
                @"[In FILE_FS_CONTROL_INFORMATION]FileSystemControlFlags (4 bytes):
                A 32-bit unsigned integer that contains a bitmask of flags that control quota enforcement and
                logging of user-related quota events on the volume.");

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug,
                "Verify MS-FSCC_R1737 Actual FileSystemControlFlags: {0}.",
                fileFsControlInformation.FileSystemControlFlags);
            //
            // Verify requirement 1737
            //
            // As the type of the FileSystemControlFlags is verified above, we didn't here again
            // Verify the valid value of FileSystemControlFlags
            const uint FileSystemControlFlagsBitUsed = (
                0x00000008 | 0x00000020 | 0x00000010 | 0x00000080 | 0x00000040 | 0x00000002 |
                0x00000001 | 0x00000100 | 0x00000200);

            // FileSystemControlFlagsBitUnUsed contains the bit that FileSystemControlFlags unused
            const uint fileSystemControlFlagsBitUnUsed = ~FileSystemControlFlagsBitUsed;

            bool isVerifyR1737 = (
                ((uint)fileFsControlInformation.FileSystemControlFlags & fileSystemControlFlagsBitUnUsed) == 0x00000000);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1737,
                1737,
                @"[In FILE_FS_CONTROL_INFORMATION]FileSystemControlFlags (4 bytes):  The following bit flags
                [FILE_VC_CONTENT_INDEX_DISABLED 0x00000008, FILE_VC_LOG_QUOTA_LIMIT 0x00000020,
                FILE_VC_LOG_QUOTA_THRESHOLD 0x00000010, FILE_VC_LOG_VOLUME_LIMIT 0x00000080,
                FILE_VC_LOG_VOLUME_THRESHOLD 0x00000040, FILE_VC_QUOTA_ENFORCE 0x00000002,
                FILE_VC_QUOTA_TRACK 0x00000001, FILE_VC_QUOTAS_INCOMPLETE 0x00000100,
                FILE_VC_QUOTAS_REBUILDING 0x00000200] are valid in any combination.");
            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug,
                "Verify MS-FSCC_R1739 the FileSystemControlFlags is {0}",
                fileFsControlInformation.FileSystemControlFlags);
            //
            // Verify requirement 1739
            //
            const uint bitUsed_r1739 =
                (uint)FileSystemControlFlags_Values.FILE_VC_CONTENT_INDEX_DISABLED |
                (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT |
                (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_THRESHOLD |
                (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_LIMIT |
                (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_THRESHOLD |
                (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_ENFORCE |
                (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_TRACK |
                (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_INCOMPLETE |
                (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_REBUILDING;

            const uint bitUnUsed_r1739 = ~bitUsed_r1739;

            Site.CaptureRequirementIfAreEqual<uint>(
                0x00000000,
                bitUnUsed_r1739 & (uint)fileFsControlInformation.FileSystemControlFlags,
                1739,
                @"[In FILE_FS_CONTROL_INFORMATION]FileSystemControlFlags (4 bytes):  Bits not defined in the
                following table[FILE_VC_CONTENT_INDEX_DISABLED 0x00000008, FILE_VC_LOG_QUOTA_LIMIT 0x00000020,
                FILE_VC_LOG_QUOTA_THRESHOLD 0x00000010, FILE_VC_LOG_VOLUME_LIMIT 0x00000080,
                FILE_VC_LOG_VOLUME_THRESHOLD 0x00000040, FILE_VC_QUOTA_ENFORCE 0x00000002, FILE_VC_QUOTA_TRACK
                0x00000001, FILE_VC_QUOTAS_INCOMPLETE 0x00000100, FILE_VC_QUOTAS_REBUILDING 0x00000200] MUST be
                ignored.<83><84>");

            Site.DefaultProtocolDocShortName = Site.Properties["ProtocolShortName"];
        }
        /// <summary>
        /// Verify the message syntax in  FILE_FS_CONTROL_INFORMATION
        /// </summary>
        /// <param name="fileFsControlInformation">A FileFsControlInformation type structure.</param>
        /// <param name="defaultPerUserDiskQuatoLimit">The default per-user disk quota limit in bytes for the volume.</param>
        /// <param name="deaultPerUserDiskQuotaWarningThreshold">the default per-user disk quota warning threshold 
        /// in bytes for the volume</param>
        /// <param name="minAmountOfFreeDiskSpaceForStartFiltering">minimum amount of free disk space in bytes that is 
        /// required for the operating system's content indexing service to begin document filtering.</param>
        /// <param name="minAmountOfFreeDiskSpaceForStopFiltering">the minimum amount of free disk space in bytes that 
        /// is required for the content indexing service to continue filtering</param>
        /// <param name="minAmountOfFreeDiskSpaceForThreshold">the minimum amount of free disk space in bytes that is 
        /// required for the indexing service to continue to filter documents and merge word lists.</param>
        public void VerifyMessageSyntaxFileFsControlInformation(
            FileFsControlInformation fileFsControlInformation,
            long deaultPerUserDiskQuotaWarningThreshold,
            long minAmountOfFreeDiskSpaceForStartFiltering,
            long minAmountOfFreeDiskSpaceForStopFiltering,
            long minAmountOfFreeDiskSpaceForThreshold)
        {
            Site.DefaultProtocolDocShortName = "MS-FSCC";
            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1720");

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1720
            //
            // If FILE_FS_CONTROL_INFORMATION is not null in the message then means the message contains it,
            // so can capture this requirement just by verifying this field is not null
            Site.CaptureRequirementIfIsNotNull(
                fileFsControlInformation,
                1720,
                @"The message[FileFsControlInformation] contains a FILE_FS_CONTROL_INFORMATION data element.");
            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1735,the value of DefaultQuotaLimit is {0}",
                fileFsControlInformation.DefaultQuotaLimit);

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1735
            //
            bool isVerifyR1735 = (Marshal.SizeOf(fileFsControlInformation.DefaultQuotaLimit) == 8) &&
                ((fileFsControlInformation.DefaultQuotaLimit >= 0) ||
                (fileFsControlInformation.DefaultQuotaLimit == 0xFFFFFFFFFFFFFFFF));

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1735,
                1735,
                @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaLimit (8 bytes):  This field MUST be set to a 64-bit integer value greater than or equal to 0 to set a default disk quota limit per user for this volume, or to (-1) to specify that no default quota limit per user is set.");

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1732,the value of DefaultQuotaThreshold is {0}",
                fileFsControlInformation.DefaultQuotaThreshold);

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1732
            //
            bool isVerifyR1732 =
                (Marshal.SizeOf(fileFsControlInformation.DefaultQuotaThreshold) == 8) &&
                (fileFsControlInformation.DefaultQuotaThreshold == (ulong)deaultPerUserDiskQuotaWarningThreshold);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1732,
                1732,
                @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaThreshold (8 bytes):  A 64-bit signed integer that contains the default per-user disk quota warning threshold in bytes for the volume.");

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1733,the value of DefaultQuotaThreshold is {0}",
                fileFsControlInformation.DefaultQuotaThreshold);

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1733
            //
            bool isVerifyR1733 = (Marshal.SizeOf(fileFsControlInformation.DefaultQuotaThreshold) == 8) &&
                (fileFsControlInformation.DefaultQuotaThreshold >= 0 ||
                fileFsControlInformation.DefaultQuotaThreshold == 0xFFFFFFFFFFFFFFFF);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1733,
                1733,
                @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaThreshold (8 bytes): This field MUST be set to a 64-bit integer value greater than or equal to 0 to set a default quota warning threshold per user for this volume, or to (-1) to specify that no default quota warning threshold per user is set.");

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1723,the value of FreeSpaceStartFiltering is {0}",
                fileFsControlInformation.FreeSpaceStartFiltering);

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1723
            //
            bool isVerifyR1723 =
                (Marshal.SizeOf(fileFsControlInformation.FreeSpaceStartFiltering) == 8) &&
                (fileFsControlInformation.FreeSpaceStartFiltering == minAmountOfFreeDiskSpaceForStartFiltering);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1723,
                1723,
                @"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStartFiltering (8 bytes):  A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the operating system's content indexing service to begin document filtering.");

            //
            // Verify requirement MS-FSCC_R1724 and MS-FSCC_R1975
            //
            string isR1724Implementated = Site.Properties.Get("SHOULDMAY.IsR1724Implementated");
            bool isR1975Satisfied = (fileFsControlInformation.FreeSpaceStartFiltering == 0);

            if (isWindows)
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1975,the value of FreeSpaceStartFiltering is {0}", fileFsControlInformation.FreeSpaceStartFiltering);
                //
                // Verify MS-FSCC requirement: MS-FSCC_R1975
                //
                Site.CaptureRequirementIfIsTrue(
                    isR1975Satisfied,
                    1975,
                    @"<80> Section 2.5.2: Windows sets this value[FreeSpaceStartFiltering] to 0.");

                if (null == isR1724Implementated)
                {
                    Site.Properties.Add("SHOULDMAY.IsR1724Implementated", Boolean.TrueString);
                    isR1724Implementated = Boolean.TrueString;
                }
            }

            if (null != isR1724Implementated)
            {
                bool implement = Boolean.Parse(isR1724Implementated);
                bool isSatisfied = isR1975Satisfied;

                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1724,the value of FreeSpaceStartFiltering is {0}", fileFsControlInformation.FreeSpaceStartFiltering);
                //
                // Verify MS-FSCC requirement: MS-FSCC_R1724
                //
                Site.CaptureRequirementIfAreEqual<Boolean>(
                    implement,
                    isSatisfied,
                    1724,
                    String.Format(@"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStartFiltering (8 bytes):  This value SHOULD be set to 0.<80> This requirement is {0} implement", implement ? "" : "not"));
            }

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1729,the value of FreeSpaceStopFiltering is {0}", fileFsControlInformation.FreeSpaceStopFiltering);

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1729
            //
            bool isVerifyR1729 =
                (Marshal.SizeOf(fileFsControlInformation.FreeSpaceStopFiltering) == 8) &&
                (fileFsControlInformation.FreeSpaceStopFiltering == minAmountOfFreeDiskSpaceForStopFiltering);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1729,
                1729,
                @"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStopFiltering (8 bytes):  A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the content indexing service to continue filtering.");

            //
            // Verify requirement MS-FSCC_R1730 and MS-FSCC_R1977
            //
            string isR1730Implementated = Site.Properties.Get("SHOULDMAY.IsR1730Implementated");
            bool isR1977Satisfied = (fileFsControlInformation.FreeSpaceStopFiltering == 0);

            if (isWindows)
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1977,the value of FreeSpaceStopFiltering is{0}", fileFsControlInformation.FreeSpaceStopFiltering);
                //
                // Verify MS-FSCC requirement: MS-FSCC_R1977
                //
                Site.CaptureRequirementIfIsTrue(
                    isR1977Satisfied,
                    1977,
                    @"<82> Section 2.5.2: Windows sets this value[FreeSpaceStopFiltering] to 0.");

                if (null == isR1730Implementated)
                {
                    Site.Properties.Add("SHOULDMAY.IsR1730Implementated", Boolean.TrueString);
                    isR1730Implementated = Boolean.TrueString;
                }
            }

            if (null != isR1730Implementated)
            {
                bool implement = Boolean.Parse(isR1730Implementated);
                bool isSatisfied = isR1977Satisfied;

                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1730,the value of FreeSpaceStopFiltering is{0}", fileFsControlInformation.FreeSpaceStopFiltering);
                //
                // Verify MS-FSCC requirement: MS-FSCC_R1730
                //
                Site.CaptureRequirementIfAreEqual<Boolean>(
                    implement,
                    isSatisfied,
                    1730,
                    String.Format(@"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStopFiltering (8 bytes): This value SHOULD be set to 0.<82> This requirement is {0} implement", implement ? "" : "not"));
            }

            //
            // Add the debug information
            //
            Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1726,the value of FreeSpaceThreshold is {0}", fileFsControlInformation.FreeSpaceThreshold);

            //
            // Verify MS-FSCC requirement: MS-FSCC_R1726
            //
            bool isVerifyR1726 =
                (Marshal.SizeOf(fileFsControlInformation.FreeSpaceThreshold) == 8) &&
                (fileFsControlInformation.FreeSpaceThreshold == minAmountOfFreeDiskSpaceForThreshold);

            Site.CaptureRequirementIfIsTrue(
                isVerifyR1726,
                1726,
                @"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceThreshold (8 bytes):  A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the indexing service to continue to filter documents and merge word lists.");

            //
            // Verify requirement MS-FSCC_R1727 and MS-FSCC_R1976
            //
            string isR1727Implementated = Site.Properties.Get("SHOULDMAY.IsR1727Implementated");
            bool isR1976Satisfied = (fileFsControlInformation.FreeSpaceThreshold == 0);

            if (isWindows)
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1976,the value of FreeSpaceThreshold is {0}", fileFsControlInformation.FreeSpaceThreshold);
                //
                // Verify MS-FSCC requirement: MS-FSCC_R1976
                //
                Site.CaptureRequirementIfIsTrue(
                    isR1976Satisfied,
                    1976,
                    @"<81> Section 2.5.2: Windows sets this value[FreeSpaceThreshold] to 0.");

                if (null == isR1727Implementated)
                {
                    Site.Properties.Add("SHOULDMAY.IsR1727Implementated", Boolean.TrueString);
                    isR1727Implementated = Boolean.TrueString;
                }
            }

            if (null != isR1727Implementated)
            {
                bool implement = Boolean.Parse(isR1727Implementated);
                bool isSatisfied = isR1976Satisfied;

                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1727,the value of FreeSpaceThreshold is {0}", fileFsControlInformation.FreeSpaceThreshold);
                //
                // Verify MS-FSCC requirement: MS-FSCC_R1727
                //
                Site.CaptureRequirementIfAreEqual<Boolean>(
                    implement,
                    isSatisfied,
                    1727,
                    String.Format(@"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceThreshold (8 bytes):  This value SHOULD be set to 0.<81> This requirement is {0} implement", implement ? "" : "not"));
            }

            Site.DefaultProtocolDocShortName = Site.Properties["ProtocolShortName"];
        }
        /// <summary>
        /// Verify the FileFsControlInformation fields
        /// </summary>
        /// <param name="info">the instance of FileFsControlInformation</param>
        public void VerifyDataTypeFileFsControlInformation(FileFsControlInformation info)
        {
            Site.DefaultProtocolDocShortName = "MS-FSCC";
            if (bool.Parse(Site.Properties["SUT.Platform.OS.isWindows"]))
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1976");

                //
                // Verify MS-FSCC requirement: MS-FSCC_R1976
                //
                Site.CaptureRequirementIfAreEqual<long>(
                    0,
                    info.FreeSpaceThreshold,
                    1976,
                    @"<81> Section 2.5.2: Windows sets this value[FreeSpaceThreshold] to 0.");

                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1977");

                //
                // Verify MS-FSCC requirement: MS-FSCC_R1977
                //
                Site.CaptureRequirementIfAreEqual<long>(
                    0,
                    info.FreeSpaceStopFiltering,
                    1977,
                    @"<82> Section 2.5.2: Windows sets this value[FreeSpaceStopFiltering] to 0.");

                // the bit flags combination
                uint bitsCombination = ((uint)FileSystemControlFlags_Values.FILE_VC_CONTENT_INDEX_DISABLED |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_THRESHOLD |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_LIMIT |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_THRESHOLD |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_ENFORCE |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_TRACK |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_INCOMPLETE |
                                        (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_REBUILDING);
                // FileSystemControlFlags is set to any other bit except all above
                if (((uint)info.FileSystemControlFlags & ~bitsCombination) == 0)
                {

                    //
                    // Add the debug information
                    //
                    Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1978");

                    //
                    // Verify MS-FSCC requirement: MS-FSCC_R1978
                    //
                    Site.CaptureRequirementIfAreEqual<uint>(
                        0,
                        (uint)info.FileSystemControlFlags,
                        1978,
                        @"<83> Section 2.5.2: Windows sets flags not defined below[[FILE_VC_CONTENT_INDEX_DISABLED
                        0x00000008, FILE_VC_LOG_QUOTA_LIMIT 0x00000020, FILE_VC_LOG_QUOTA_THRESHOLD 0x00000010,
                        FILE_VC_LOG_VOLUME_LIMIT 0x00000080, FILE_VC_LOG_VOLUME_THRESHOLD 0x00000040,
                        FILE_VC_QUOTA_ENFORCE 0x00000002, FILE_VC_QUOTA_TRACK 0x00000001, FILE_VC_QUOTAS_INCOMPLETE
                        0x00000100, FILE_VC_QUOTAS_REBUILDING 0x00000200] to zero.");
                }
            }

            Site.DefaultProtocolDocShortName = Site.Properties["ProtocolShortName"];
        }