Subscription Basic

Support the following Subscription Services: CreateSubscription, ModifySubscription, DeleteSubscriptions, Publish, Republish and SetPublishingMode.


Questions? Contact us
Generated: 21/11/2021 at 17:21:20 p.m.
Subscription Basic - 99 Test Cases
Test Case Id Test Type Keywords Test Case Description Test Requirements Expected Result

001

CTT CreateSubscription()  Create a subscription using default parameters of the client. ServiceResult = Good
All parameter values are valid and correct.

002

CTT CreateSubscription()  Create a subscription where requestedPublishingInterval (data type is Duration) is 1. ServiceResult = Good.
revisedPublishingInterval returns fastest publishing interval (which may be 1).
All other parameter values are valid and correct.

003

CTT CreateSubscription()  Create a subscription where requestedPublishingInterval is 0. ServiceResult = Good.
Verify the revisedPublishingInterval is not equal to 0.

004

CTT CreateSubscription()  Create a subscription where requestedPublishingInterval is max size of a Double. ServiceResult = Good.
Verify the revisedPublishingInterval.
It `might` match the MAX Double, or some kind of multiple that is a nearest supported match.

005

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is 0 and RequestedMaxKeepAliveCount is 0. ServiceResult = Good.
All returned parameter values are valid and correct.
revisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount which should be set to the smallest number the server supports.
BASICALLY the server is populating the revised figures with the lowest numbers that it supports!

006

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is 3 and RequestedMaxKeepAliveCount is 1. ServiceResult = Good
All returned parameter values are valid and correct. revisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount.

007

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is equal to RequestedMaxKeepAliveCount. ServiceResult = Good.
RevisedLifetimeCounter returns a value at least 3 times that of the revisedMaxKeepAliveCount.
All other parameter values are valid and correct.
If the revised is not 3x then the test is fail!

008

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is less than RequestedMaxKeepAliveCount. ServiceResult = Good.
RevisedLifetimeCounter returns a value at least 3 times that of the revisedMaxKeepAliveCount.
All other parameter values are valid and correct.
If the revised is not 3x then the test is fail!

009

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is less than 3 times the RequestedMaxKeepAliveCount ServiceResult = Good.
All returned parameter values are valid and correct.
RevisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount.
If the revised is not 3x then the test is fail!

010

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is max UInt32 and RequestedMaxKeepAliveCount is (max UInt32)/3. ServiceResult = Good.
All returned parameter values are valid and correct.
RevisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount.

011

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is max UInt32 and RequestedMaxKeepAliveCount is (max UInt32)/2. ServiceResult = Good.
All returned parameter values are valid and correct.
RevisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount.
If the revised is not 3x then the test is fail!

012

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter is (max UInt32)/2 and RequestedMaxKeepAliveCount is max UInt32. ServiceResult = Good.
All returned parameter values are valid and correct.
RevisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount.
If the revised is not 3x then the test is fail!

013

CTT CreateSubscription()  Create a subscription where RequestedLifetimeCounter and RequestedMaxKeepAliveCount are max UInt32. ServiceResult = Good.
All returned parameter values are valid and correct.
RevisedLifetimeCounter is at least 3 times that of the revisedMaxKeepAliveCount.
If the revised is not 3x then the test is fail!

014

CTT CreateSubscription()  Create a subscription where PublishingEnabled is FALSE. ServiceResult = Good.
All returned parameter values are valid and correct.
Verify that publishing does not begin by making sure the NotificationData is empty, and SubscriptionId=0.

015

CTT CreateSubscription()  Create a subscription (no monitoredItems) with a RequestedPublishingInterval of 1000, and a RequestedLifetimeCount of 20.
Wait (RevisedPublishingInterval * RevisedLifetimeCount / 2) milliseconds and then call Publish().
Wait ((RevisedPublishingInterval * RevisedLifetimeCount) - 1000 milliseconds) and then call Publish().
All service and operation results are Good.
Both Publish calls return a keep-alive notificationMessage with a sequence number of 1.

016

CTT CreateSubscription()  Given a valid subscription.
And an amount of time approaching the subscription's expiry time passes.
Call DeleteSubscription() to delete the subscription.
Any and all service and operation level results are `good`.

017

CTT CreateSubscription()  Create a subscription (no monitored items) with a RequestedPublishingInterval of 1000 and a RequestedMaxKeepAliveCount of 5.
Call Publish().
Call Publish() again.
All service and operation results are Good.
The first Publish returns in revisedPublishingInterval milliseconds with a keep-alive notificationMessage (i.e., a notificationMessage that contains no notifications).
The sequence number in the notificationMessage is 1.
The second Publish returns a keep-alive notificationMessage (revisedPublishingInterval * revisedMaxKeepAliveCount) milliseconds after the first Publish.
The sequence number in the notificationMessage is 1.

018

CTT CreateSubscription()  Create a subscription (no monitored items) with a RequestedPublishingInterval of 3000 and a RequestedMaxKeepAliveCount of 3.
Call Publish().
Call Publish() again.
All service and operation results are Good.
The first Publish returns in revisedPublishingInterval milliseconds with a keep-alive notificationMessage.
The sequence number in the notificationMessage is 1.
The second Publish returns (revisedPublishingInterval * revisedMaxKeepAliveCount) milliseconds later with a keep-alive notificationMessage.
The sequence number in the notificationMessage is 1.

019

CTT CreateSubscription()  Create a subscription (no monitoredItems) with a RequestedPublishingInterval of 1000 and a RequestedMaxKeepAliveCount of 5.
Wait (RevisedPublishingInterval + 500) milliseconds and then call Publish().
Wait ((RevisedPublishingInterval * RevisedMaxKeepAliveCount) + 500) milliseconds and then call Publish() again.
All service and operation results are Good.
Both Publish calls immediately return a keep-alive notificationMessage.

020

CTT CreateSubscription()  Create a subscription (no monitoredItems) with a RequestedPublishingInterval of 1000, a RequestedMaxKeepAliveCount of 5, and PublishingEnabled = FALSE.
Call Publish().
Call Publish() again.
All service and operation results are Good.
First Publish returns in revisedPublishingInterval milliseconds with a keep-alive notificationMessage. The sequence number in the notificationMessage is 1.
Second Publish returns (revisedPublishingInterval * revisedMaxKeepAliveCount) milliseconds later with a keep-alive notificationMessage. The sequence number in the notificationMessage is 1.

021

CTT CreateSubscription()  Create a subscription (no monitoredItems) with a RequestedPublishingInterval of 1000, a RequestedMaxKeepAliveCount of 10, and a RequestedLifetimeCount of 30.
Wait (RevisedPublishingInterval * RevisedMaxKeepAliveCount / 2) milliseconds and then call Publish().
Call Publish() again.
All service and operation results are Good.
First Publish immediately returns a keep-alive notification.
The sequence number in the notificationMessage is 1.
Second Publish returns (revisedPublishingInterval * revisedMaxKeepAliveCount) milliseconds later.
The sequence number in the notificationMessage is 1.

See UA Part 4 section 5.13.1.1 bullet #d.

022

CTT CreateSubscription()  Create a subscription with a RequestedPublishingInterval of 1000, a RequestedMaxKeepAliveCount of 10, and a RequestedLifetimeCount of 30.
Add a static monitoredItem to the subscription.
Wait (RevisedPublishingInterval * RevisedMaxKeepAliveCount / 2) milliseconds and then write a value, wait one publishing cycle and then call Publish().
Call Publish() again.
All service and operation results are Good.
First Publish immediately returns a data notification.
Second Publish returns (revisedPublishingInterval * revisedMaxKeepAliveCount) milliseconds later with a keep-alive message.

023

CTT ModifySubscription()  Create a subscription using default parameters, using a static monitoredItem.
Modify a subscription using default parameters.
In a loop (of 3 iterations):
1. Write to the monitoredItem Node.
2. Call Publish().
All Service and operation-level results are Good.
All returned parameter values are valid and correct.
The total time to receive all 3 publish() calls will be within 6 to 7 seconds.

024

CTT ModifySubscription()  Modify a subscription where RequestedPublishingInterval is (7ms) greater than RevisedPublishingInterval from CreateSubscription().
In a loop (of 3 iterations):
1. Write() to the monitoredItem Node.
2. Call Publish().
ServiceResult = Good.
All returned parameter values are valid and correct.
Verify the revisedPublishingInterval is either the same as what was requested, or greater than what was requested.
The total time to receive all 3 publish() calls will be within 3 to 4 seconds.

025

CTT ModifySubscription()  Modify a subscription where RequestedPublishingInterval is (7ms) less than RevisedPublishingInterval from CreateSubscription.
In a loop (of 3 iterations):
1. Write to the monitoredItem Node.
2. Call Publish().
ServiceResult = Good.
All returned parameter values are valid and correct.
Verify the revisedPublishingInterval is either the same as what was requested, or greater than what was requested.
The total time to receive all 3 publish() calls will be within 3 to 4 seconds.

026

CTT ModifySubscription()  Modify a subscription where all parameters are equal to those used in CreateSubscription.
In a loop (of 3 iterations):
1. Write to the monitoredItem Node.
2. Call Publish().
ServiceResult = Good.
All returned parameter values are valid and correct.
The total time to receive all 3 publish() calls will be within 3 to 4 seconds.

027

CTT ModifySubscription()  Modify a subscription where RequestedPublishingInterval is 1. ServiceResult = Good.
RevisedPublishingInterval returns fastest publishing interval as defined in the SETTINGS.
All other parameter values are valid and correct.

028

CTT ModifySubscription()  Modify a subscription where RequestedPublishingInterval is 0. ServiceResult = Good.
RevisedPublishingInterval returns fastest publishing interval as defined in the SETTINGS.
All other parameter values are valid and correct.

029

CTT ModifySubscription()  Modify a subscription where RequestedPublishingInterval is max size of a Double. ServiceResult = Good.
Verify the revisedPublishingInterval != MAX Double && >= minimum publishingInterval.

030

CTT ModifySubscription()  Modify a subscription where on each modification (each row is an individual modification change):

* LifetimeCounter: increased; MaxKeepAliveCount: increased.
* LifetimeCounter: decreased; MaxKeepAliveCount: increased.
* LifetimeCounter: same; MaxKeepAliveCount: increased.
* LifetimeCounter: increased; MaxKeepAliveCount: decreased.
* LifetimeCounter: decreased; MaxKeepAliveCount: decreased.
* LifetimeCounter: same; MaxKeepAliveCount: decreased.
* LifetimeCounter: increased; MaxKeepAliveCount: same.
* LifetimeCounter: decreased; MaxKeepAliveCount: same.
* LifetimeCounter: same; MaxKeepAliveCount: same.
ServiceResult = Good.
All returned parameter values are valid and correct.

031

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is 0 and RequestedMaxKeepAliveCount is 0. ServiceResult = Good.
All returned parameter values are valid and correct.

032

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is 3 and RequestedMaxKeepAliveCount is 1. ServiceResult = Good
All returned parameter values are valid and correct.

033

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is equal to RequestedMaxKeepAliveCount. ServiceResult = Good
All returned parameter values are valid and correct.

034

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is less than RequestedMaxKeepAliveCount. ServiceResult = Good.
All returned parameter values are valid and correct.

035

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is less than 3 times (e.g. 2x) the RequestedMaxKeepAliveCount. ServiceResult = Good.
All returned parameter values are valid and correct.

036

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is max UInt32 and RequestedMaxKeepAliveCount is (max UInt32)/3. ServiceResult = Good.
All returned parameter values are valid and correct.

037

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is max UInt32 and RequestedMaxKeepAliveCount is (max UInt32)/2. ServiceResult = Good.
All returned parameter values are valid and correct.

038

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter is (max UInt32)/2 and RequestedMaxKeepAliveCount is max UInt32. ServiceResult = Good.
All returned parameter values are valid and correct.

039

CTT ModifySubscription()  Modify a subscription where RequestedLifetimeCounter and RequestedMaxKeepAliveCount are max UInt32. ServiceResult = Good.
All returned parameter values are valid and correct.

040

CTT ModifySubscription()  This test assumes an existing active subscription (with at least 2 monitoredItem that is reporting data changes) whose MaxNotificationsPerPublish is 0.
Call Publish (#1) to get the initial data changes.
Modify the subscription while specifying the maxNotificationsPerPublish of 1.
Invoke writes to the monitoredItems.
Call Publish() twice (#2 and #3).
All service and operation results are Good.
The first publish (#1) yields a DataChange containing values for both items.
The second Publish (#2) call will yield a DataChange with 1 monitoredItem value and MoreNotifications=True.
The third publish (#3) will contain a DataChange with the other item.

041

CTT ModifySubscription()  Create an active subscription whose MaxNotificationsPerPublish = 0, and the subscription has 15 or more static MonitoredItems).
Call Publish().
Modify the subscription and set the MaxNotificationsPerPublish = 5.
Invoke a Write to all MonitoredItems.
In a loop: Call Publish() until a KeepAlive is received.
All service and operation results are Good.
After the subscription has been modified:
All Publish calls will receive at most 5-notification messages and parameter MoreNotifications=TRUE; except when the last set of notifications are received and then MoreNotifications=FALSE.
The final Publish call will contain KeepAlive only.

042

CTT Republish()  Create a subscription monitoring multiple items.
Call Publish() to get the initial value(s).
In a loop of 3 iterations: Write() a value to all items and then call Publish() withoutacknowledging any sequenceNumbers.
After the loop, call Republish() to retrieve the notificationMessages already received (but not acknowledged) in the Publish() calls, but request the sequenceNumbers out of order, e.g.
2, 1, 3.
All service and operation level results are Good.
The Republish() calls yield the same dataChange notifications as received in Publish() calls.

UA 1.03: Republish() support is OPTIONAL, although the service is required. If not supported then the ServiceResult is BadMessageNotAvailable.

043

CTT SetPublishingMode()  Create a subscription (default values) with a static monitoredItem.
Call Publish().
Set PblishingEnabled=FALSE.
Write to the monitoredItems.
Call Publish().
All service and operation level results are `good`.
The call to Publish() before the change yields a dataChange.
The call to Publish() after the change yield a KeepAlive.

044

CTT SetPublishingMode()  Create a subscription (PublishingEnabled=FALSE) with a static monitoredItem.
Call Publish().
Set PublishingEnabled=TRUE.
Write to the monitoredItems.
Call Publish().
All service and operation level results are `good`.
The call to Publish() before the change yields no dataChanges.
The call to Publish() after the change yields a dataChange.

045

CTT SetPublishingMode()  Create a subscription (default values) with a static monitoredItem.
Call Publish().
Set publishingEnabled=TRUE.
Write to the monitoredItems.
Call Publish().
All service and operation level results are `good`.
The calls to Publish() always yield a dataChange.

046

CTT SetPublishingMode()  Create a subscription (PblishingEnabled=FALSE) with a static monitoredItem.
Call Publish().
Set PblishingEnabled=FALSE.
Write to the monitoredItems.
Call Publish().
All service and operation level results are `good`.
The calls to Publish() yields a KeepAlive.

047

CTT SetPublishingMode()  Create a subscription (PblishingEnabled=TRUE) monitoring a single Static monitoredItem.
Specify the subscription 5 times in the call to SetPublishingMode where the PblishingEnabled=FALSE.
Write to the monitoredItem.
Call Publish().
All service and operation level results are Good.
The Publish() call yields a KeepAlive.

048

CTT SetPublishingMode()  Create a subscription (PblishingEnabled=FALSE) monitoring a single Static monitoredItem.
Specify the subscription 5 times in the call to SetPublishingMode where the PblishingEnabled=TRUE.
Write to the monitoredItem.
Call Publish().
All service and operation level results are Good.
The Publish() call yields a dataChange!

049

CTT Publish()  Create a subscription.
Call Publish() without any acknowledgements.
ServiceResult = Good.
Check that the first sequenceNumber is 1.

050

CTT Publish()  Create a subscription containing active monitoredItems.
Call Publish().
Call Publish() again and acknowledge the sequence number and subscription received in the first Publish() call.
All Service and operation level results are Good.

053

CTT Publish()  Acknowledge multiple valid and invalid (current sequence number + 1000) sequence numbers from multiple valid and invalid subscriptions. ServiceResult = `Good`.
results[i] = Bad_SequenceNumberUnknown(i = index of invalid sequence numbers in sequence numbers array).
results[j] = Good (j = index of valid sequence numbers in sequence numbers array).
results[] = Bad_SubscriptionIdInvalid for the incorrect subscription parameters.

054

CTT Publish()  Call Publish() multiple times to verify that the subscriptions are indeed occurring at the rate configured.
The intervals to test are: 1000, 2000 and 4000 msecs.
Measure the number of callbacks over a 10 second period.
ServiceResult and all operation level results are `Good`.
The number of dataChanges expected:
- 1000ms = 10 callbacks.
- 2000ms = 5 callbacks.
- 4000ms = 2 callbacks.
A warning if the count is +/- 1.
A fail if the count is greater than +/- 1.

055

CTT Publish()  Acknowledge valid and invalid (current sequence number + 1000) sequence numbers from a valid subscription. ServiceResult = `Good`.
results[i] = Bad_SequenceNumberUnknown(i = index of invalid sequence numbers in sequence numbers array).
results[j] = Good (j = index of valid sequence numbers in sequence numbers array).

056

CTT Republish()  Create a subscription using default values. Monitor dynamic monitoredItem(s).
Call Publish().
Call Republish() and use default parameters.
All Service and Operation level results are Good.
Publish() yields valid data.
Republish yields the same notificationMessage data as Publish().

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

057

CTT Republish()  Call Republish() multiple times, to obtain the last 3 notifications. ServiceResult = Good.
NotificationMessages contain valid data.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

058

CTT Republish()  Create a subscription using default values.
Monitor multiple monitoredItem(s).
For a period of Publish.Response.RevisedKeepAliveInterval-1:
* Write() to the monitored items.
* Call Publish(), but do not acknowledge any of the subscriptions/sequences.
After this period expires, call Republish() to retrieve ALL of the same subscription/sequence dataChange notifications as originally received in the unacknowledged Publish() calls.
All service and operation level results are Good.
The Republish() calls yield the same dataChange notifications as received in Publish() calls.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable.

059

CTT Republish()  Create a subscription using default values, monitoring multiple item(s).
Call Publish() 4 times, do not acknowledge the 3rd sequenceNumber.
Call Republish() to retrieve the 3rd (missing) dataChange notification message.

Note: Write() is used to force data-changes to the MonitoredItems.
All service and operation level results are Good.
The Republish() calls yield the correct dataChange notification message.


UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable.

060

CTT DeleteSubscriptions()  Call DeleteSubscription() on valid subscription. ServiceResult = Good.
Results[0] = Good.

061

CTT DeleteSubscriptions()  Create a subscription with monitoredItems.
Call DeleteSubscription() on the subscription (without calling deleteMonitoredItems).
Call ModifyMonitoredItems().
All calls before `modifyMonitoredItems` will return Good.
ModifyMonitoredItems will yield Bad_SubscriptionIdInvalid.

062

CTT Republish()  Create a subscription with one or more monitored items.
Call Publish() to obtain the sequence number.
Call Republish() and request a sequence number greater than the current sequence number.
Service result = Bad_MessageNotAvailable.

063

CreateMonitoredItems()  ModifyMonitoredItems()  DeleteMonitoredItems()  CreateSubscription()  Verify the lifetime of a subscription increases with subsequent subscription service-calls, explicitly excluding Publish:
Step #
Action
Expected Result(s)

1

Create a new Subscription (default parameter values, short lifetime e.g. 10 seconds).

Service result = Good. All returned parameters are valid.

2

Wait until the subscription nearly expires (perhaps 2-seconds before expiration) and then call CreateMonitoredItems().

Service result = Good. All returned parameters are valid.

3

Wait until the subscription nearly expires (perhaps 2-seconds before expiration) and then call ModifyMonitoredItems().

Service result = Good. All returned parameters are valid.

4

Wait until the subscription nearly expires (perhaps 2-seconds before expiration) and then call DeleteMonitoredItems() for half of the items.

Service result = Good. All returned parameters are valid.

5

Wait the same time-period as before and then call Publish().

The Publish() call contains the initial data-change.

064

CTT Unavailable  Create a subscription with a MonitoredItem for the ServerObject.Notifier (no filter); Write to a node that will invoke an Event of any kind; Call Publish.
Step #
Action
Expected Result(s)

1

The CreateMonitoredItems request may fail if events are not supported; if so, then exit gracefully; otherwise, we expect an Event in the Publish response.

2

In a loop, write to the same node as before; call Publish but do not acknowledge the SequenceNumber. This will cause Publish notifications to accumulate in the Server.

Event notifications are received in each Publish response.

3

In a loop, call Republish for each of the Publishes received previously.

The same event notifications are received as before.

065

CTT Unavailable  Create a subscription with a MonitoredItem for the ServerObject.Notifier (no filter); Write to a node that will invoke an Event of any kind; Call Publish. The CreateMonitoredItems request may fail if events are not supported; if so, then exit gracefully; otherwise, we expect an Event in the Publish response.

066

Lab UA 1.03  Startup the server and create a subscription and check the subscriptionId, add one or more items, allow some Publish calls, and then disconnect.
Step #
Action
Expected Result(s)

1

<p> All calls are successful.<br /> SubscriptionId is either 1 or some other number.</p>

2

<p> Repeat the above steps a number of times.</p>

3

<p> Reboot the Server.</p>

4

<p> Repeat step 1. Check the subscriptionId.</p>

<p> SubscriptionId is either a random number or a different number from what was observed before.</p>

067

CTT Create a subscription that is monitoring a static node. Call Publish.
Step #
Action
Expected Result(s)

1

<p> All calls are successful. Initial data-change received.</p>

2

<p> Issue a Publish call while specifying a RequestHeader.TimeoutHint that is smaller than the subscription keepAlive.</p>

<p> Service result is BadTimeout and no data is returned.</p>

068

Lab UA 1.04  Create a subscription and monitor an item, preferably with a changing value (e.g. counter, current-time etc.)
Verify the Client is seeing the item's value change.
This test can only be conducted manually if the server permits removing items from the address space at runtime.
Step #
Action
Expected Result(s)

1

Data changes are seen by the client.

2

Remove the item from the address space. Note: some Clients might attempt to re-add the item to the subscription; the same expected result occurs.

Server sends a Publish response containing a BadNodeIdUnknown for the item.

3

Add the item back into the address space maintaining the same NodeId.

Server sends a Publish response with the item's value, and continues to receive updates.

069

CTT Unavailable  UA 1.04  Select all floating point variables configured for testing. Read and cache their initial values. Setup a subscription, monitor the items, call Publish.
Step #
Action
Expected Result(s)

1

All calls successful. Publish yields the initial value of the item.

2

Write a NaN to all items. Call Publish.

Write is successful. DataChange returns a NaN.

3

Write a NaN to all items. Call Publish.

KeepAlive received.

4

Write the original value for all items. Call Publish.

Write is successful. DataChange returns new value.

5

Repeat steps 2-4 once more.

Err-001

CTT CreateSubscription()  Create a subscription where RequestedPublishingInterval is a negative number. ServiceResult is Good.
The revisedPublishingInterval contains the fastest rate supported by the server.

Err-002

CTT CreateSubscription()  Create the maximum number of subscriptions allowed in the server.
Try to create one more.
ServiceResult = Bad_TooManySubscriptions.

Err-003

CTT CreateSubscription()  Specify the RequestedPublishingInterval as a NaN. ServiceResult is Good.
The revisedPublishingInterval contains the fastest rate supported by the server.

Err-004

CTT CreateSubscription()  Given a valid subscription and an amount of time equal to the subscription's expiration time passes.
When a service requiring the SubscriptionId is called, such as DeleteSubscription(). Then the service fails.
Call Publish().
Any and all service and operation level results are `good` until after the timeout has occurred, then a service result of `Bad_SubscriptionIdInvalid` is expected.
The Publish response should include a StatusChangeNotification with status `Bad_Timeout`.

Err-005

CTT ModifySubscription()  Modify an invalid (non-existent) subscription. ServiceResult = Bad_SubscriptionIdInvalid.

Err-006

CTT ModifySubscription()  Modify a subscription with subscriptionId=0. ServiceResult = Bad_SubscriptionIdInvalid.

Err-007

CTT ModifySubscription()  Modify publishing interval to a negative value. ServiceResult is Good.
The revisedPublishingInterval contains the fastest rate supported by the server.

Err-008

CTT ModifySubscription()  Specify the RquestedPublishingInterval as a NaN. ServiceResult is Good.
The revisedPublishingInterval contains the fastest rate supported by the server.

Err-009

CTT SetPublishingMode()  Enabled=False for an invalid subscription by specifying an invalid SubscriptionId. ServiceResult = Good.
results[0] = Bad_SubscriptionIdInvalid.

Err-010

CTT SetPublishingMode()  Enabled=True publishing for an invalid subscription. ServiceResult = Good.
results[0] = Bad_SubscriptionIdInvalid.

Err-011

CTT SetPublishingMode()  No subscriptions have been previously set-up in the session.
Call SetPublishingMode (Enabled=true) for a SubscriptionId of 1.
Service result = Bad_SubscriptionIdInvalid.

Err-012

CTT Publish()  Call Publish() when no subscriptions have been created. ServiceResult = Bad_NoSubscription.

Err-013

CTT Publish()  Acknowledge a sequence number with SubscriptionId equal to 0. ServiceResult = Good.
results[0] = Bad_SubscriptionIdInvalid.
The code Bad_SequenceNumberInvalid will be accepted as a Warning, along with a message indicating that the code is 'deprecated'.

Err-014

CTT Publish()  Acknowledge the same sequence number twice in the same Publish() call. Service result is Good.
Operation level result are:
[0] Good
[1] Bad_SequenceNumberUnknown.

Err-015

CTT Publish()  Acknowledge the same sequence number twice in 2 different Publish() calls. Publish #1 = service/operation level results are Good.
Publish #2 = service result is Good and operation level result is Bad_SequenceNumberUnknown.
The code Bad_SequenceNumberInvalid will be accepted as a Warning, along with a message indicating that the code is 'deprecated'.

Err-016

CTT Publish()  Acknowledge multiple invalid sequence numbers from an invalid subscription. ServiceResult = Good.
Results[*] are Bad_SubscriptionIdInvalid.

Err-017

CTT Publish()  Acknowledge multiple invalid sequence numbers from a valid subscription. ServiceResult = Good.
results[i] = Bad_SequenceNumberUnknown.

Err-018

CTT SetPublishingMode()  Call Republish() when no subscriptions have been created. ServiceResult = Bad_SubscriptionIdInvalid.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-019

CTT SetPublishingMode()  Republish() with SubscriptionId equal to 0. ServiceResult = Bad_SubscriptionIdInvalid.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-020

CTT SetPublishingMode()  Republish() using an invalid (MaxInt32) SubscriptionId. ServiceResult = Bad_SubscriptionIdInvalid.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-021

CTT SetPublishingMode()  Republish() with RetransmitSequenceNumber equal to 0. ServiceResult = Bad_MessageNotAvailable.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-022

CTT SetPublishingMode()  Republish() using an (MaxInt32) RetransmitSequenceNumber. ServiceResult = Bad_MessageNotAvailable.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-023

CTT SetPublishingMode()  Republish() using a SequenceNumber that had been previously acknowledged in a Publish() call. ServiceResult = Bad_MessageNotAvailable.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-024

CTT SetPublishingMode()  Republish() on a subscription that was previously deleted. ServiceResult = Bad_SubscriptionIdInvalid.

UA 1.03 Clarification: Republish() service is required; but behavior is optional and can return BadMessageNotAvailable

Err-025

CTT DeleteSubscriptions()  Call DeleteSubscriptions() and speicfy a SubscriptionId of an invalid subscription. ServiceResult = Good.
results[0] = Bad_SubscriptionIdInvalid.

Err-026

CTT DeleteSubscriptions()  Call DeleteSubscriptions() and specify a subscription using the SubscriptionId of a subscription that has already been deleted. ServiceResult = Good.
results[0] = Bad_SubscriptionIdInvalid.

Err-027

CTT DeleteSubscriptions()  Call DeleteSubscriptions() and specify multiple subscriptions using the SubscriptionIds of subscriptions that have already been deleted. ServiceResult = Good.
results[i] = Bad_SubscriptionIdInvalid.

Err-028

CTT DeleteSubscriptions()  Call DeleteSubscriptions() and specify an empty SubscriptionIds array. ServiceResult = Bad_NothingToDo.

Err-029

CTT DeleteSubscriptions()  Call DeleteSubscriptions() and specify more SubscriptionId`s than the server can handle.

Note: This test may not apply to most UA Servers, but may apply to resource-constrained UA Servers such as embedded.
ServiceResult = Bad_TooManyOperations.

Err-030

CTT Publish()  Create a MonitoredItem using a ByteStringArray node and a StringArray node while specifying a valid IndexRange as being outside of the bounds of the array.
Call Publish() and check the StatusCode of the item.
Step #
Action
Expected Result(s)

1

Add the items to the subscription via CreateMonitoredItems.

ServiceResult = Good. Operation level result is either Good, or Bad_IndexRangeNoData.

2

If CreateMonitoredItems is successful, then call Publish.

Service result is Good. DataChange notification received. StatusCode of the received item is BadIndexRangeNoData.

Err-031

CTT ModifySubscription()  UA 1.03  Create a subscription with default parameter.
Create an additional Session and try to modify the previous created subscription by specifying a longer PublishingInterval.
Verify that the client is still receiving DataChangeNotifications within the original PublishingInterval.
SeviceResult: BadSubscriptionIdInvalid
The parameter of the Subscription did not change.

Err-032

CTT SetPublishingMode()  UA 1.03  Call SetPublishingMode for a subscription which was already created in another session.
"SeviceResult: Good, OperationResult: BadSubscriptionIdInvalid
Publishing is still enabled in the subscription."