/// <summary>
/// Create message each one loop In InBox
/// </summary>
/// <param name="logonResponse">the logon response be used to create message</param>
/// <param name="tableHandle">The tableHanlder of the new folder</param>
/// <param name="count">The count of created messages</param>
/// <param name="createMessageRequest">The ROP CreateMessageRequest</param>
/// <param name="saveChangesMessageRequest">The ROP SaveChangesMessageRequest</param>
/// <param name="releaseRequest">The ROP ReleaseRequest</param>
protected void CreateSingleProcessEachLoop(ref RopLogonResponse logonResponse, out uint tableHandle, int count, RopCreateMessageRequest createMessageRequest, RopSaveChangesMessageRequest saveChangesMessageRequest, RopReleaseRequest releaseRequest)
{
RopCreateMessageResponse createMessageResponse = new RopCreateMessageResponse();
RopSaveChangesMessageResponse saveChangesMessageResponse = new RopSaveChangesMessageResponse();
#region Preparing the table: CreateFolder
// Open a folder first
RopOpenFolderRequest openFolderRequest;
RopOpenFolderResponse openFolderResponse;
openFolderRequest.RopId = (byte)RopId.RopOpenFolder;
openFolderRequest.LogonId = TestSuiteBase.LogonId;
openFolderRequest.InputHandleIndex = TestSuiteBase.InputHandleIndex0;
openFolderRequest.OutputHandleIndex = TestSuiteBase.OutputHandleIndex1;
openFolderRequest.FolderId = logonResponse.FolderIds[4];
openFolderRequest.OpenModeFlags = (byte)FolderOpenModeFlags.None;
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2: Begin to send the RopOpenFolder request.");
this.responseSOHs = this.cropsAdapter.ProcessSingleRop(
openFolderRequest,
this.inputObjHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse);
openFolderResponse = (RopOpenFolderResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
openFolderResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
uint openedFolderHandle = this.responseSOHs[0][openFolderResponse.OutputHandleIndex];
// Create a new subfolder in the opened folder
// The new subfolder will be used as target folder
RopCreateFolderRequest createFolderRequest;
RopCreateFolderResponse createFolderResponse;
createFolderRequest.RopId = (byte)RopId.RopCreateFolder;
createFolderRequest.LogonId = TestSuiteBase.LogonId;
createFolderRequest.InputHandleIndex = TestSuiteBase.InputHandleIndex0;
createFolderRequest.OutputHandleIndex = TestSuiteBase.OutputHandleIndex1;
createFolderRequest.FolderType = (byte)FolderType.Genericfolder;
createFolderRequest.UseUnicodeStrings = Convert.ToByte(TestSuiteBase.Zero);
createFolderRequest.OpenExisting = TestSuiteBase.NonZero;
createFolderRequest.Reserved = TestSuiteBase.Reserved;
createFolderRequest.DisplayName = Encoding.ASCII.GetBytes(TestSuiteBase.DisplayNameAndCommentForNonSearchFolder + "\0");
createFolderRequest.Comment = Encoding.ASCII.GetBytes(TestSuiteBase.DisplayNameAndCommentForNonSearchFolder + "\0");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2: Begin to send the RopCreateFolder request.");
this.responseSOHs = this.cropsAdapter.ProcessSingleRop(
createFolderRequest,
openedFolderHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse);
createFolderResponse = (RopCreateFolderResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
createFolderResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
uint targetFolderHandle = this.responseSOHs[0][openFolderResponse.OutputHandleIndex];
tableHandle = this.GetContentsTableHandle(targetFolderHandle);
ulong folderId = createFolderResponse.FolderId;
#endregion
#region Preparing the table: RopCreateAndSaveMessages
int waitTime = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
int maxRetryCount = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
int retryCount;
uint returnValue = 0;
for (int i = 1; i < count; i++)
{
// If the RPC report error code reported by the following three ROP methods is 1726 (The remote procedure call failed),
// re-do the common steps of this case.
if (returnValue == 1726)
{
#region The common steps
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "If RPC error code is 1726, re-connect to server.");
this.cropsAdapter.RpcConnect(
Common.GetConfigurationPropertyValue("SutComputerName", this.Site),
ConnectionType.PrivateMailboxServer,
Common.GetConfigurationPropertyValue("UserEssdn", this.Site),
Common.GetConfigurationPropertyValue("Domain", this.Site),
Common.GetConfigurationPropertyValue("AdminUserName", this.Site),
Common.GetConfigurationPropertyValue("PassWord", this.Site));
logonResponse = this.Logon(LogonType.Mailbox, this.userDN, out this.inputObjHandle);
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopOpenFolder request.");
this.responseSOHs = this.cropsAdapter.ProcessSingleRop(
openFolderRequest,
this.inputObjHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse);
openFolderResponse = (RopOpenFolderResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
openFolderResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
openedFolderHandle = this.responseSOHs[0][openFolderResponse.OutputHandleIndex];
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopCreateFolder request.");
this.responseSOHs = this.cropsAdapter.ProcessSingleRop(
createFolderRequest,
openedFolderHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse);
createFolderResponse = (RopCreateFolderResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
createFolderResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
targetFolderHandle = this.responseSOHs[0][openFolderResponse.OutputHandleIndex];
tableHandle = this.GetContentsTableHandle(targetFolderHandle);
folderId = createFolderResponse.FolderId;
#endregion
}
#region Create message
createMessageRequest.FolderId = folderId;
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopCreateMessage request:loop counter i={0}", i);
retryCount = maxRetryCount;
do
{
// Send the RopCreateMessage to create message.
this.responseSOHs = this.cropsAdapter.ProcessSingleRopWithReturnValue(
createMessageRequest,
this.inputObjHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse,
out returnValue);
System.Threading.Thread.Sleep(waitTime);
retryCount--;
}
while (this.response is RopBackoffResponse && retryCount >= 0);
Site.Assert.IsTrue(retryCount >= 0, "The case {0} failed since server is busy and always returns RopBackoff in the response, reduce your server load and try again.", this.TestContext.TestName);
// If the error code is 1726, continue this loop.
if (returnValue == 1726)
{
continue;
}
createMessageResponse = (RopCreateMessageResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
createMessageResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
uint targetMessageHandle = this.responseSOHs[0][createMessageResponse.OutputHandleIndex];
#endregion
#region Save message
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopSaveChangesMessage request:loop counter i={0}", i);
retryCount = maxRetryCount;
// Do the loop when response is RopBackoffResponse or saveChangesMessageResponse is 0x80040401 (ecTimeout).
do
{
// Send the RopSaveChangesMessage request to save the created message.
this.responseSOHs = this.cropsAdapter.ProcessSingleRopWithReturnValue(
saveChangesMessageRequest,
targetMessageHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse,
out returnValue);
if (this.response is RopSaveChangesMessageResponse)
{
saveChangesMessageResponse = (RopSaveChangesMessageResponse)this.response;
}
System.Threading.Thread.Sleep(waitTime);
retryCount--;
}
while ((this.response is RopBackoffResponse || saveChangesMessageResponse.ReturnValue == 0x80040401) && retryCount >= 0);
Site.Assert.IsTrue(retryCount >= 0, "The case {0} failed since server is busy and always returns RopBackoff in the response, reduce your server load and try again.", this.TestContext.TestName);
// If the error code is 1726, continue this loop.
if (returnValue == 1726)
{
continue;
}
saveChangesMessageResponse = (RopSaveChangesMessageResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
saveChangesMessageResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
#endregion
#region Release all resources
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopRelease request.");
retryCount = maxRetryCount;
do
{
this.responseSOHs = this.cropsAdapter.ProcessSingleRopWithReturnValue(
releaseRequest,
targetMessageHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse,
out returnValue);
System.Threading.Thread.Sleep(waitTime);
retryCount--;
}
while (this.response is RopBackoffResponse && retryCount >= 0);
Site.Assert.IsTrue(retryCount >= 0, "The case {0} failed since server is busy and always returns RopBackoff in the response, reduce your server load and try again.", this.TestContext.TestName);
// If the error code is 1726, continue this loop.
if (returnValue == 1726)
{
continue;
}
#endregion
}
// If the error code 1726 occurs on the last time of the above "for" loop, re-do the common steps.
if (returnValue == 1726)
{
#region The common steps
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "If RPC error code is 1726, re-connect to server.");
this.cropsAdapter.RpcConnect(
Common.GetConfigurationPropertyValue("SutComputerName", this.Site),
ConnectionType.PrivateMailboxServer,
Common.GetConfigurationPropertyValue("UserEssdn", this.Site),
Common.GetConfigurationPropertyValue("Domain", this.Site),
Common.GetConfigurationPropertyValue("AdminUserName", this.Site),
Common.GetConfigurationPropertyValue("PassWord", this.Site));
logonResponse = this.Logon(LogonType.Mailbox, this.userDN, out this.inputObjHandle);
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopOpenFolder request.");
this.responseSOHs = this.cropsAdapter.ProcessSingleRop(
openFolderRequest,
this.inputObjHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse);
openFolderResponse = (RopOpenFolderResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
openFolderResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
openedFolderHandle = this.responseSOHs[0][openFolderResponse.OutputHandleIndex];
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Step 2:Begin to send the RopCreateFolder request.");
this.responseSOHs = this.cropsAdapter.ProcessSingleRop(
createFolderRequest,
openedFolderHandle,
ref this.response,
ref this.rawData,
RopResponseType.SuccessResponse);
createFolderResponse = (RopCreateFolderResponse)this.response;
Site.Assert.AreEqual<uint>(
TestSuiteBase.SuccessReturnValue,
createFolderResponse.ReturnValue,
"if ROP succeeds, the ReturnValue of its response is 0(success)");
targetFolderHandle = this.responseSOHs[0][openFolderResponse.OutputHandleIndex];
tableHandle = this.GetContentsTableHandle(targetFolderHandle);
folderId = createFolderResponse.FolderId;
#endregion
}
#endregion
}
/// <summary>
/// Create and save message.
/// </summary>
/// <param name="folderHandle">Folder Handle </param>
/// <param name="folderId">Folder Id which messages will be create in.</param>
/// <param name="associatedFlag">Specifies whether the message is a Folder Associated Information message.</param>
/// <param name="messageId"> Message Id which will be returned by server.</param>
/// <param name="messageHandle">Message Handle which will be returned by server.</param>
protected void CreateSaveMessage(uint folderHandle, ulong folderId, byte associatedFlag, ref ulong messageId, ref uint messageHandle)
{
// Create a Message.
RopCreateMessageRequest createMessageRequest = new RopCreateMessageRequest();
RopCreateMessageResponse createMessageResponse = new RopCreateMessageResponse();
object ropResponse = null;
createMessageRequest.RopId = (byte)RopId.RopCreateMessage;
createMessageRequest.LogonId = Constants.CommonLogonId;
createMessageRequest.InputHandleIndex = Constants.CommonInputHandleIndex;
createMessageRequest.OutputHandleIndex = Constants.CommonOutputHandleIndex;
createMessageRequest.CodePageId = 0x0FFF;
createMessageRequest.FolderId = folderId;
createMessageRequest.AssociatedFlag = associatedFlag;
this.Adapter.DoRopCall(createMessageRequest, folderHandle, ref ropResponse, ref this.responseHandles);
createMessageResponse = (RopCreateMessageResponse)ropResponse;
Site.Assert.AreEqual<uint>(0, createMessageResponse.ReturnValue, "Creating Message should succeed");
messageHandle = this.responseHandles[0][createMessageResponse.OutputHandleIndex];
// Save a Message.
RopSaveChangesMessageRequest saveChangesMessageRequest = new RopSaveChangesMessageRequest();
RopSaveChangesMessageResponse saveChangesMessageResponse = new RopSaveChangesMessageResponse();
saveChangesMessageRequest.RopId = (byte)RopId.RopSaveChangesMessage;
saveChangesMessageRequest.LogonId = Constants.CommonLogonId;
saveChangesMessageRequest.InputHandleIndex = Constants.CommonInputHandleIndex;
saveChangesMessageRequest.ResponseHandleIndex = 0x01;
saveChangesMessageRequest.SaveFlags = 0x0C;
this.Adapter.DoRopCall(saveChangesMessageRequest, messageHandle, ref ropResponse, ref this.responseHandles);
saveChangesMessageResponse = (RopSaveChangesMessageResponse)ropResponse;
Site.Assert.AreEqual<uint>(
0,
createMessageResponse.ReturnValue,
"Save Messages Success.");
messageId = saveChangesMessageResponse.MessageId;
}
/// <summary>
/// This ROP creates a Message object in a mailbox.
/// </summary>
/// <param name="handle">The handle to operate.</param>
/// <param name="folderId">This value identifies the parent folder.</param>
/// <param name="associatedFlag">This flag specifies whether the message is a folder associated information (FAI) message.</param>
/// <param name="createMessageResponse">The response of this ROP.</param>
/// <param name="needVerify">Whether need to verify the response</param>
/// <returns>The handle of the created message.</returns>
private uint RopCreateMessage(uint handle, ulong folderId, byte associatedFlag, out RopCreateMessageResponse createMessageResponse, bool needVerify)
{
this.rawDataValue = null;
this.responseValue = null;
this.responseSOHsValue = null;
RopCreateMessageRequest createMessageRequest = new RopCreateMessageRequest()
{
RopId = (byte)RopId.RopCreateMessage,
LogonId = LogonId,
InputHandleIndex = (byte)HandleIndex.FirstIndex,
OutputHandleIndex = (byte)HandleIndex.SecondIndex,
CodePageId = (ushort)CodePageId.SameAsLogonObject,
FolderId = folderId,
AssociatedFlag = associatedFlag
};
this.responseSOHsValue = this.ProcessSingleRop(createMessageRequest, handle, ref this.responseValue, ref this.rawDataValue, RopResponseType.SuccessResponse);
createMessageResponse = (RopCreateMessageResponse)this.responseValue;
if (needVerify)
{
this.Site.Assert.AreEqual((uint)RopResponseType.SuccessResponse, createMessageResponse.ReturnValue, string.Format("RopCreateMessageResponse Failed! Error: 0x{0:X8}", createMessageResponse.ReturnValue));
}
return this.responseSOHsValue[0][createMessageResponse.OutputHandleIndex];
}
/// <summary>
/// Create a message and return the message handle created.
/// </summary>
/// <param name="serverId">A 32-bit signed integer represent the Identity of server.</param>
/// <param name="folderHandleIndex">The folder handle index for creating message.</param>
/// <param name="folderIdIndex">The folder Id index.</param>
/// <param name="associatedFlag">The message is FAI or not.</param>
/// <param name="messageHandleIndex">The created message handle index.</param>
/// <returns>Indicate the result of this ROP operation.</returns>
public RopResult CreateMessage(int serverId, int folderHandleIndex, int folderIdIndex, bool associatedFlag, out int messageHandleIndex)
{
// Initialize operation values.
RopCreateMessageRequest createMessageRequest = new RopCreateMessageRequest();
RopCreateMessageResponse createMessageResponse = new RopCreateMessageResponse();
messageHandleIndex = -1;
uint folderHandle = this.handleContainer[folderHandleIndex];
ulong folderId = this.objectIdContainer[folderIdIndex];
RopResult result = RopResult.InvalidParameter;
// Construct the RopCreateMessage request.
createMessageRequest.RopId = 0x06;
createMessageRequest.LogonId = 0x00;
createMessageRequest.InputHandleIndex = 0x00;
createMessageRequest.OutputHandleIndex = 0x01;
// Set CodePageId to 0x0FFF, which specified the code page of Logon object will be used
createMessageRequest.CodePageId = 0x0FFF;
createMessageRequest.FolderId = folderId;
// If the message is a FAImessage.
createMessageRequest.AssociatedFlag = associatedFlag ? (byte)0x01 : (byte)0x00;
// Send request and get ROP response.
createMessageResponse = (RopCreateMessageResponse)this.Process(serverId, createMessageRequest, folderHandle);
result = (RopResult)createMessageResponse.ReturnValue;
if (result == RopResult.Success)
{
messageHandleIndex = AdapterHelper.GetHandleIndex();
this.handleContainer.Add(messageHandleIndex, this.responseSOHs[createMessageResponse.OutputHandleIndex]);
this.AddRecipient(serverId, this.responseSOHs[createMessageResponse.OutputHandleIndex]);
// Verify server Accept PidTagIdsetGivenPtypBinary
this.VerifyServerAcceptPidTagIdsetGivenPtypBinary(serverId, folderHandleIndex);
}
return result;
}
/// <summary>
/// Verify RopCreateMessage Failure Response
/// </summary>
/// <param name="ropCreateMessageResponse">The response of RopCreateMessage request</param>
/// <param name="outputHandleIndex">The field of OutputHandleIndex in RopCreateMessage request</param>
private void VerifyRopCreateMessageFailureResponse(RopCreateMessageResponse ropCreateMessageResponse, byte outputHandleIndex)
{
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1781");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1781
Site.CaptureRequirementIfAreEqual<Type>(
typeof(byte),
ropCreateMessageResponse.RopId.GetType(),
1781,
@"[In RopCreateMessage ROP Failure Response Buffer]RopId (1 byte): An unsigned integer.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1783");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1783
Site.CaptureRequirementIfAreEqual<byte>(
(byte)RopId.RopCreateMessage,
ropCreateMessageResponse.RopId,
1783,
@"[In RopCreateMessage ROP Failure Response Buffer,RopId (1 byte)] For this[RopCreateMessage] operation, this field is set to 0x06.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1784");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1784
Site.CaptureRequirementIfAreEqual<Type>(
typeof(byte),
ropCreateMessageResponse.OutputHandleIndex.GetType(),
1784,
@"[In RopCreateMessage ROP Failure Response Buffer]OutputHandleIndex (1 byte): An unsigned integer.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1785");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1785
Site.CaptureRequirementIfAreEqual<byte>(
outputHandleIndex,
ropCreateMessageResponse.OutputHandleIndex,
1785,
@"[In RopCreateMessage ROP Failure Response Buffer,OutputHandleIndex (1 byte)]This index MUST be set to the value specified in the OutputHandleIndex field in the request.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1787");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1787
Site.CaptureRequirementIfAreEqual<Type>(
typeof(uint),
ropCreateMessageResponse.ReturnValue.GetType(),
1787,
@"[In RopCreateMessage ROP Failure Response Buffer]ReturnValue (4 bytes): An unsigned integer.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1789");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1789
Site.CaptureRequirementIfAreNotEqual<uint>(
SuccessReturnValue,
ropCreateMessageResponse.ReturnValue,
1789,
@"[In RopCreateMessage ROP Failure Response Buffer,ReturnValue (4 bytes)]For this[Failure Response] response, this field is set to a value other than 0x00000000.");
}
/// <summary>
/// Verify RopCreateMessage Success Response
/// </summary>
/// <param name="ropCreateMessageResponse">The response of RopCreateMessage request</param>
/// <param name="outputHandleIndex">The field of OutputHandleIndex in RopCreateMessage request</param>
private void VerifyRopCreateMessageSuccessResponse(RopCreateMessageResponse ropCreateMessageResponse, byte outputHandleIndex)
{
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1764");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1764
Site.CaptureRequirementIfAreEqual<Type>(
typeof(byte),
ropCreateMessageResponse.RopId.GetType(),
1764,
@"[In RopCreateMessage ROP Success Response Buffer]RopId (1 byte): An unsigned integer.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1766");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1766
Site.CaptureRequirementIfAreEqual<byte>(
(byte)RopId.RopCreateMessage,
ropCreateMessageResponse.RopId,
1766,
@"[In RopCreateMessage ROP Success Response Buffer,RopId (1 byte)]For this[RopCreateMessage] operation, this field is set to 0x06.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1767");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1767
Site.CaptureRequirementIfAreEqual<Type>(
typeof(byte),
ropCreateMessageResponse.OutputHandleIndex.GetType(),
1767,
@"[In RopCreateMessage ROP Success Response Buffer]OutputHandleIndex (1 byte): An unsigned integer.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1768");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1768
Site.CaptureRequirementIfAreEqual<byte>(
outputHandleIndex,
ropCreateMessageResponse.OutputHandleIndex,
1768,
@"[In RopCreateMessage ROP Success Response Buffer,OutputHandleIndex (1 byte)]This index MUST be set to the value specified in the OutputHandleIndex specified in field the request.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1770");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1770
Site.CaptureRequirementIfAreEqual<Type>(
typeof(uint),
ropCreateMessageResponse.ReturnValue.GetType(),
1770,
@"[In RopCreateMessage ROP Success Response Buffer]ReturnValue (4 bytes): An unsigned integer.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1772");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1772
Site.CaptureRequirementIfAreEqual<uint>(
SuccessReturnValue,
ropCreateMessageResponse.ReturnValue,
1772,
@"[In RopCreateMessage ROP Success Response Buffer,ReturnValue (4 bytes)]For this[Success Response] response, this field is set to 0x00000000.");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1773,HasMessageId:{0}", ropCreateMessageResponse.HasMessageId);
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1773
// If HasMessageId is byte type and can be boolean type representation, then verify R1773
bool isVerifyR1773 = (typeof(byte) == ropCreateMessageResponse.HasMessageId.GetType()) &&
((Convert.ToBoolean(ropCreateMessageResponse.HasMessageId) == true) ||
(Convert.ToBoolean(ropCreateMessageResponse.HasMessageId) == false));
Site.CaptureRequirementIfIsTrue(
isVerifyR1773,
1773,
@"[In RopCreateMessage ROP Success Response Buffer]HasMessageId (1 byte): A Boolean.");
if (ropCreateMessageResponse.HasMessageId != 0)
{
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXCROPS_R1775");
// Verify MS-OXCROPS requirement: MS-OXCROPS_R1775
Site.CaptureRequirementIfAreEqual<int>(
8,
Marshal.SizeOf(ropCreateMessageResponse.MessageId),
1775,
@"[In RopCreateMessage ROP Success Response Buffer]MessageId (8 bytes): An identifier.");
}
}
/// <summary>
/// Get Created Message Handle
/// </summary>
/// <param name="folderId">The folder Id be used to create message</param>
/// <param name="logonHandle">The RopLogon object handle</param>
/// <param name="createMessageResponse">The response of calling RopCreateMessage</param>
/// <returns>Return created Message Handle</returns>
protected uint CreatedMessage(ulong folderId, uint logonHandle, out RopCreateMessageResponse createMessageResponse)
{
// Create a message object first
RopCreateMessageRequest createMessageRequest = new RopCreateMessageRequest
{
RopId = (byte)RopId.RopCreateMessage,
LogonId = CommonLogonId,
InputHandleIndex = CommonInputHandleIndex,
OutputHandleIndex = CommonOutputHandleIndex,
CodePageId = 0x0FFF,
FolderId = folderId,
AssociatedFlag = 0x00
};
this.ResponseSOHs = this.MSOXCMSGAdapter.DoRopCall(createMessageRequest, logonHandle, ref this.response, ref this.rawData, GetPropertiesFlags.None);
createMessageResponse = (RopCreateMessageResponse)this.response;
Site.Assert.AreEqual<uint>(TestSuiteBase.Success, createMessageResponse.ReturnValue, "Call RopCreateMessage should success.");
// Get handle of message object, it will be used as input handle in next ROP
uint messageHandle = this.ResponseSOHs[0][createMessageResponse.OutputHandleIndex];
return messageHandle;
}
/// <summary>
/// Create Reply Template use settings in Util.cs file.
/// It will be used by create Rule of ActioType: OP_REPLY
/// </summary>
/// <param name="inboxFolderHandle">The inbox folder's handle.</param>
/// <param name="inboxFolderID">The inbox folder's ID.</param>
/// <param name="isOOFReplyTemplate">Indicate whether the template to be created is a template for OP_REPLY or OP_OOF_REPLY .</param>
/// <param name="templateSubject">The name of the template.</param>
/// <param name="addedProperties">The properties that need to add to the reply template.</param>
/// <param name="messageId">Message id of reply template message.</param>
/// <param name="messageHandler">The reply message Handler.</param>
/// <returns>Return the value of ReplyTemplateGUID.</returns>
public byte[] CreateReplyTemplate(uint inboxFolderHandle, ulong inboxFolderID, bool isOOFReplyTemplate, string templateSubject, TaggedPropertyValue[] addedProperties, out ulong messageId, out uint messageHandler)
{
// Create a new FAI message in the inbox folder
RopCreateMessageResponse ropCreateMessageResponse = new RopCreateMessageResponse();
messageHandler = this.RopCreateMessage(inboxFolderHandle, inboxFolderID, Convert.ToByte(true), out ropCreateMessageResponse);
#region Set the new created message's properties
TaggedPropertyValue[] replyTemplateProperties = new TaggedPropertyValue[3];
// PidTagMessageClass
replyTemplateProperties[0] = new TaggedPropertyValue();
PropertyTag replyTemplatePropertiesPropertyTag = new PropertyTag
{
PropertyType = (ushort)PropertyType.PtypString,
PropertyId = (ushort)PropertyId.PidTagMessageClass
};
replyTemplateProperties[0].PropertyTag = replyTemplatePropertiesPropertyTag;
if (isOOFReplyTemplate == true)
{
replyTemplateProperties[0].Value = Encoding.Unicode.GetBytes(Constants.OOFReplyTemplate + "\0");
}
else
{
replyTemplateProperties[0].Value = Encoding.Unicode.GetBytes(Constants.ReplyTemplate + "\0");
}
// PidTagReplyTemplateId
replyTemplateProperties[1] = new TaggedPropertyValue();
PropertyTag pidTagReplyTemplateIdPropertyTag = new PropertyTag
{
PropertyId = (ushort)PropertyId.PidTagReplyTemplateId,
PropertyType = (ushort)PropertyType.PtypBinary
};
replyTemplateProperties[1].PropertyTag = pidTagReplyTemplateIdPropertyTag;
Guid newGuid = System.Guid.NewGuid();
replyTemplateProperties[1].Value = Common.AddInt16LengthBeforeBinaryArray(newGuid.ToByteArray());
// PidTagSubject
replyTemplateProperties[2] = new TaggedPropertyValue();
PropertyTag pidTagSubjectPropertyTag = new PropertyTag
{
PropertyId = (ushort)PropertyId.PidTagSubject,
PropertyType = (ushort)PropertyType.PtypString
};
replyTemplateProperties[2].PropertyTag = pidTagSubjectPropertyTag;
replyTemplateProperties[2].Value = Encoding.Unicode.GetBytes(templateSubject + "\0");
this.RopSetProperties(messageHandler, replyTemplateProperties);
this.RopSetProperties(messageHandler, addedProperties);
#endregion
// Save changes of the message
RopSaveChangesMessageResponse ropSaveChangesMessagResponse = this.RopSaveChangesMessage(messageHandler);
messageId = ropSaveChangesMessagResponse.MessageId;
return newGuid.ToByteArray();
}
/// <summary>
/// This ROP creates a Message object in a mailbox.
/// </summary>
/// <param name="handle">Handle to operate.</param>
/// <param name="folderId">This value identifies the parent folder.</param>
/// <param name="isFAIMessage">8-bit Boolean. This value specifies whether the message is a folder associated information (FAI) message.</param>
/// <param name="createMessageResponse">Response of this ROP.</param>
/// <returns>Handle of the create message.</returns>
public uint RopCreateMessage(uint handle, ulong folderId, byte isFAIMessage, out RopCreateMessageResponse createMessageResponse)
{
this.rawData = null;
this.response = null;
this.responseSOHs = null;
RopCreateMessageRequest req;
req.RopId = 0x06;
req.LogonId = 0;
req.InputHandleIndex = 0;
req.OutputHandleIndex = 1;
req.CodePageId = 0x0fff;
req.FolderId = folderId;
req.AssociatedFlag = isFAIMessage;
this.responseSOHs = this.DoRPCCall(req, handle, ref this.response, ref this.rawData);
createMessageResponse = (RopCreateMessageResponse)this.response;
return this.responseSOHs[0][createMessageResponse.OutputHandleIndex];
}