public void BVT_SMB2Basic_LockAndUnLock() { uint status; string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb); #region From client1 lock a byte range and try to write content to the file within the range BaseTestSite.Log.Add( LogEntryKind.Comment, "From client1 locks a byte range and try to write content to the file within the range."); BaseTestSite.Log.Add( LogEntryKind.TestStep, "Start client1 to create a file with sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE."); client1 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite); client1.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress); status = client1.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled); status = client1.SessionSetup( TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, TestConfig.UseServerGssToken); uint treeId1; status = client1.TreeConnect(uncSharePath, out treeId1); Smb2CreateContextResponse[] serverCreateContexts; FILEID fileId1; string fileName = Guid.NewGuid().ToString() + ".txt"; status = client1.Create( treeId1, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId1, out serverCreateContexts); BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client1 writes content to the file created."); status = client1.Write(treeId1, fileId1, content); BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down client1 by sending CLOSE request."); client1.Close(treeId1, fileId1); BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client1 sends CREATE request."); status = client1.Create( treeId1, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId1, out serverCreateContexts); //Construct LOCK_ELEMENT LOCK_ELEMENT[] locks = new LOCK_ELEMENT[1]; uint lockSequence = 0; locks[0].Offset = 0; locks[0].Length = (ulong)TestConfig.WriteBufferLengthInKb * 1024; locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK; BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client1 starts to lock a byte range for file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3})", fileName, locks[0].Offset, locks[0].Length, locks[0].Flags.ToString()); status = client1.Lock(treeId1, lockSequence++, fileId1, locks); BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client1 sends WRITE request to write content to the locking range"); status = client1.Write( treeId1, fileId1, content, checker: (header, response) => { BaseTestSite.Assert.AreNotEqual( Smb2Status.STATUS_SUCCESS, header.Status, "All opens MUST NOT be allowed to write within the range when SMB2_LOCKFLAG_SHARED_LOCK set, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status)); BaseTestSite.CaptureRequirementIfAreEqual( Smb2Status.STATUS_FILE_LOCK_CONFLICT, header.Status, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description); }); #endregion #region From client2 to read and write the locking range of the same file after lock BaseTestSite.Log.Add( LogEntryKind.Comment, "From client2 to read and take shared lock on the locking range of the same file after lock"); BaseTestSite.Log.Add( LogEntryKind.TestStep, "Start client2 to create a file with sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE."); client2 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite); client2.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress); status = client2.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled); status = client2.SessionSetup( TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, TestConfig.UseServerGssToken); uint treeId2; status = client2.TreeConnect(uncSharePath, out treeId2); FILEID fileId2; status = client2.Create( treeId2, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId2, out serverCreateContexts); string data; Random random = new Random(); uint offset = (uint)random.Next(0, TestConfig.WriteBufferLengthInKb * 1024 - 1); uint length = (uint)random.Next(0, (int)(TestConfig.WriteBufferLengthInKb * 1024 - offset)); BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client2 sends READ request to read a random area in the locking range of file \"{0}\" with offset: {1}, length: {2}", fileName, offset, length); status = client2.Read(treeId2, fileId2, offset, length, out data); //Construct LOCK_ELEMENT LOCK_ELEMENT[] locksFromOtherOpen = new LOCK_ELEMENT[1]; locksFromOtherOpen[0].Offset = offset; locksFromOtherOpen[0].Length = (ulong)length; locksFromOtherOpen[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK; BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client2 attempts to take a shared lock on random range of file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3})", fileName, locksFromOtherOpen[0].Offset, locksFromOtherOpen[0].Length, locksFromOtherOpen[0].Flags.ToString()); status = client2.Lock(treeId2, lockSequence++, fileId2, locksFromOtherOpen); locksFromOtherOpen[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_UNLOCK; BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client2 attempts to unlock the range"); status = client2.Lock(treeId2, lockSequence++, fileId2, locksFromOtherOpen); BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client2 sends WRITE request to write a random area in the locking range of file \"{0}\" after lock", fileName); status = client2.Write( treeId2, fileId2, content, offset, checker: (header, response) => { BaseTestSite.Assert.AreNotEqual( Smb2Status.STATUS_SUCCESS, header.Status, "All opens MUST NOT be allowed to write within the range when SMB2_LOCKFLAG_SHARED_LOCK set, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status)); BaseTestSite.CaptureRequirementIfAreEqual( Smb2Status.STATUS_FILE_LOCK_CONFLICT, header.Status, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description); }); #endregion #region From client1 unlock the range BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client1 unlocks the range"); locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_UNLOCK; BaseTestSite.Log.Add( LogEntryKind.Debug, "Client1 attempts to unlock the range"); status = client1.Lock(treeId1, lockSequence++, fileId1, locks); BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down client1 by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF"); client1.Close(treeId1, fileId1); client1.TreeDisconnect(treeId1); client1.LogOff(); #endregion #region From client2 write content to the previous locking range after unlock BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client2 sends WRITE request to write content to the previous locking range after unlock"); BaseTestSite.Log.Add( LogEntryKind.Debug, "Client2 attempts to write a random area in the locking range of file \"{0}\" after unlock", fileName); status = client2.Write(treeId2, fileId2, content, offset); BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down client2 by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF"); client2.Close(treeId2, fileId2); client2.TreeDisconnect(treeId2); client2.LogOff(); #endregion }
public void FileServerFailover_Lock() { FILEID fileIdBeforeFailover; uint treeIdBeforeFailover; BaseTestSite.Log.Add(LogEntryKind.TestStep, "BeforeFailover: Connect to general file server {0}.", TestConfig.ClusteredFileServerName); ConnectGeneralFileServerBeforeFailover(TestConfig.ClusteredFileServerName, out treeIdBeforeFailover); #region CREATE a durable open with flag DHANDLE_FLAG_PERSISTENT BaseTestSite.Log.Add(LogEntryKind.TestStep, "BeforeFailover: CREATE a durable open with flag DHANDLE_FLAG_PERSISTENT."); Smb2CreateContextResponse[] serverCreateContexts; createGuid = Guid.NewGuid(); status = clientBeforeFailover.Create( treeIdBeforeFailover, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileIdBeforeFailover, out serverCreateContexts, RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE, new Smb2CreateContextRequest[] { new Smb2CreateDurableHandleRequestV2 { CreateGuid = createGuid, Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT, Timeout = 3600000, }, new Smb2CreateQueryOnDiskId { }, }); #endregion #region WRITE content to file BaseTestSite.Log.Add(LogEntryKind.TestStep, "BeforeFailover: WRITE content to file."); status = clientBeforeFailover.Write(treeIdBeforeFailover, fileIdBeforeFailover, contentWrite); #endregion #region Request byte range lock LOCK_ELEMENT[] locks = new LOCK_ELEMENT[1]; uint lockSequence = 0; locks[0].Offset = 0; locks[0].Length = (ulong)TestConfig.WriteBufferLengthInKb * 1024; locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK; BaseTestSite.Log.Add( LogEntryKind.TestStep, "Client1 start to lock a byte range for file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3}", fileName, locks[0].Offset, locks[0].Length, locks[0].Flags.ToString()); status = clientBeforeFailover.Lock(treeIdBeforeFailover, lockSequence++, fileIdBeforeFailover, locks); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "Do failover of the file server."); FailoverServer(currentAccessIp, TestConfig.ClusteredFileServerName, FileServerType.GeneralFileServer); FILEID fileIdAfterFailover = FILEID.Zero; uint treeIdAfterFailover; BaseTestSite.Log.Add(LogEntryKind.TestStep, "AfterFailover: Reconnect to the same general file server {0}.", TestConfig.ClusteredFileServerName); ReconnectServerAfterFailover(TestConfig.ClusteredFileServerName, FileServerType.GeneralFileServer, out treeIdAfterFailover); #region CREATE to reconnect previous duarable open with flag DHANDLE_FLAG_PERSISTENT BaseTestSite.Log.Add(LogEntryKind.TestStep, "AfterFailover: CREATE to reconnect previous duarable open with flag DHANDLE_FLAG_PERSISTENT."); status = DoUntilSucceed( () => clientAfterFailover.Create( treeIdAfterFailover, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileIdAfterFailover, out serverCreateContexts, RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE, new Smb2CreateContextRequest[] { new Smb2CreateDurableHandleReconnectV2 { FileId = new FILEID { Persistent = fileIdBeforeFailover.Persistent }, CreateGuid = createGuid, Flags = CREATE_DURABLE_HANDLE_RECONNECT_V2_Flags.DHANDLE_FLAG_PERSISTENT }, }, checker: (header, response) => { }), TestConfig.FailoverTimeout, "Retry Create until succeed within timeout span"); #endregion #region READ and WRITE BaseTestSite.Log.Add(LogEntryKind.TestStep, "AfterFailover: Read the contents written before failover."); status = clientAfterFailover.Read( treeIdAfterFailover, fileIdAfterFailover, 0, (uint)contentWrite.Length, out contentRead); BaseTestSite.Log.Add(LogEntryKind.TestStep, "AfterFailover: Verify the contents are the same as the one written before failover."); BaseTestSite.Assert.IsTrue( contentWrite.Equals(contentRead), "Content read after failover should be identical to that written before failover."); BaseTestSite.Log.Add(LogEntryKind.TestStep, "AfterFailover: Write contents to the locking range, it MUST NOT be allowed."); status = clientAfterFailover.Write( treeIdAfterFailover, fileIdAfterFailover, contentWrite, checker: (header, response) => { BaseTestSite.Assert.AreNotEqual( Smb2Status.STATUS_SUCCESS, header.Status, "All opens MUST NOT be allowed to write within the range when SMB2_LOCKFLAG_SHARED_LOCK set"); BaseTestSite.CaptureRequirementIfAreEqual( Smb2Status.STATUS_FILE_LOCK_CONFLICT, header.Status, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description); }); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "From client3: Read and write the locking range when the file is locked, it should fail."); ValidateByteLockRangeFromAnotherClient(true, TestConfig.ClusteredFileServerName, fileName); #region Unlock byte range locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_UNLOCK; BaseTestSite.Log.Add( LogEntryKind.TestStep, "AfterFailover: Client2 attempts to unlock the range"); status = clientAfterFailover.Lock(treeIdAfterFailover, lockSequence++, fileIdAfterFailover, locks); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "From client3: Read and write the locking range from a separate client when the file is unlocked, it should succeed."); ValidateByteLockRangeFromAnotherClient(false, TestConfig.ClusteredFileServerName, fileName); status = clientAfterFailover.Close(treeIdAfterFailover, fileIdAfterFailover); status = clientAfterFailover.TreeDisconnect(treeIdAfterFailover); status = clientAfterFailover.LogOff(); }
/// <summary> /// Establish alternative channel and lock/unlock byte range of a file from same or different channel client /// </summary> /// <param name="lockUnlockOnSameChannel">Set this parameter to true if the unlock operation is taken from the same channel client</param> private void MultipleChannelTestWithLock(bool lockUnlockOnSameChannel) { uint treeId; FILEID fileId; #region Check Applicability TestConfig.CheckDialect(DialectRevision.Smb30); TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "Establish main channel with client {0} and server {1}.", clientIps[0].ToString(), serverIps[0].ToString()); EstablishMainChannel( TestConfig.RequestDialects, serverIps[0], clientIps[0], out treeId); #region CREATE to open file for WRITE and LOCK BaseTestSite.Log.Add( LogEntryKind.TestStep, "Main channel: CREATE file."); Smb2CreateContextResponse[] serverCreateContexts; status = mainChannelClient.Create( treeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId, out serverCreateContexts); #endregion #region WRITE content to file BaseTestSite.Log.Add( LogEntryKind.TestStep, "Main channel: WRITE content to file."); status = mainChannelClient.Write(treeId, fileId, contentWrite); #endregion #region Request byte lock range //Construct LOCK_ELEMENT LOCK_ELEMENT[] locks = new LOCK_ELEMENT[1]; uint lockSequence = 0; locks[0].Offset = 0; locks[0].Length = (ulong)TestConfig.WriteBufferLengthInKb * 1024; locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK; BaseTestSite.Log.Add( LogEntryKind.TestStep, "Main channel client starts to lock a byte range for file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3})", fileName, locks[0].Offset, locks[0].Length, locks[0].Flags.ToString()); status = mainChannelClient.Lock(treeId, lockSequence++, fileId, locks); #endregion #region WRITE content within the locking range BaseTestSite.Log.Add( LogEntryKind.TestStep, "Main channel: attempts to write content within the locking range."); status = mainChannelClient.Write( treeId, fileId, contentWrite, checker: (header, response) => { BaseTestSite.Assert.AreNotEqual( Smb2Status.STATUS_SUCCESS, header.Status, "Write should not success when shared lock is taken"); BaseTestSite.CaptureRequirementIfAreEqual( Smb2Status.STATUS_FILE_LOCK_CONFLICT, header.Status, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description); }); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "Establish alternative channel with client {0} and server {1}.", clientIps[1].ToString(), serverIps[1].ToString()); EstablishAlternativeChannel( TestConfig.RequestDialects, serverIps[1], clientIps[1], treeId); #region READ/WRITE from alternative channel within the locking range Random random = new Random(); uint offset = (uint)random.Next(0, TestConfig.WriteBufferLengthInKb * 1024 - 1); uint length = (uint)random.Next(0, (int)(TestConfig.WriteBufferLengthInKb * 1024 - offset)); BaseTestSite.Log.Add( LogEntryKind.Debug, "Alternative channel: attempts to randomly read the locking range with offset: {0} and length: {1}", offset, length); status = alternativeChannelClient.Read(treeId, fileId, offset, length, out contentRead); BaseTestSite.Log.Add( LogEntryKind.TestStep, "Alternative channel: attempts to write content to the locking range"); status = alternativeChannelClient.Write( treeId, fileId, contentWrite, checker: (header, response) => { BaseTestSite.Assert.AreNotEqual( Smb2Status.STATUS_SUCCESS, header.Status, "All opens MUST NOT be allowed to write within the range when SMB2_LOCKFLAG_SHARED_LOCK set"); BaseTestSite.CaptureRequirementIfAreEqual( Smb2Status.STATUS_FILE_LOCK_CONFLICT, header.Status, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id, RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description); }); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "Read and write the locking range from Client3 when the file is locked"); ValidateByteLockRangeFromAnotherClient(true); locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_UNLOCK; if (lockUnlockOnSameChannel) { BaseTestSite.Log.Add( LogEntryKind.TestStep, "From main channel client unlock the range"); status = mainChannelClient.Lock(treeId, lockSequence++, fileId, locks); } else { BaseTestSite.Log.Add( LogEntryKind.TestStep, "From alternative channel client unlock the range"); status = alternativeChannelClient.Lock(treeId, lockSequence++, fileId, locks); } BaseTestSite.Log.Add( LogEntryKind.TestStep, "Read and write the locking range from Client3 when the file is unlocked"); ValidateByteLockRangeFromAnotherClient(false); ClientTearDown(mainChannelClient, treeId, fileId); }
public void AppInstanceId_Lock_ExpectNoLockInReOpen() { #region Check Applicability TestConfig.CheckDialect(DialectRevision.Smb30); TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES); TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_APP_INSTANCE_ID, CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2); #endregion BaseTestSite.Log.Add( LogEntryKind.TestStep, "InitialOpen: Connect to share via Nic1."); FILEID fileIdForInitialOpen; uint treeIdForInitialOpen; ConnectShare(TestConfig.SutIPAddress, TestConfig.ClientNic1IPAddress, clientForInitialOpen, out treeIdForInitialOpen); #region Create an open with AppInstanceId BaseTestSite.Log.Add(LogEntryKind.TestStep, "InitialOpen: Create an open with AppInstanceId."); Guid appInstanceId = Guid.NewGuid(); Smb2CreateContextResponse[] serverCreateContexts; status = clientForInitialOpen.Create( treeIdForInitialOpen, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileIdForInitialOpen, out serverCreateContexts, RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE, new Smb2CreateContextRequest[] { new Smb2CreateDurableHandleRequestV2 { CreateGuid = Guid.NewGuid(), Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT, }, new Smb2CreateAppInstanceId { AppInstanceId = appInstanceId } }, accessMask: AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE, shareAccess: ShareAccess_Values.NONE); #endregion BaseTestSite.Log.Add(LogEntryKind.TestStep, "InitialOpen: Write contents to file."); status = clientForInitialOpen.Write(treeIdForInitialOpen, fileIdForInitialOpen, contentWrite); #region Request ByteRangeLock BaseTestSite.Log.Add(LogEntryKind.TestStep, "InitialOpen: Request ByteRangeLock."); LOCK_ELEMENT[] locks = new LOCK_ELEMENT[1]; uint lockSequence = 0; locks[0].Offset = 0; locks[0].Length = (ulong)TestConfig.WriteBufferLengthInKb * 1024; locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK; BaseTestSite.Log.Add( LogEntryKind.Debug, "Client starts to lock a byte range for file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3}", fileName, locks[0].Offset, locks[0].Length, locks[0].Flags.ToString()); status = clientForInitialOpen.Lock(treeIdForInitialOpen, lockSequence++, fileIdForInitialOpen, locks); #endregion BaseTestSite.Log.Add(LogEntryKind.TestStep, "ReOpen: Connect to share via Nic2."); FILEID fileIdForReOpen; uint treeIdForReOpen; ConnectShare(TestConfig.SutIPAddress, TestConfig.ClientNic2IPAddress, clientForReOpen, out treeIdForReOpen); #region Create an open with same AppInstanceId BaseTestSite.Log.Add(LogEntryKind.TestStep, "ReOpen: Create an open with same AppInstanceId."); status = clientForReOpen.Create( treeIdForReOpen, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileIdForReOpen, out serverCreateContexts, RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE, new Smb2CreateContextRequest[] { new Smb2CreateDurableHandleRequestV2 { CreateGuid = Guid.NewGuid(), Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT, }, new Smb2CreateAppInstanceId { // Use the same application instance id to force the server close all files // and will clear previous ByteRangeLock AppInstanceId = appInstanceId } }, accessMask: AccessMask.GENERIC_READ); #endregion BaseTestSite.Log.Add(LogEntryKind.TestStep, "ReOpen: Read the contents written by InitialOpen."); status = clientForReOpen.Read(treeIdForReOpen, fileIdForReOpen, 0, (uint)contentWrite.Length, out contentRead); BaseTestSite.Assert.IsTrue( contentRead.Equals(contentWrite), "The written content should equal to read content."); #region AfterFailover: Attempt to access same file with previous byte lock range BaseTestSite.Log.Add( LogEntryKind.TestStep, "ReOpen: Attempt to access same file with previous byte lock range."); ValidateByteLockRangeFromAnotherClient(false); #endregion #region Client tear down BaseTestSite.Log.Add(TestTools.LogEntryKind.TestStep, "ReOpen: Close file."); status = clientForReOpen.Close(treeIdForReOpen, fileIdForReOpen); BaseTestSite.Log.Add(TestTools.LogEntryKind.TestStep, "ReOpen: Disconnect from the share."); status = clientForReOpen.TreeDisconnect(treeIdForReOpen); BaseTestSite.Log.Add(TestTools.LogEntryKind.TestStep, "ReOpen: Log off."); status = clientForReOpen.LogOff(); #endregion }