Modified script will recognize if an array is defined in the CTT settings and/or the MaxArrayLength is available in the address space.
Probably not the best modification solution, but good enough to show an possible solution.

/ Test prepared by Nathan Pocock: nathan.pocock@opcfoundation.org
Description: MaxArrayLength matches reality /

function test() {
// read the value of the setting
var item = MonitoredItem.fromNodeIds( new UaNodeId( Identifier.Server_ServerCapabilities_MaxArrayLength ) )[0];

if( !ReadHelper.Execute( { NodesToRead: item, OperationResults: [ new ExpectedAndAcceptedResults( [ StatusCode.Good, StatusCode.BadNodeIdUnknown ] ) ] } ) ) return( false );
var realValue = item.Value.Value.toUInt32();
/***** modification begin ******/
// checkout the arrays that are configured and Read their values. We'll compare their lengths and see if any of them
// exceed the value.
var items = MonitoredItem.fromSettings( Settings.ServerTest.NodeIds.Static.AllProfiles.Arrays.Settings );

// check if the node MaxArrayLength is available
if( item.Value.StatusCode.isBad())
{
    if( items == null || items.length < 1 )
    {
        addSkipped( "No Arrays configured in Settings. See settings > ServerTest > NodeIds > Static > All Profiles > Arrays" );
        return( false );
    }
    else
    {
        addWarning( "ServerCapabilitiesType -> MaxArrayLength ==>[NOT FOUND], where as some array are specified. It is recommended to support this server capability. " );
    }
}
// only continue if the value is not 0
if( realValue == 0 ) {
    addWarning( "MaxArrayLength = 0, which means 'no limit'. Please verify if this is accurate. OperationLimit will be limited to this value." );
    realValue = MAX_ALLOWED_SIZE;
}
else if( realValue > MAX_ALLOWED_SIZE ) { 
    addWarning("MaxArrayLength is set to a value above " + MAX_ALLOWED_SIZE + ". OperationLimit will be limited to this value." );
    realValue = MAX_ALLOWED_SIZE;
}
/***** modification end ******/

if( !ReadHelper.Execute( { NodesToRead: items } ) ) return( false );
for( var i=0; i<items.length; i++ ) {
    if( realValue < items[i].Value.Value.getArraySize() ) addError( "Item " + items[i].NodeSetting + " has a value where the array size is greater than what is advertized as the max size (MaxArrayLength=" + realValue + ")" );
    items[i].InitialValue = items[i].Value.Value.clone(); // cache the value so we can write it back later
}

// now to see if we can re-write the array and increase the size
for( var i=0; i<items.length; i++ ) items[i].AttributeId = Attribute.ArrayDimensions;
ReadHelper.Execute( { NodesToRead: items } );
var writableNodes = [];
for( var i=0; i<items.length; i++ ) {
    if( items[i].Value.Value.toUInt32Array()[0] == 0 ) writableNodes.push( items[i] );
}
if( writableNodes.length === 0 ) return( false );

// read the values again...
for( var i=0; i<writableNodes.length; i++ ) writableNodes[i].AttributeId = Attribute.Value;                                // set the attribute back to Value 
ReadHelper.Execute( { NodesToRead: writableNodes } );

// overwrite the values by filling the array
for( var i=0; i<writableNodes.length; i++ ) UaVariant.Fill( { Variant: writableNodes[i].Value.Value, Length: realValue } );  // set the new value
if( WriteHelper.Execute( { NodesToWrite: writableNodes, ReadVerification: false } ) ) {
    // now to revert all values back to their initial value....
    for( var i=0; i<writableNodes.length; i++ ) writableNodes[i].Value.Value = writableNodes[i].InitialValue.clone();
    WriteHelper.Execute( { NodesToWrite: writableNodes, ReadVerification: false } );
}
return( true );

}

Test.Execute( { Procedure: test } );