public void MaximumIsGreaterThanAnyDateTime()
{
var t1 = new MessageTimestamp(new DateTime(3423, DateTimeKind.Local));
Assert.IsTrue(MessageTimestamp.Compare(t1, MessageTimestamp.MaxValue) < 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MaxValue, t1) > 0);
var t2 = new MessageTimestamp(new DateTime(3423, DateTimeKind.Utc));
Assert.IsTrue(MessageTimestamp.Compare(t2, MessageTimestamp.MaxValue) < 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MaxValue, t2) > 0);
var t3 = new MessageTimestamp(new DateTime(3423, DateTimeKind.Unspecified));
Assert.IsTrue(MessageTimestamp.Compare(t3, MessageTimestamp.MaxValue) < 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MaxValue, t3) > 0);
var t4 = new MessageTimestamp(new DateTime(1, DateTimeKind.Local));
Assert.IsTrue(MessageTimestamp.Compare(t4, MessageTimestamp.MaxValue) < 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MaxValue, t4) > 0);
var t5 = new MessageTimestamp(new DateTime(1, DateTimeKind.Utc));
Assert.IsTrue(MessageTimestamp.Compare(t5, MessageTimestamp.MaxValue) < 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MaxValue, t5) > 0);
}
private static void AssertResponseMessage(MessageId messageId, MessageTimestamp messageTimestamp, int amount, Guid purchaseId, string externalTransactionId, PaymentResponseMessage <StandardPaymentResponseTxn> message)
{
Assert.AreEqual(messageId, message.MessageInfo.MessageId);
Assert.AreEqual(messageTimestamp, message.MessageInfo.MessageTimestamp);
Assert.AreEqual(ApiVersion, message.MessageInfo.ApiVersion);
Assert.AreEqual(MerchantId, message.MerchantInfo.MerchantId);
Assert.AreEqual(RequestType.Payment, message.RequestType);
Assert.AreEqual(int.Parse(StatusCode), message.Status.StatusCode);
Assert.AreEqual(StatusDescription, message.Status.StatusDescription);
Assert.AreEqual(amount, message.Payment.TxnList.Txn.Amount);
Assert.AreEqual(Currency.AUD, message.Payment.TxnList.Txn.Currency);
Assert.AreEqual(purchaseId, message.Payment.TxnList.Txn.PurchaseId);
Assert.AreEqual(true, message.Payment.TxnList.Txn.IsApproved);
Assert.AreEqual(ResponseCode, message.Payment.TxnList.Txn.ResponseCode);
Assert.AreEqual(ResponseText, message.Payment.TxnList.Txn.ResponseText);
Assert.AreEqual(SettlementDate, message.Payment.TxnList.Txn.SettlementDate);
Assert.AreEqual(externalTransactionId, message.Payment.TxnList.Txn.ExternalTransactionId);
Assert.AreEqual(Pan, message.Payment.TxnList.Txn.CreditCardInfo.Pan);
Assert.AreEqual(ExpiryDate, message.Payment.TxnList.Txn.CreditCardInfo.ExpiryDate);
Assert.AreEqual(CreditCardType.Visa, message.Payment.TxnList.Txn.CreditCardInfo.CardType);
Assert.AreEqual(CreditCardType.Visa.ToString(), message.Payment.TxnList.Txn.CreditCardInfo.CardDescription);
}
public void MinimumIsLessThanAnyDateTime()
{
Func <long, long> localTicksToUtcTicks = ticks => new DateTime(ticks, DateTimeKind.Local).ToUniversalTime().Ticks;
var t1 = new MessageTimestamp(new DateTime(3423, DateTimeKind.Local));
Assert.IsTrue(MessageTimestamp.Compare(t1, MessageTimestamp.MinValue) > 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MinValue, t1) < 0);
var t2 = new MessageTimestamp(new DateTime(localTicksToUtcTicks(3423), DateTimeKind.Utc));
Assert.IsTrue(MessageTimestamp.Compare(t2, MessageTimestamp.MinValue) > 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MinValue, t2) < 0);
var t3 = new MessageTimestamp(new DateTime(3423, DateTimeKind.Unspecified));
Assert.IsTrue(MessageTimestamp.Compare(t3, MessageTimestamp.MinValue) > 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MinValue, t3) < 0);
var t4 = new MessageTimestamp(new DateTime(1, DateTimeKind.Local));
Assert.IsTrue(MessageTimestamp.Compare(t4, MessageTimestamp.MinValue) > 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MinValue, t4) < 0);
var t5 = new MessageTimestamp(new DateTime(localTicksToUtcTicks(1), DateTimeKind.Utc));
Assert.IsTrue(MessageTimestamp.Compare(t5, MessageTimestamp.MinValue) > 0);
Assert.IsTrue(MessageTimestamp.Compare(MessageTimestamp.MinValue, t5) < 0);
}
public FrameBegin(long position, long endPosition, IThread t, MessageTimestamp time, StringSlice name, StringSlice rawText = new StringSlice())
:
base(position, endPosition, t, time, rawText)
{
this.name = name;
this.flags = MessageFlag.StartFrame;
}
public Content(long position, long endPosition, IThread t, MessageTimestamp time, StringSlice msg, SeverityFlag s, StringSlice rawText = new StringSlice())
:
base(position, endPosition, t, time, rawText)
{
this.message = msg;
this.flags = MessageFlag.Content | (MessageFlag)s;
}
private static void AssertResponseMessage(MessageId messageId, MessageTimestamp messageTimestamp, ResponseMessage message)
{
Assert.AreEqual(messageId, message.MessageInfo.MessageId);
Assert.AreEqual(messageTimestamp, message.MessageInfo.MessageTimestamp);
Assert.AreEqual(ApiVersion, message.MessageInfo.ApiVersion);
Assert.AreEqual(MerchantId, message.MerchantInfo.MerchantId);
Assert.AreEqual(RequestType.Echo, message.RequestType);
}
void Reset()
{
content.Length = 0;
attribName = null;
thread = null;
dateTime = new MessageTimestamp();
severity = SeverityFlag.Info;
}
public void TestParseMessageTimestamp()
{
var now = DateTime.Now;
var messageTimestamp1 = new MessageTimestamp(new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond));
var messageTimestamp2 = MessageTimestamp.Parse(messageTimestamp1.ToString());
Assert.AreEqual(messageTimestamp2, messageTimestamp1);
}
public virtual IEnumerator <ITask> SetTimerHandler(SetTimer setTimer)
{
MessageTimestamp timeStamp = setTimer.GetHeader <MessageTimestamp>();
DateTime start;
if (timeStamp == null)
{
start = DateTime.Now;
}
else
{
start = timeStamp.Value;
}
StringBuilder log = new StringBuilder();
if (_state.Timeout > 0 && _state.Expires > DateTime.Now)
{
log.AppendFormat(
CultureInfo.InvariantCulture,
"Override previous timer of {0}ms, expected at {1}.",
_state.Timeout,
_state.Expires
);
#if URT_MINCLR
log.Append("\n");
#else
log.AppendLine();
#endif
}
if (setTimer.Body.Interval > 0)
{
_state.Timeout = setTimer.Body.Interval;
_state.Expires = start.AddMilliseconds(_state.Timeout);
log.AppendFormat(
CultureInfo.InvariantCulture,
"Set new timer of {0}ms, expected at {1}.",
_state.Timeout,
_state.Expires
);
}
else
{
_state.Timeout = 0;
_state.Expires = DateTime.MaxValue;
log.Append("Timer stopped");
}
LogVerbose(log.ToString());
setTimer.ResponsePort.Post(DefaultUpdateResponseType.Instance);
SendNotification(_subMgr, setTimer);
yield break;
}
public void TestCloneResponseMessage()
{
// Deserialize.
var messageId = MessageId.NewMessageId();
var messageTimestamp = new MessageTimestamp(DateTime.Now);
var serializedMessage = string.Format(ResponseMessageFormat, messageId, messageTimestamp);
var message = (ResponseMessage)Serialization.Deserialize(serializedMessage).Clone();
// Check.
AssertResponseMessage(messageId, messageTimestamp, message);
}
public void TimeZoneTest()
{
var m1 = new MessageTimestamp(new DateTime(123213213, DateTimeKind.Local));
Assert.AreEqual(MessageTimestampTimezone.Unknown, m1.TimeZone);
var m2 = new MessageTimestamp(new DateTime(123213213, DateTimeKind.Unspecified));
Assert.AreEqual(MessageTimestampTimezone.Unknown, m2.TimeZone);
var m3 = new MessageTimestamp(new DateTime(123213213, DateTimeKind.Utc));
Assert.AreEqual(MessageTimestampTimezone.UTC, m3.TimeZone);
}
public int CompareTo(TextLogEventTrigger t)
{
int x;
if ((x = Math.Sign(this.StreamPosition - t.StreamPosition)) != 0)
{
return(x);
}
if ((x = MessageTimestamp.Compare(this.Timestamp, t.Timestamp)) != 0)
{
return(x);
}
return(0);
}
public void Verify(int actualLine, IMessage actualMessage, int actualFrameLevel)
{
ExpectedMessage expectedMessage;
if (expectedMessages.TryGetValue(actualLine, out expectedMessage))
{
expectedMessage.Verified = true;
Assert.IsNotNull(actualMessage);
if (expectedMessage.Date != null)
{
Assert.IsTrue(MessageTimestamp.EqualStrict(expectedMessage.Date.Value, actualMessage.Time),
string.Format("Expected message timestamp: {0}, actual: {1}", expectedMessage.Date.Value, actualMessage.Time));
}
else if (expectedMessage.DateVerifier != null)
{
Assert.IsTrue(expectedMessage.DateVerifier(actualMessage.Time));
}
if (expectedMessage.Thread != null)
{
Assert.AreEqual(expectedMessage.Thread, actualMessage.Thread.ID);
}
if (expectedMessage.Type != null)
{
Assert.AreEqual(expectedMessage.Type.Value, actualMessage.Flags & MessageFlag.TypeMask);
}
if (expectedMessage.ContentType != null)
{
Assert.AreEqual(expectedMessage.ContentType.Value, actualMessage.Flags & MessageFlag.ContentTypeMask);
}
if (expectedMessage.Text != null)
{
if (expectedMessage.TextNeedsNormalization)
{
Assert.AreEqual(StringUtils.NormalizeLinebreakes(expectedMessage.Text), StringUtils.NormalizeLinebreakes(actualMessage.Text.Value));
}
else
{
Assert.AreEqual(expectedMessage.Text, actualMessage.Text.Value);
}
}
else if (expectedMessage.TextVerifier != null)
{
Assert.IsTrue(expectedMessage.TextVerifier(actualMessage.Text.Value));
}
if (expectedMessage.FrameLevel != null)
{
Assert.AreEqual(expectedMessage.FrameLevel.Value, actualFrameLevel);
}
}
}
public void TestDeserializeResponseMessageWithThinlink()
{
// Deserialize.
var messageId = MessageId.NewMessageId();
var messageTimestamp = new MessageTimestamp(DateTime.Now);
const int amount = 10;
var purchaseId = Guid.NewGuid();
var externalTransactionId = Guid.NewGuid().ToString();
var serializedMessage = string.Format(ResponseMessageFormat, messageId, messageTimestamp, amount, purchaseId, externalTransactionId, Thinlink);
var message = Serialization.Deserialize <StandardPaymentResponseTxn>(serializedMessage);
// Check.
AssertResponseMessage(messageId, messageTimestamp, amount, purchaseId, externalTransactionId, message);
}
public void TestCloneResponseMessage()
{
// Deserialize.
var messageId = MessageId.NewMessageId();
var messageTimestamp = new MessageTimestamp(DateTime.Now);
const int amount = 10;
var purchaseId = Guid.NewGuid();
var externalTransactionId = Guid.NewGuid().ToString();
var serializedMessage = string.Format(ResponseMessageFormat, messageId, messageTimestamp, amount, purchaseId, externalTransactionId);
var message = (PaymentResponseMessage <RefundResponseTxn>)Serialization.Deserialize <RefundResponseTxn>(serializedMessage).Clone();
// Check.
AssertResponseMessage(messageId, messageTimestamp, amount, purchaseId, externalTransactionId, message);
}
public static int Compare(StateInspectorEvent evt1, MessageTimestamp evt2time, ILogSource evt2source, long evt2Position)
{
int sign = MessageTimestamp.Compare(evt1.Trigger.Timestamp.Adjust(evt1.Output.LogSource.TimeOffsets), evt2time);
if (sign != 0)
{
return(sign);
}
sign = MessagesComparer.CompareLogSourceConnectionIds(
evt1.Output.LogSource.GetSafeConnectionId(), evt2source.GetSafeConnectionId());
if (sign != 0)
{
return(sign);
}
sign = Math.Sign(evt1.Trigger.StreamPosition - evt2Position);
return(sign);
}
public void LoselessFormatTest()
{
var d1 = new MessageTimestamp(new DateTime(2010, 10, 22, 3, 3, 4, DateTimeKind.Local));
var d2 = new MessageTimestamp(new DateTime(2010, 10, 22, 3, 3, 4, DateTimeKind.Utc));
var d3 = new MessageTimestamp(new DateTime(2010, 10, 22, 3, 3, 4, DateTimeKind.Unspecified));
var d1_str = d1.StoreToLoselessFormat();
var d2_str = d2.StoreToLoselessFormat();
var d3_str = d3.StoreToLoselessFormat();
var d1_restored = MessageTimestamp.ParseFromLoselessFormat(d1_str);
var d2_restored = MessageTimestamp.ParseFromLoselessFormat(d2_str);
var d3_restored = MessageTimestamp.ParseFromLoselessFormat(d3_str);
Assert.AreEqual(0, MessageTimestamp.Compare(d1, d1_restored));
Assert.AreEqual(0, MessageTimestamp.Compare(d2, d2_restored));
Assert.AreEqual(0, MessageTimestamp.Compare(d2, d2_restored));
}
public int CompareThreads(IThread t1, IThread t2)
{
if (t1.IsDisposed || t2.IsDisposed)
{
return(0);
}
int ret = 0;
switch (sortColumn)
{
case 0:
ret = string.Compare(t2.ID, t1.ID);
break;
case 1:
ret = MessageTimestamp.Compare(GetBookmarkDate(t2.FirstKnownMessage), GetBookmarkDate(t1.FirstKnownMessage));
break;
case 2:
ret = MessageTimestamp.Compare(GetBookmarkDate(t2.LastKnownMessage), GetBookmarkDate(t1.LastKnownMessage));
break;
}
return(ascending ? ret : -ret);
}
static VisualizerNode MakeRootNode(
IReadOnlyList <IStateInspectorOutputsGroup> groups,
EventHandler <NodeCreatedEventArgs> nodeCreationHandler,
ImmutableDictionary <ILogSource, string> annotationsMap,
VisualizerNode existingRoot
)
{
var existingRoots = existingRoot.Children.ToLookup(c => c.InspectedObject);
var children = ImmutableList.CreateRange(
groups.SelectMany(
group => group.Roots.Select(rootObj =>
{
var existingNode = existingRoots[rootObj].FirstOrDefault();
if (existingNode != null)
{
return(existingNode.SetAnnotationsMap(annotationsMap));
}
var newNode = MakeVisualizerNode(rootObj, 1, annotationsMap);
newNode.SetInitialProps(nodeCreationHandler); // call handler on second phase when all children and parents are initiated
return(newNode);
})
)
);
children = children.Sort((n1, n2) => MessageTimestamp.Compare(GetNodeTimestamp(n1), GetNodeTimestamp(n2)));
var result = new VisualizerNode(null, children, true, false, 0, annotationsMap);
if (!result.HasSelectedNodes && result.Children.Count > 0)
{
result = result.Children[0].Select(true);
}
return(result);
}
static MessageTimestamp ParseDateTime(string str)
{
return(MessageTimestamp.ParseFromLoselessFormat(str));
}
internal TextLogEventTrigger(XmlReader reader)
: this(
long.Parse(reader.GetAttribute(triggerPositionAttrShort)),
MessageTimestamp.ParseFromLoselessFormat(reader.GetAttribute(triggerTimestampAttrShort)))
{
}
public TextLogEventTrigger(IBookmark bmk)
{
StreamPosition = bmk.Position;
Timestamp = new MessageTimestamp(bmk.Time.Adjust(bmk.GetLogSource().TimeOffsets.Inverse()).ToUnspecifiedTime());
}
public TextLogEventTrigger(long position, MessageTimestamp timestamp)
{
this.StreamPosition = position;
this.Timestamp = new MessageTimestamp(timestamp.ToUnspecifiedTime());
}
public TextLogEventTrigger(XElement evtElement) : this(
long.Parse(evtElement.Attribute(triggerPositionAttr).Value),
MessageTimestamp.ParseFromLoselessFormat(evtElement.Attribute(triggerTimestampAttr).Value))
{
}
/// <summary>
/// Read a scope info
/// </summary>
public virtual async Task <(SyncContext, long)> GetLocalTimestampAsync(SyncContext context, MessageTimestamp message)
{
// Open the connection
using (var connection = this.CreateConnection())
{
try
{
await connection.OpenAsync();
var scopeBuilder = this.GetScopeBuilder();
var scopeInfoBuilder = scopeBuilder.CreateScopeInfoBuilder(message.ScopeInfoTableName, connection);
var localTime = scopeInfoBuilder.GetLocalTimestamp();
return(context, localTime);
}
finally
{
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
}
}
public string ToLine()
{
return($"{JsonFileVersion}|{MinerClientVersion}|{Time.ToString()}|{MessageTimestamp.ToString()}|{OutputKeywordTimestamp.ToString()}|{WsStatus.ToString()}");
}
void EnsureTreeView()
{
if (!treeViewInvalidated)
{
return;
}
treeViewInvalidated = false;
var oldRoots = view.EnumCollection(view.RootNodesCollection).ToList();
var newRoots = new List <NodeInfo>();
bool updateStarted = false;
MarkAllViewPartsAsDead();
foreach (var group in model.Groups)
{
TreeViewPart part;
if (!viewPartsCache.TryGetValue(group.Key, out part))
{
viewPartsCache.Add(group.Key, part = new TreeViewPart()
{
Key = group.Key
});
foreach (var rootObj in group.Roots)
{
if (!updateStarted)
{
view.BeginTreeUpdate();
updateStarted = true;
}
var nodesToCollapse = new List <NodeInfo>();
var rootNode = CreateViewNode(view, new NodesCollectionInfo(), rootObj, 0, nodesToCollapse);
part.RootNodes.Add(rootNode);
view.ExpandAll(rootNode);
nodesToCollapse.ForEach(view.Collapse);
}
}
newRoots.AddRange(part.RootNodes);
part.OutputIsAlive = true;
}
RemoveDeadViewPartsFromCache();
newRoots.Sort((n1, n2) => MessageTimestamp.Compare(GetNodeTimestamp(n1), GetNodeTimestamp(n2)));
bool propsNeedUpdating = false;
if (!newRoots.SequenceEqual(oldRoots))
{
if (!updateStarted)
{
view.BeginTreeUpdate();
}
var oldSelectedNodes = view.SelectedNodes;
var newSelectedNodes = (
from selectedNode in oldSelectedNodes
let selectedObj = GetInspectedObject(selectedNode)
where selectedObj != null
let selectedObjRoot = selectedObj.GetRoot()
where newRoots.Any(r => r.Tag == selectedObjRoot)
select selectedNode
).ToArray();
view.Clear(view.RootNodesCollection);
foreach (var rootNode in newRoots)
{
view.AddNode(view.RootNodesCollection, rootNode);
}
if (newSelectedNodes.Length > 0)
{
view.SelectedNodes = newSelectedNodes;
selectedObjectsPathsBeforeSelectionLoss.Clear();
}
else if (oldSelectedNodes.Length > 0)
{
selectedObjectsPathsBeforeSelectionLoss.Clear();
selectedObjectsPathsBeforeSelectionLoss.AddRange(
from selectedNode in oldSelectedNodes
let selectedObj = GetInspectedObject(selectedNode)
where selectedObj != null
select new InspectedObjectPath(selectedObj)
);
}
else if (selectedObjectsPathsBeforeSelectionLoss.Count > 0)
{
newSelectedNodes = (
from p in selectedObjectsPathsBeforeSelectionLoss
let n = p.Follow(this)
where n != null
select n.Value
).ToArray();
if (newSelectedNodes.Length > 0)
{
view.SelectedNodes = newSelectedNodes;
view.ScrollSelectedNodesInView();
selectedObjectsPathsBeforeSelectionLoss.Clear();
}
}
view.EndTreeUpdate();
}
newRoots.ForEach(UpdateRootNodeText);
if (propsNeedUpdating)
{
UpdateSelectedObjectPropertiesAndHistory();
}
}
public async Task <(SyncContext, Int64)> GetLocalTimestampAsync(SyncContext ctx, MessageTimestamp message) => await this.LocalProvider.GetLocalTimestampAsync(ctx, message);
public FrameEnd(long position, long endPosition, IThread thread, MessageTimestamp time, StringSlice rawText = new StringSlice())
:
base(position, endPosition, thread, time, rawText)
{
this.flags = MessageFlag.EndFrame;
}
async Task <bool> IScreenBuffer.MoveToBookmark(
IBookmark bookmark,
BookmarkLookupMode mode,
CancellationToken cancellation)
{
using (CreateTrackerForNewOperation(string.Format("MoveToBookmark({0})", mode), cancellation))
{
var matchMode = mode & BookmarkLookupMode.MatchModeMask;
MessageTimestamp dt = bookmark.Time;
long position = bookmark.Position;
int lineIndex = bookmark.LineIndex;
string logSourceCollectionId = bookmark.LogSourceConnectionId;
var tmp = buffers.ToDictionary(s => s.Key, s => new SourceBuffer(s.Value));
var tasks = tmp.Select(s => new
{
buf = s.Value,
task =
(buffers.Count == 1 && matchMode == BookmarkLookupMode.ExactMatch) ?
GetScreenBufferLines(s.Key, position, bufferSize, EnumMessagesFlag.Forward | EnumMessagesFlag.IsActiveLogPositionHint, isRawLogMode, cancellation) :
GetScreenBufferLines(s.Key, dt.ToLocalDateTime(), bufferSize, isRawLogMode, cancellation),
}).ToList();
await Task.WhenAll(tasks.Select(i => i.task));
cancellation.ThrowIfCancellationRequested();
foreach (var t in tasks)
{
t.buf.Set(t.task.Result);
}
bool messageFound = false;
if (matchMode == BookmarkLookupMode.FindNearestTime)
{
messageFound = true;
}
else
{
foreach (var i in GetMessagesInternal(tmp.Values).Forward(0, int.MaxValue))
{
var cmp = MessagesComparer.CompareLogSourceConnectionIds(i.Message.Message.GetConnectionId(), logSourceCollectionId);
if (cmp == 0)
{
cmp = Math.Sign(i.Message.Message.Position - position);
}
if (cmp == 0)
{
cmp = Math.Sign(((SourceBuffer)i.SourceCollection).Get(i.SourceIndex).LineIndex - lineIndex);
}
if (matchMode == BookmarkLookupMode.ExactMatch)
{
messageFound = cmp == 0;
}
else if (matchMode == BookmarkLookupMode.FindNearestBookmark)
{
messageFound = cmp > 0;
}
if (messageFound)
{
break;
}
var sb = ((SourceBuffer)i.SourceCollection);
sb.UnnededTopMessages++;
}
}
if (!messageFound)
{
if (matchMode == BookmarkLookupMode.FindNearestBookmark)
{
await MoveToStreamsEndInternal(cancellation);
return(true);
}
return(false);
}
buffers = tmp;
FinalizeSourceBuffers();
if (AllLogsAreAtEnd())
{
await MoveToStreamsEndInternal(cancellation);
}
else
{
SetScrolledLines(0);
if ((mode & BookmarkLookupMode.MoveBookmarkToMiddleOfScreen) != 0)
{
var additionalSpace = ((int)Math.Floor(viewSize) - 1) / 2;
if (additionalSpace > 0)
{
await ShiftByInternal(-additionalSpace, cancellation);
}
}
}
return(true);
}
}
