Resolve the open CTT findings: aggregate fixes, de-DE ApplicationName and CTT configuration

plans/ctt-testing.md

@@ -272,7 +272,8 @@ each CU on its own takes well over an hour.
    manual single-case CUs cost nothing.
 2. **One CTT process, fresh server.** The CTT keeps one alarm thread for the whole group, so the initial event
    capture (one Alarm Cycle Time) is paid once, by the first A & C CU.
-3. **Project copy with `/Server Test/Alarms and Conditions/Alarm Cycle Time` = 30** (default 60). The setting
+3. **`/Server Test/Alarms and Conditions/Alarm Cycle Time` = 30** (CTT default 60; `samples/UAReferenceServer.ctt.xml`
+   sets 30). The setting
    is the length of the initial capture, one third of the maximum time of every collector test case, and ten
    times the Enable `Test_003.js` refresh delay. The reference server's alarm sources run a 40 s sawtooth and
    every alarm type reports an event at most 11 s apart, so 30 s still captures every type, and the longest

samples/Quickstarts.Servers/ReferenceServer/ReferenceServer.cs

@@ -458,6 +458,15 @@ protected override ResourceManager CreateResourceManager(
                 }
             }
 
+            // Offer the application name in the advertised locales, so FindServers and
+            // GetEndpoints return a de-DE ApplicationName when the client asks for German.
+            string applicationName = configuration.ApplicationName ?? string.Empty;
+            resourceManager.Add(ApplicationNameKey, "en-US", applicationName);
+            resourceManager.Add(
+                ApplicationNameKey,
+                "de-DE",
+                applicationName.Replace("Reference Server", "Referenzserver", StringComparison.Ordinal));
+
             return resourceManager;
         }
 
@@ -488,6 +497,15 @@ protected override void OnServerStarted(IServerInternal server)
 
             RegisterIdentityAuthenticators(server);
 
+            // Key the ApplicationName of the endpoints, so the resource manager translates it.
+            if (ServerDescription != null)
+            {
+                ServerDescription.ApplicationName = new LocalizedText(
+                    ApplicationNameKey,
+                    "en-US",
+                    ServerDescription.ApplicationName.Text ?? string.Empty);
+            }
+
             try
             {
                 ServerInternal.UpdateServerStatus(
@@ -866,6 +884,7 @@ protected override void Dispose(bool disposing)
             base.Dispose(disposing);
         }
 
+        private const string ApplicationNameKey = "ApplicationName";
         private CertificateManager? m_userCertificateValidator;
         private string? m_rejectedUserStorePath;
         private readonly ITelemetryContext m_telemetry;

samples/Reference/ConsoleReferenceServer/Ctt.ReferenceServer.Config.xml

@@ -196,7 +196,7 @@
     <NodeManagerSaveFile>Ctt.ReferenceServer.nodes.xml</NodeManagerSaveFile>
     <MinSubscriptionLifetime>10000</MinSubscriptionLifetime>
     <MaxPublishRequestCount>20</MaxPublishRequestCount>
-    <MaxSubscriptionCount>100</MaxSubscriptionCount>
+    <MaxSubscriptionCount>200</MaxSubscriptionCount>
     <MaxEventQueueSize>10000</MaxEventQueueSize>
     <!-- see https://opcfoundation-onlineapplications.org/profilereporting/ for list of available profiles -->
     <ServerProfileArray>

samples/UAReferenceServer.ctt.xml

@@ -397,7 +397,7 @@
          </Column>
          <Column column="1">
           <ItemData role="0" rolename="DisplayRole">
-           <Value type="10" typename="QString" data="100"/>
+           <Value type="10" typename="QString" data="200"/>
           </ItemData>
           <ChildRows size="0"/>
          </Column>
@@ -16578,7 +16578,7 @@
          </Column>
          <Column column="1">
           <ItemData role="0" rolename="DisplayRole">
-           <Value type="10" typename="QString" data="60"/>
+           <Value type="10" typename="QString" data="30"/>
           </ItemData>
           <ChildRows size="0"/>
          </Column>

src/Opc.Ua.Server/Aggregates/AggregateCalculator.cs

@@ -680,11 +680,6 @@ protected class TimeSlice
             /// </summary>
             public LinkedListNode<DataValue> EarlyBound { get; set; } = null!;
 
-            /// <summary>
-            /// The latest non-Bad value before the slice.
-            /// </summary>
-            public LinkedListNode<DataValue> NonBadEarlyBound { get; set; } = null!;
-
             /// <summary>
             /// The second early bound for the slice (always earlier than the first).
             /// </summary>
@@ -802,11 +797,6 @@ protected bool UpdateSlice(TimeSlice slice)
                     // check if before the beginning of the slice.
                     if (CompareTimestamps(slice.StartTime, ii) >= 0)
                     {
-                        if (StatusCode.IsNotBad(ii.Value.StatusCode))
-                        {
-                            slice.NonBadEarlyBound = ii;
-                        }
-
                         if (IsGood(ii.Value))
                         {
                             slice.SecondEarlyBound = slice.EarlyBound;
@@ -843,11 +833,6 @@ protected bool UpdateSlice(TimeSlice slice)
                     // check if before the beginning of the slice.
                     if (CompareTimestamps(slice.StartTime, ii) > 0)
                     {
-                        if (StatusCode.IsNotBad(ii.Value.StatusCode))
-                        {
-                            slice.NonBadEarlyBound = ii;
-                        }
-
                         if (IsGood(ii.Value))
                         {
                             slice.SecondEarlyBound = slice.EarlyBound;

src/Opc.Ua.Server/Aggregates/CountAggregateCalculator.cs

@@ -92,6 +92,61 @@ public static ArrayOf<DataValue> CalculateAnnotationCounts(
             double processingInterval,
             int outputCap,
             CancellationToken cancellationToken)
+        {
+            return CalculateAnnotationCounts(
+                annotationTimestamps,
+                startTime,
+                endTime,
+                processingInterval,
+                DateTimeUtc.MinValue,
+                DateTimeUtc.MaxValue,
+                outputCap,
+                cancellationToken);
+        }
+
+        /// <summary>
+        /// Calculates AnnotationCount values for the requested time domain of a
+        /// history collection whose data spans the specified range.
+        /// </summary>
+        /// <remarks>
+        /// Part 13 §5.4.3.20: an interval entirely before the start of data or
+        /// after the end of data is <c>Bad_NoData</c>, and an interval that
+        /// overlaps the start or the end of data has the Partial bit set
+        /// (§5.3.3.2). Pass a <paramref name="startOfData"/> later than
+        /// <paramref name="endOfData"/> when the collection has no data.
+        /// </remarks>
+        /// <param name="annotationTimestamps">
+        /// Annotation timestamps in any order.
+        /// </param>
+        /// <param name="startTime">The start of the requested domain.</param>
+        /// <param name="endTime">The end of the requested domain.</param>
+        /// <param name="processingInterval">
+        /// The interval in milliseconds. Zero requests one result over the
+        /// complete domain.
+        /// </param>
+        /// <param name="startOfData">The timestamp of the first data point.</param>
+        /// <param name="endOfData">The timestamp of the last data point.</param>
+        /// <param name="outputCap">Maximum number of returned values.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>The calculated AnnotationCount values.</returns>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="annotationTimestamps"/> is null.
+        /// </exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="outputCap"/> is not positive.
+        /// </exception>
+        /// <exception cref="ServiceResultException">
+        /// The interval is invalid or the output cap is exceeded.
+        /// </exception>
+        public static ArrayOf<DataValue> CalculateAnnotationCounts(
+            ArrayOf<DateTimeUtc> annotationTimestamps,
+            DateTimeUtc startTime,
+            DateTimeUtc endTime,
+            double processingInterval,
+            DateTimeUtc startOfData,
+            DateTimeUtc endOfData,
+            int outputCap,
+            CancellationToken cancellationToken)
         {
             if (annotationTimestamps.IsNull)
             {
@@ -181,7 +236,33 @@ public static ArrayOf<DataValue> CalculateAnnotationCounts(
                         cursor,
                         next,
                         cancellationToken);
-                values.Add(CreateAnnotationCountValue(count, cursor));
+
+                // chronological bounds; forward intervals exclude the late
+                // time and reverse intervals exclude the early time.
+                DateTimeUtc early = forward ? cursor : next;
+                DateTimeUtc late = forward ? next : cursor;
+                bool beforeStartOfData = forward
+                    ? late <= startOfData
+                    : late < startOfData;
+                bool afterEndOfData = forward
+                    ? early > endOfData
+                    : early >= endOfData;
+                if (beforeStartOfData || afterEndOfData)
+                {
+                    values.Add(new DataValue(
+                        Variant.Null,
+                        StatusCodes.BadNoData,
+                        cursor,
+                        cursor));
+                }
+                else
+                {
+                    // same edge rules as AggregateCalculator.TryGetProcessedValue.
+                    bool partial =
+                        (startOfData > early && startOfData < late) ||
+                        (endOfData >= early && endOfData < late);
+                    values.Add(CreateAnnotationCountValue(count, cursor, partial));
+                }
                 cursor = next;
             }
             return values.ToArrayOf();
@@ -340,7 +421,12 @@ protected DataValue ComputeDurationInState(TimeSlice slice, bool isNonZero)
                 StatusCodes.Good,
                 GetTimestamp(slice),
                 GetTimestamp(slice));
-            value = value.WithStatus(GetTimeBasedStatusCode(regions, value.StatusCode));
+
+            // The duration uses stepped regions because a state lasts until the next value, but
+            // the status regions follow the interpolation of the variable: with sloped
+            // interpolation a region ending in a Bad or Uncertain value (including the simple
+            // end bound) is Uncertain (Part 13 §5.4.3.2.2).
+            value = value.WithStatus(GetTimeBasedStatusCode(slice, values, value.StatusCode));
             value = value.WithStatus(value.StatusCode.WithAggregateBits(AggregateBits.Calculated));
 
             // return result.
@@ -362,7 +448,9 @@ protected DataValue ComputeNumberOfTransitions(TimeSlice slice)
             }
 
             // The first non-Bad value is a transition when no previous non-Bad value exists.
-            LinkedListNode<DataValue>? previousValue = slice.NonBadEarlyBound;
+            // Part 13 §4.2.1.2: with TreatUncertainAsBad an Uncertain value is equivalent to Bad,
+            // so it is neither counted nor used as the previous value (IsGood applies the setting).
+            LinkedListNode<DataValue>? previousValue = slice.EarlyBound;
             bool hasLastValue = previousValue != null;
             Variant lastValue = previousValue != null
                 ? previousValue.Value.WrappedValue
@@ -373,7 +461,7 @@ protected DataValue ComputeNumberOfTransitions(TimeSlice slice)
 
             for (int ii = 0; ii < values.Count; ii++)
             {
-                if (StatusCode.IsBad(values[ii].StatusCode))
+                if (!IsGood(values[ii]))
                 {
                     continue;
                 }
@@ -502,15 +590,18 @@ private static int CountReverseAnnotations(
 
         private static DataValue CreateAnnotationCountValue(
             int count,
-            DateTimeUtc timestamp)
+            DateTimeUtc timestamp,
+            bool partial)
         {
             var value = new DataValue(
                 Variant.From(count),
                 StatusCodes.Good,
                 timestamp,
                 timestamp);
             return value.WithStatus(value.StatusCode.WithAggregateBits(
-                AggregateBits.Calculated));
+                partial
+                    ? AggregateBits.Calculated | AggregateBits.Partial
+                    : AggregateBits.Calculated));
         }
     }
 }

src/Opc.Ua.Server/Historian/HistorianDispatcher.cs

@@ -1118,6 +1118,55 @@ private static async ValueTask<ServiceResult> ComputeAnnotationCountAsync(
                 }
                 token = page.NextToken;
             }
+
+            // Part 13 §5.4.3.20: intervals before the start or after the end of data are
+            // Bad_NoData and intervals overlapping either edge are Partial. The data is the
+            // raw history (read with bounds, as for the other aggregates) and the annotations.
+            DateTimeUtc startOfData = DateTimeUtc.MaxValue;
+            DateTimeUtc endOfData = DateTimeUtc.MinValue;
+            foreach (DateTimeUtc annotationTime in annotationTimes)
+            {
+                startOfData = annotationTime < startOfData ? annotationTime : startOfData;
+                endOfData = annotationTime > endOfData ? annotationTime : endOfData;
+            }
+            if (provider is IHistorianDataProvider raw)
+            {
+                var rawRequest = new HistorianRawReadRequest
+                {
+                    NodeId = node.NodeId,
+                    StartTime = windowStart,
+                    EndTime = windowEnd,
+                    MaxValues = 0,
+                    IsForward = true,
+                    ReturnBounds = true
+                };
+                HistorianResumeToken rawToken = default;
+                while (true)
+                {
+                    HistorianPage<HistoricalDataValue> rawPage = await raw.ReadRawAsync(
+                        opContext, rawRequest, rawToken, cancellationToken).ConfigureAwait(false);
+                    foreach (HistoricalDataValue sample in rawPage.Values)
+                    {
+                        // skip bound placeholders as AggregateCalculator.QueueRawValue does.
+                        StatusCode status = sample.Value.StatusCode;
+                        if (sample.Value.IsNull ||
+                            status == StatusCodes.BadNoData ||
+                            status == StatusCodes.BadBoundNotFound)
+                        {
+                            continue;
+                        }
+                        DateTimeUtc sampleTime = sample.Value.SourceTimestamp;
+                        startOfData = sampleTime < startOfData ? sampleTime : startOfData;
+                        endOfData = sampleTime > endOfData ? sampleTime : endOfData;
+                    }
+                    if (rawPage.IsFinal)
+                    {
+                        break;
+                    }
+                    rawToken = rawPage.NextToken;
+                }
+            }
+
             ArrayOf<DataValue> outputs;
             try
             {
@@ -1126,6 +1175,8 @@ private static async ValueTask<ServiceResult> ComputeAnnotationCountAsync(
                     startTime,
                     endTime,
                     details.ProcessingInterval,
+                    startOfData,
+                    endOfData,
                     kMaxProcessedBufferedOutputs,
                     cancellationToken);
             }

tests/Opc.Ua.Core.Tests/Stack/Transport/TcpServerChannelBufferTests.cs

@@ -1064,6 +1064,69 @@
                 Is.GreaterThan(DateTime.UtcNow.AddMinutes(-1)));
         }
 
+        /// <summary>
+        /// The shape of CTT GDS Application Directory 005.js: a Call request whose
+        /// String input argument is MaxStringLength + 10 %, sent in two chunks.
+        /// The Bad_EncodingLimitsExceeded ServiceFault (OPC 10000-4 §5.3) echoes
+        /// the RequestHandle (OPC 10000-4 §7.34), read from the first chunk.
+        /// </summary>
+        [Test]
+        public async Task OversizedCallArgumentInChunkedRequestFaultEchoesRequestHandleAsync()
+        {
+            const int maxStringLength = 1000;
+            var pool = new TrackingArrayPool();
+            using TestServerChannel channel = CreateOpenChannel(pool, maxStringLength: maxStringLength);
+            var transport = new GateByteTransport(expectedSendCount: 1, captureSentChunks: true);
+            channel.SetTransport(transport);
+
+            var request = new CallRequest
+            {
+                RequestHeader = new RequestHeader
+                {
+                    AuthenticationToken = new NodeId(Guid.NewGuid()),
+                    Timestamp = DateTime.UtcNow,
+                    RequestHandle = 18
+                },
+                MethodsToCall =
+                [
+                    new CallMethodRequest
+                    {
+                        ObjectId = new NodeId(141u, 2),
+                        MethodId = new NodeId(143u, 2),
+                        InputArguments = [new Variant(new string('u', maxStringLength + (maxStringLength / 10)))]
+                    }
+                ]
+            };
+            var encodeContext = ServiceMessageContext.Create(NUnitTelemetryContext.Create());
+            encodeContext.MaxStringLength = 0;
+            byte[] body = BinaryEncoder.EncodeMessage(request, encodeContext);
+            int split = body.Length / 2;
+
+            await channel.FeedReceivedChunkAsync(
+                channel.CreateRequestChunkForTest(
+                    TcpMessageType.Message,
+                    isFinal: false,
+                    sequenceNumber: 1,
+                    requestId: 7,
+                    body: body[..split]))
+                .ConfigureAwait(false);
+            await channel.FeedReceivedChunkAsync(
+                channel.CreateRequestChunkForTest(
+                    TcpMessageType.Message,
+                    isFinal: true,
+                    sequenceNumber: 2,
+                    requestId: 7,
+                    body: body[split..]))
+                .ConfigureAwait(false);
+
+            ServiceFault fault = await ReadSentServiceFaultAsync(transport, expectedRequestId: 7)
+                .ConfigureAwait(false);
+            Assert.That(
+                fault.ResponseHeader.ServiceResult,
+                Is.EqualTo((StatusCode)StatusCodes.BadEncodingLimitsExceeded));
+            Assert.That(fault.ResponseHeader.RequestHandle, Is.EqualTo(18u));
+        }
+
         /// <summary>
         /// A discovery-only channel rejects a non-discovery request from its
         /// encoding id before decoding it; the ServiceFault still echoes the