Functions: S¶

54 functions (76 overloads) on BasicRuntime.Functions starting with S.

A B C D E F G H I K L M N O P Q R S T U W X Z

SAVELIST¶

1 overload

static void Functions.SAVELIST(string saveName, int listNo)

Performs the savelist operation using the supplied saveName, listNo.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SAVELIST(...) directly (no instance required) when your code needs to perform the savelist operation using the supplied saveName, listNo.

How this member is tested

Act: Functions.SAVELIST("sample", 1)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SCREEN_CONTROL¶

1 overload

static DynamicArray Functions.SCREEN_CONTROL(DynamicArray x)

Performs the screen_control operation using the supplied x.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SCREEN_CONTROL(...) directly (no instance required) when your code needs to perform the screen_control operation using the supplied x.

How this member is tested

Act: var result = Functions.SCREEN_CONTROL(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SCREEN_POSITION¶

1 overload

static DynamicArray Functions.SCREEN_POSITION(DynamicArray x, DynamicArray y)

Performs the screen_position operation using the supplied x, y.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SCREEN_POSITION(...) directly (no instance required) when your code needs to perform the screen_position operation using the supplied x, y.

How this member is tested

Act: var result = Functions.SCREEN_POSITION(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SEEK¶

2 overloads

Overload 1

static DynamicArray Functions.SEEK(DynamicArray fileVariable, DynamicArray position)

Performs the seek operation using the supplied fileVariable, position.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SEEK(...) directly (no instance required) when your code needs to perform the seek operation using the supplied fileVariable, position.

How this member is tested

Act: var result = Functions.SEEK(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static DynamicArray Functions.SEEK(DynamicArray fileVariable, DynamicArray position, int relativeTo)

Performs the seek operation using the supplied fileVariable, position, relativeTo.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SEEK(...) directly (no instance required) when your code needs to perform the seek operation using the supplied fileVariable, position, relativeTo.

How this member is tested

Act: var result = Functions.SEEK(/* a valid DynamicArray value */, /* a valid DynamicArray value */, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SELECT¶

6 overloads · BASIC reference

Overload 1

static void Functions.SELECT(DynamicArray fileVariable, DynamicArray listVariable)

Performs the select operation using the supplied fileVariable, listVariable.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECT(...) directly (no instance required) when your code needs to perform the select operation using the supplied fileVariable, listVariable.

How this member is tested

Act: Functions.SELECT(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 2

static void Functions.SELECT(DynamicArray fileVariable, int listNumber, string withCriteria, bool omitRecord)

Performs the select operation using the supplied fileVariable, listNumber, withCriteria, omitRecord.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECT(...) directly (no instance required) when your code needs to perform the select operation using the supplied fileVariable, listNumber, withCriteria, omitRecord.

How this member is tested

Act: Functions.SELECT(/* a valid DynamicArray value */, 1, "sample", true)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 3

static void Functions.SELECT(DynamicArray fileVariable, int listNumber, Itypes itype)

Performs the select operation using the supplied fileVariable, listNumber, itype.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECT(...) directly (no instance required) when your code needs to perform the select operation using the supplied fileVariable, listNumber, itype.

How this member is tested

Act: Functions.SELECT(/* a valid DynamicArray value */, 1, /* a valid Itypes value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 4

static void Functions.SELECT(DynamicArray fileVariable, int listNumber, Itypes itype, int sampleCount)

Performs the select operation using the supplied fileVariable, listNumber, itype, sampleCount.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECT(...) directly (no instance required) when your code needs to perform the select operation using the supplied fileVariable, listNumber, itype, sampleCount.

How this member is tested

Act: Functions.SELECT(/* a valid DynamicArray value */, 1, /* a valid Itypes value */, 1)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 5

static void Functions.SELECT(DynamicArray fileVariable, int listNumber, string withCriteria)

Performs the select operation using the supplied fileVariable, listNumber, withCriteria.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECT(...) directly (no instance required) when your code needs to perform the select operation using the supplied fileVariable, listNumber, withCriteria.

How this member is tested

Act: Functions.SELECT(/* a valid DynamicArray value */, 1, "sample")
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 6

static void Functions.SELECT(DynamicArray fileVariable, int listNumber)

Performs the select operation using the supplied fileVariable, listNumber.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECT(...) directly (no instance required) when your code needs to perform the select operation using the supplied fileVariable, listNumber.

How this member is tested

Act: Functions.SELECT(/* a valid DynamicArray value */, 1)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SELECTE¶

1 overload

static void Functions.SELECTE(DynamicArray listVariable)

Performs the selecte operation using the supplied listVariable.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECTE(...) directly (no instance required) when your code needs to perform the selecte operation using the supplied listVariable.

How this member is tested

Act: Functions.SELECTE(/* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SELECTINDEX¶

2 overloads

Overload 1

static void Functions.SELECTINDEX(DynamicArray fileVariable, string fieldName, int listNumber)

Performs the selectindex operation using the supplied fileVariable, fieldName, listNumber.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECTINDEX(...) directly (no instance required) when your code needs to perform the selectindex operation using the supplied fileVariable, fieldName, listNumber.

How this member is tested

Act: Functions.SELECTINDEX(/* a valid DynamicArray value */, "sample", 1)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 2

static void Functions.SELECTINDEX(DynamicArray fileVariable, string fieldName, DynamicArray alternateKey, int listNumber)

Performs the selectindex operation using the supplied fileVariable, fieldName, alternateKey, listNumber.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECTINDEX(...) directly (no instance required) when your code needs to perform the selectindex operation using the supplied fileVariable, fieldName, alternateKey, listNumber.

How this member is tested

Act: Functions.SELECTINDEX(/* a valid DynamicArray value */, "sample", /* a valid DynamicArray value */, 1)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SELECTINFO¶

1 overload

static DynamicArray Functions.SELECTINFO(int listNumber, int controlCode)

Performs the selectinfo operation using the supplied listNumber, controlCode.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SELECTINFO(...) directly (no instance required) when your code needs to perform the selectinfo operation using the supplied listNumber, controlCode.

How this member is tested

Act: var result = Functions.SELECTINFO(1, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SELECTN¶

1 overload

static void Functions.SELECTN(DynamicArray fileVariable, DynamicArray listNumber)

Performs the selectn operation using the supplied fileVariable, listNumber.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SELECTN(...) directly (no instance required) when your code needs to perform the selectn operation using the supplied fileVariable, listNumber.

How this member is tested

Act: Functions.SELECTN(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SENTENCE¶

1 overload

static DynamicArray Functions.SENTENCE()

Performs the sentence operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SENTENCE(...) directly (no instance required) when your code needs to perform the sentence operation.

How this member is tested

Act: var result = Functions.SENTENCE()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SEQ¶

1 overload

static DynamicArray Functions.SEQ(DynamicArray value)

Performs the seq operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SEQ(...) directly (no instance required) when your code needs to perform the seq operation using the supplied value.

How this member is tested

Act: var result = Functions.SEQ(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SetAllowUnsafeHeaderParsing¶

1 overload

static bool Functions.SetAllowUnsafeHeaderParsing()

Sets allow unsafe header parsing.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.SetAllowUnsafeHeaderParsing(...) directly (no instance required) when your code needs to sets allow unsafe header parsing.

How this member is tested

Act: var result = Functions.SetAllowUnsafeHeaderParsing()
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the set allow unsafe header parsing check for the given input.

SETENV¶

1 overload

static DynamicArray Functions.SETENV(string variableName, DynamicArray value)

Performs the setenv operation using the supplied variableName, value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SETENV(...) directly (no instance required) when your code needs to perform the setenv operation using the supplied variableName, value.

How this member is tested

Act: var result = Functions.SETENV("sample", /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SETHTTPDEFAULT¶

1 overload

static DynamicArray Functions.SETHTTPDEFAULT(string option, string value)

Performs the sethttpdefault operation using the supplied option, value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SETHTTPDEFAULT(...) directly (no instance required) when your code needs to perform the sethttpdefault operation using the supplied option, value.

How this member is tested

Act: var result = Functions.SETHTTPDEFAULT("sample", "sample")
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

setHTTPDEFAULT¶

1 overload

static DynamicArray Functions.setHTTPDEFAULT(string option, out DynamicArray value)

Performs the set httpdefault operation using the supplied option, value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.setHTTPDEFAULT(...) directly (no instance required) when your code needs to perform the set httpdefault operation using the supplied option, value.

How this member is tested

Act: var result = Functions.setHTTPDEFAULT("sample", out /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SETINDEX¶

2 overloads

Overload 1

static void Functions.SETINDEX(DynamicArray indexName, DynamicArray rop, DynamicArray keyValue, DynamicArray fileVariable, bool bufferKeys, bool validateKeys)

Performs the setindex operation using the supplied indexName, rop, keyValue, fileVariable, bufferKeys, validateKeys.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SETINDEX(...) directly (no instance required) when your code needs to perform the setindex operation using the supplied indexName, rop, keyValue, fileVariable, bufferKeys, validateKeys.

How this member is tested

Act: Functions.SETINDEX(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, true, true)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 2

static void Functions.SETINDEX(DynamicArray indexName, DynamicArray rop, DynamicArray keyValue, DynamicArray idExpression, DynamicArray fileVariable, bool bufferKeys, bool validateKeys)

Performs the setindex operation using the supplied indexName, rop, keyValue, idExpression, fileVariable, bufferKeys, validateKeys.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SETINDEX(...) directly (no instance required) when your code needs to perform the setindex operation using the supplied indexName, rop, keyValue, idExpression, fileVariable, bufferKeys, validateKeys.

How this member is tested

Act: Functions.SETINDEX(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, true, true)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SETREM¶

1 overload

static void Functions.SETREM(int position, DynamicArray value)

Performs the setrem operation using the supplied position, value.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SETREM(...) directly (no instance required) when your code needs to perform the setrem operation using the supplied position, value.

How this member is tested

Act: Functions.SETREM(1, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SETREQUESTHEADER¶

1 overload

static DynamicArray Functions.SETREQUESTHEADER(DynamicArray requestHandle, string parameterName, string parameterValue)

Performs the setrequestheader operation using the supplied requestHandle, parameterName, parameterValue.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SETREQUESTHEADER(...) directly (no instance required) when your code needs to perform the setrequestheader operation using the supplied requestHandle, parameterName, parameterValue.

How this member is tested

Act: var result = Functions.SETREQUESTHEADER(/* a valid DynamicArray value */, "sample", "sample")
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SET_SQLDATABASE¶

1 overload

static DynamicArray Functions.SET_SQLDATABASE(string name)

Performs the set_sqldatabase operation using the supplied name.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SET_SQLDATABASE(...) directly (no instance required) when your code needs to perform the set_sqldatabase operation using the supplied name.

How this member is tested

Act: var result = Functions.SET_SQLDATABASE("sample")
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SFTPDEL¶

1 overload

static string Functions.SFTPDEL(string hostName, int port, string userName, string password, string sourcePath)

Performs the sftpdel operation using the supplied hostName, port, userName, password, sourcePath.


Kind	Method (static)
Returns	`string`
Use case	Call Functions.SFTPDEL(...) directly (no instance required) when your code needs to perform the sftpdel operation using the supplied hostName, port, userName, password, sourcePath.

How this member is tested

Act: var result = Functions.SFTPDEL("sample", 1, "sample", "sample", "sample")
Assert: result is non-null and matches the expected text.

Expected: Returns a string value; verify it is non-null and matches the expected content.

SFTPGET¶

1 overload

static string Functions.SFTPGET(string hostName, int port, string userName, string password, string sourcePath, string destinationPath)

Performs the sftpget operation using the supplied hostName, port, userName, password, sourcePath, destinationPath.


Kind	Method (static)
Returns	`string`
Use case	Call Functions.SFTPGET(...) directly (no instance required) when your code needs to perform the sftpget operation using the supplied hostName, port, userName, password, sourcePath, destinationPath.

How this member is tested

Act: var result = Functions.SFTPGET("sample", 1, "sample", "sample", "sample", "sample")
Assert: result is non-null and matches the expected text.

Expected: Returns a string value; verify it is non-null and matches the expected content.

SFTPPUT¶

1 overload

static string Functions.SFTPPUT(string hostName, int port, string userName, string password, string sourcePath, string destinationPath)

Performs the sftpput operation using the supplied hostName, port, userName, password, sourcePath, destinationPath.


Kind	Method (static)
Returns	`string`
Use case	Call Functions.SFTPPUT(...) directly (no instance required) when your code needs to perform the sftpput operation using the supplied hostName, port, userName, password, sourcePath, destinationPath.

How this member is tested

Act: var result = Functions.SFTPPUT("sample", 1, "sample", "sample", "sample", "sample")
Assert: result is non-null and matches the expected text.

Expected: Returns a string value; verify it is non-null and matches the expected content.

SLEEP¶

1 overload

static void Functions.SLEEP(DynamicArray value)

Performs the sleep operation using the supplied value.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SLEEP(...) directly (no instance required) when your code needs to perform the sleep operation using the supplied value.

How this member is tested

Act: Functions.SLEEP(/* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SOCKET_ESTABLISHED¶

1 overload

static DynamicArray Functions.SOCKET_ESTABLISHED(int port)

Performs the socket_established operation using the supplied port.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SOCKET_ESTABLISHED(...) directly (no instance required) when your code needs to perform the socket_established operation using the supplied port.

How this member is tested

Act: var result = Functions.SOCKET_ESTABLISHED(1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SOCKET_LISTENING¶

1 overload

static DynamicArray Functions.SOCKET_LISTENING(int port)

Performs the socket_listening operation using the supplied port.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SOCKET_LISTENING(...) directly (no instance required) when your code needs to perform the socket_listening operation using the supplied port.

How this member is tested

Act: var result = Functions.SOCKET_LISTENING(1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SORT¶

3 overloads

Overload 1

static DynamicArray Functions.SORT(DynamicArray value)

Performs the sort operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SORT(...) directly (no instance required) when your code needs to perform the sort operation using the supplied value.

How this member is tested

Act: var result = Functions.SORT(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static DynamicArray Functions.SORT(DynamicArray value, DynamicArray seperator)

Performs the sort operation using the supplied value, seperator.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SORT(...) directly (no instance required) when your code needs to perform the sort operation using the supplied value, seperator.

How this member is tested

Act: var result = Functions.SORT(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 3

static DynamicArray Functions.SORT(DynamicArray value, int attribute, string sortType)

Performs the sort operation using the supplied value, attribute, sortType.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SORT(...) directly (no instance required) when your code needs to perform the sort operation using the supplied value, attribute, sortType.

How this member is tested

Act: var result = Functions.SORT(/* a valid DynamicArray value */, 1, "sample")
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SOUNDEX¶

1 overload

static DynamicArray Functions.SOUNDEX(string phrase)

Performs the soundex operation using the supplied phrase.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SOUNDEX(...) directly (no instance required) when your code needs to perform the soundex operation using the supplied phrase.

How this member is tested

Act: var result = Functions.SOUNDEX("sample")
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SPACE¶

1 overload

static DynamicArray Functions.SPACE(DynamicArray length)

Performs the space operation using the supplied length.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SPACE(...) directly (no instance required) when your code needs to perform the space operation using the supplied length.

How this member is tested

Act: var result = Functions.SPACE(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SPACES¶

1 overload

static DynamicArray Functions.SPACES(DynamicArray lengths)

Performs the spaces operation using the supplied lengths.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SPACES(...) directly (no instance required) when your code needs to perform the spaces operation using the supplied lengths.

How this member is tested

Act: var result = Functions.SPACES(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SPLICE¶

1 overload

static DynamicArray Functions.SPLICE(DynamicArray array1, string substring, DynamicArray array2)

Performs the splice operation using the supplied array1, substring, array2.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SPLICE(...) directly (no instance required) when your code needs to perform the splice operation using the supplied array1, substring, array2.

How this member is tested

Act: var result = Functions.SPLICE(/* a valid DynamicArray value */, "sample", /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SQLEXECUTE¶

3 overloads

Overload 1

static DynamicArray Functions.SQLEXECUTE(DynamicArray sntc, bool executeScalar, int timeOut)

Performs the sqlexecute operation using the supplied sntc, executeScalar, timeOut.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQLEXECUTE(...) directly (no instance required) when your code needs to perform the sqlexecute operation using the supplied sntc, executeScalar, timeOut.

How this member is tested

Act: var result = Functions.SQLEXECUTE(/* a valid DynamicArray value */, true, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static DynamicArray Functions.SQLEXECUTE(DynamicArray sntc)

Performs the sqlexecute operation using the supplied sntc.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQLEXECUTE(...) directly (no instance required) when your code needs to perform the sqlexecute operation using the supplied sntc.

How this member is tested

Act: var result = Functions.SQLEXECUTE(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 3

static DynamicArray Functions.SQLEXECUTE(DynamicArray sntc, int timeOut)

Performs the sqlexecute operation using the supplied sntc, timeOut.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQLEXECUTE(...) directly (no instance required) when your code needs to perform the sqlexecute operation using the supplied sntc, timeOut.

How this member is tested

Act: var result = Functions.SQLEXECUTE(/* a valid DynamicArray value */, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SQLEXECUTEDATA¶

2 overloads

Overload 1

static DynamicArray Functions.SQLEXECUTEDATA(DynamicArray sntc)

Performs the sqlexecutedata operation using the supplied sntc.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQLEXECUTEDATA(...) directly (no instance required) when your code needs to perform the sqlexecutedata operation using the supplied sntc.

How this member is tested

Act: var result = Functions.SQLEXECUTEDATA(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static DynamicArray Functions.SQLEXECUTEDATA(DynamicArray sntc, int timeOut)

Performs the sqlexecutedata operation using the supplied sntc, timeOut.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQLEXECUTEDATA(...) directly (no instance required) when your code needs to perform the sqlexecutedata operation using the supplied sntc, timeOut.

How this member is tested

Act: var result = Functions.SQLEXECUTEDATA(/* a valid DynamicArray value */, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SQLNATIVE¶

1 overload

static Hashtable Functions.SQLNATIVE(DynamicArray fileVariable)

Performs the sqlnative operation using the supplied fileVariable.


Kind	Method (static)
Returns	`Hashtable`
Use case	Call Functions.SQLNATIVE(...) directly (no instance required) when your code needs to perform the sqlnative operation using the supplied fileVariable.

How this member is tested

Act: var result = Functions.SQLNATIVE(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of Hashtable; verify its properties reflect the expected resulting state.

SQRT¶

1 overload

static DynamicArray Functions.SQRT(DynamicArray value)

Performs the sqrt operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQRT(...) directly (no instance required) when your code needs to perform the sqrt operation using the supplied value.

How this member is tested

Act: var result = Functions.SQRT(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SQUOTE¶

1 overload · BASIC reference

static DynamicArray Functions.SQUOTE(DynamicArray value)

Performs the squote operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SQUOTE(...) directly (no instance required) when your code needs to perform the squote operation using the supplied value.

How this member is tested

Act: var result = Functions.SQUOTE(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SSELECT¶

2 overloads

Overload 1

static void Functions.SSELECT(DynamicArray fileVariable, DynamicArray listVariable)

Performs the sselect operation using the supplied fileVariable, listVariable.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SSELECT(...) directly (no instance required) when your code needs to perform the sselect operation using the supplied fileVariable, listVariable.

How this member is tested

Act: Functions.SSELECT(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 2

static void Functions.SSELECT(DynamicArray fileVariable, int listNumber)

Performs the sselect operation using the supplied fileVariable, listNumber.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SSELECT(...) directly (no instance required) when your code needs to perform the sselect operation using the supplied fileVariable, listNumber.

How this member is tested

Act: Functions.SSELECT(/* a valid DynamicArray value */, 1)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

STACK_POP¶

1 overload

static DynamicArray Functions.STACK_POP(DynamicArray stackVariable)

Performs the stack_pop operation using the supplied stackVariable.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.STACK_POP(...) directly (no instance required) when your code needs to perform the stack_pop operation using the supplied stackVariable.

How this member is tested

Act: var result = Functions.STACK_POP(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

STACK_PUSH¶

1 overload

static bool Functions.STACK_PUSH(DynamicArray stackVariable, DynamicArray value)

Performs the stack_push operation using the supplied stackVariable, value.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.STACK_PUSH(...) directly (no instance required) when your code needs to perform the stack_push operation using the supplied stackVariable, value.

How this member is tested

Act: var result = Functions.STACK_PUSH(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the stack_push check for the given input.

STATUS¶

2 overloads

Overload 1

static DynamicArray Functions.STATUS()

Performs the status operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.STATUS(...) directly (no instance required) when your code needs to perform the status operation.

How this member is tested

Act: var result = Functions.STATUS()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static bool Functions.STATUS(DynamicArray fileVariable, ref DynamicArray statusVariable)

Performs the status operation using the supplied fileVariable, statusVariable.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.STATUS(...) directly (no instance required) when your code needs to perform the status operation using the supplied fileVariable, statusVariable.

How this member is tested

Act: var result = Functions.STATUS(/* a valid DynamicArray value */, ref /* a valid DynamicArray value */)
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the status check for the given input.

STOP¶

4 overloads · BASIC reference

Overload 1

static DynamicArray Functions.STOP()

Performs the stop operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.STOP(...) directly (no instance required) when your code needs to perform the stop operation.

How this member is tested

Act: var result = Functions.STOP()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static void Functions.STOP(DynamicArray[] msgParams)

Performs the stop operation using the supplied msgParams.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOP(...) directly (no instance required) when your code needs to perform the stop operation using the supplied msgParams.

How this member is tested

Act: Functions.STOP(/* a populated collection */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 3

static void Functions.STOP(DynamicArray errorMessage)

Performs the stop operation using the supplied errorMessage.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOP(...) directly (no instance required) when your code needs to perform the stop operation using the supplied errorMessage.

How this member is tested

Act: Functions.STOP(/* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 4

static void Functions.STOP(DynamicArray errorNumber, DynamicArray errorMessage)

Performs the stop operation using the supplied errorNumber, errorMessage.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOP(...) directly (no instance required) when your code needs to perform the stop operation using the supplied errorNumber, errorMessage.

How this member is tested

Act: Functions.STOP(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

STOPE¶

1 overload

static void Functions.STOPE(DynamicArray[] msgParams)

Performs the stope operation using the supplied msgParams.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOPE(...) directly (no instance required) when your code needs to perform the stope operation using the supplied msgParams.

How this member is tested

Act: Functions.STOPE(/* a populated collection */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

STOPM¶

3 overloads

Overload 1

static void Functions.STOPM()

Performs the stopm operation.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOPM(...) directly (no instance required) when your code needs to perform the stopm operation.

How this member is tested

Act: Functions.STOPM()
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 2

static void Functions.STOPM(DynamicArray errorMessage)

Performs the stopm operation using the supplied errorMessage.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOPM(...) directly (no instance required) when your code needs to perform the stopm operation using the supplied errorMessage.

How this member is tested

Act: Functions.STOPM(/* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

Overload 3

static void Functions.STOPM(DynamicArray errorNumber, DynamicArray errorMessage)

Performs the stopm operation using the supplied errorNumber, errorMessage.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.STOPM(...) directly (no instance required) when your code needs to perform the stopm operation using the supplied errorNumber, errorMessage.

How this member is tested

Act: Functions.STOPM(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

STOREDPROCEDURE¶

1 overload

static DynamicArray Functions.STOREDPROCEDURE(string accountName, string storedProcedure, DynamicArray[] paramters)

Performs the storedprocedure operation using the supplied accountName, storedProcedure, paramters.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.STOREDPROCEDURE(...) directly (no instance required) when your code needs to perform the storedprocedure operation using the supplied accountName, storedProcedure, paramters.

How this member is tested

Act: var result = Functions.STOREDPROCEDURE("sample", "sample", /* a populated collection */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

STR¶

1 overload

static DynamicArray Functions.STR(DynamicArray fillString, int fillLength)

Performs the str operation using the supplied fillString, fillLength.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.STR(...) directly (no instance required) when your code needs to perform the str operation using the supplied fillString, fillLength.

How this member is tested

Act: var result = Functions.STR(/* a valid DynamicArray value */, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

StringToByteArray¶

1 overload

static byte[] Functions.StringToByteArray(string hex)

Performs the string to byte array operation using the supplied hex.


Kind	Method (static)
Returns	`byte[]`
Use case	Call Functions.StringToByteArray(...) directly (no instance required) when your code needs to perform the string to byte array operation using the supplied hex.

How this member is tested

Act: var result = Functions.StringToByteArray("sample")
Assert: result contains the expected elements in the expected order.

Expected: Returns a collection (byte[]); verify its count and contents match the expected elements.

SUBMITREQUEST¶

1 overload

static DynamicArray Functions.SUBMITREQUEST(DynamicArray requestHandle, int timeOut, string postData, ref DynamicArray responseHeadera, ref DynamicArray responseData, ref DynamicArray httpStatus)

Performs the submitrequest operation using the supplied requestHandle, timeOut, postData, responseHeadera, responseData, httpStatus.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SUBMITREQUEST(...) directly (no instance required) when your code needs to perform the submitrequest operation using the supplied requestHandle, timeOut, postData, responseHeadera, responseData, httpStatus.

How this member is tested

Act: var result = Functions.SUBMITREQUEST(/* a valid DynamicArray value */, 1, "sample", ref /* a valid DynamicArray value */, ref /* a valid DynamicArray value */, ref /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SUBR¶

1 overload

static DynamicArray Functions.SUBR(string subName, object[] args)

Performs the subr operation using the supplied subName, args.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SUBR(...) directly (no instance required) when your code needs to perform the subr operation using the supplied subName, args.

How this member is tested

Act: var result = Functions.SUBR("sample", /* a populated collection */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SUBS¶

1 overload

static DynamicArray Functions.SUBS(DynamicArray array1, DynamicArray array2)

Performs the subs operation using the supplied array1, array2.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SUBS(...) directly (no instance required) when your code needs to perform the subs operation using the supplied array1, array2.

How this member is tested

Act: var result = Functions.SUBS(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SUBSTRINGS¶

1 overload

static DynamicArray Functions.SUBSTRINGS(string value, int start, int length)

Performs the substrings operation using the supplied value, start, length.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SUBSTRINGS(...) directly (no instance required) when your code needs to perform the substrings operation using the supplied value, start, length.

How this member is tested

Act: var result = Functions.SUBSTRINGS("sample", 1, 1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SUM¶

1 overload

static DynamicArray Functions.SUM(DynamicArray value)

Performs the sum operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SUM(...) directly (no instance required) when your code needs to perform the sum operation using the supplied value.

How this member is tested

Act: var result = Functions.SUM(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SUMMATION¶

1 overload

static DynamicArray Functions.SUMMATION(DynamicArray value)

Performs the summation operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SUMMATION(...) directly (no instance required) when your code needs to perform the summation operation using the supplied value.

How this member is tested

Act: var result = Functions.SUMMATION(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SWAP¶

3 overloads

Overload 1

static DynamicArray Functions.SWAP(DynamicArray value, DynamicArray searchString, DynamicArray subString)

Performs the swap operation using the supplied value, searchString, subString.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SWAP(...) directly (no instance required) when your code needs to perform the swap operation using the supplied value, searchString, subString.

How this member is tested

Act: var result = Functions.SWAP(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 2

static DynamicArray Functions.SWAP(DynamicArray value, DynamicArray searchString, DynamicArray subString, DynamicArray noToChange)

Performs the swap operation using the supplied value, searchString, subString, noToChange.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SWAP(...) directly (no instance required) when your code needs to perform the swap operation using the supplied value, searchString, subString, noToChange.

How this member is tested

Act: var result = Functions.SWAP(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

Overload 3

static DynamicArray Functions.SWAP(DynamicArray value, DynamicArray searchString, DynamicArray subString, DynamicArray noToChange, DynamicArray beginAt)

Performs the swap operation using the supplied value, searchString, subString, noToChange, beginAt.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SWAP(...) directly (no instance required) when your code needs to perform the swap operation using the supplied value, searchString, subString, noToChange, beginAt.

How this member is tested

Act: var result = Functions.SWAP(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

SWAPSTR¶

1 overload

static void Functions.SWAPSTR(DynamicArray value, DynamicArray searchString, DynamicArray subString)

Performs the swapstr operation using the supplied value, searchString, subString.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.SWAPSTR(...) directly (no instance required) when your code needs to perform the swapstr operation using the supplied value, searchString, subString.

How this member is tested

Act: Functions.SWAPSTR(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

SYSTEM¶

1 overload

static DynamicArray Functions.SYSTEM(int item)

Performs the system operation using the supplied item.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.SYSTEM(...) directly (no instance required) when your code needs to perform the system operation using the supplied item.

How this member is tested

Act: var result = Functions.SYSTEM(1)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.