Examples with Range org.apache.commons.lang3.Range used on opensource projects

Example 26 with Range

use of org.apache.commons.lang3.Range in project cassandra by apache.

the class RangeStreamer method calculateRangesToFetchWithPreferredEndpoints.

/**
 * Get a map of all ranges and the source that will be cleaned up once this bootstrapped node is added for the given ranges.
 * For each range, the list should only contain a single source. This allows us to consistently migrate data without violating
 * consistency.
 */
public static EndpointsByReplica calculateRangesToFetchWithPreferredEndpoints(BiFunction<InetAddressAndPort, EndpointsForRange, EndpointsForRange> snitchGetSortedListByProximity, AbstractReplicationStrategy strat, ReplicaCollection<?> fetchRanges, boolean useStrictConsistency, TokenMetadata tmdBefore, TokenMetadata tmdAfter, String keyspace, Collection<SourceFilter> sourceFilters) {
    EndpointsByRange rangeAddresses = strat.getRangeAddresses(tmdBefore);
    InetAddressAndPort localAddress = FBUtilities.getBroadcastAddressAndPort();
    logger.debug("Keyspace: {}", keyspace);
    logger.debug("To fetch RN: {}", fetchRanges);
    logger.debug("Fetch ranges: {}", rangeAddresses);
    Predicate<Replica> testSourceFilters = and(sourceFilters);
    Function<EndpointsForRange, EndpointsForRange> sorted = endpoints -> snitchGetSortedListByProximity.apply(localAddress, endpoints);
    // This list of replicas is just candidates. With strict consistency it's going to be a narrow list.
    EndpointsByReplica.Builder rangesToFetchWithPreferredEndpoints = new EndpointsByReplica.Builder();
    for (Replica toFetch : fetchRanges) {
        // Replica that is sufficient to provide the data we need
        // With strict consistency and transient replication we may end up with multiple types
        // so this isn't used with strict consistency
        Predicate<Replica> isSufficient = r -> toFetch.isTransient() || r.isFull();
        logger.debug("To fetch {}", toFetch);
        for (Range<Token> range : rangeAddresses.keySet()) {
            if (!range.contains(toFetch.range()))
                continue;
            final EndpointsForRange oldEndpoints = sorted.apply(rangeAddresses.get(range));
            // Ultimately we populate this with whatever is going to be fetched from to satisfy toFetch
            // It could be multiple endpoints and we must fetch from all of them if they are there
            // With transient replication and strict consistency this is to get the full data from a full replica and
            // transient data from the transient replica losing data
            EndpointsForRange sources;
            // Due to CASSANDRA-5953 we can have a higher RF than we have endpoints.
            // So we need to be careful to only be strict when endpoints == RF
            boolean isStrictConsistencyApplicable = useStrictConsistency && (oldEndpoints.size() == strat.getReplicationFactor().allReplicas);
            if (isStrictConsistencyApplicable) {
                EndpointsForRange strictEndpoints;
                // Start with two sets of who replicates the range before and who replicates it after
                EndpointsForRange newEndpoints = strat.calculateNaturalReplicas(toFetch.range().right, tmdAfter);
                logger.debug("Old endpoints {}", oldEndpoints);
                logger.debug("New endpoints {}", newEndpoints);
                // Remove new endpoints from old endpoints based on address
                strictEndpoints = oldEndpoints.without(newEndpoints.endpoints());
                if (strictEndpoints.size() > 1)
                    throw new AssertionError("Expected <= 1 endpoint but found " + strictEndpoints);
                // required for strict consistency
                if (!all(strictEndpoints, testSourceFilters))
                    throw new IllegalStateException("Necessary replicas for strict consistency were removed by source filters: " + buildErrorMessage(sourceFilters, strictEndpoints));
                // So it's an error if we don't find what we need.
                if (strictEndpoints.isEmpty() && toFetch.isTransient())
                    throw new AssertionError("If there are no endpoints to fetch from then we must be transitioning from transient to full for range " + toFetch);
                if (!any(strictEndpoints, isSufficient)) {
                    // need an additional replica; include all our filters, to ensure we include a matching node
                    Optional<Replica> fullReplica = Iterables.<Replica>tryFind(oldEndpoints, and(isSufficient, testSourceFilters)).toJavaUtil();
                    if (fullReplica.isPresent())
                        strictEndpoints = Endpoints.concat(strictEndpoints, EndpointsForRange.of(fullReplica.get()));
                    else
                        throw new IllegalStateException("Couldn't find any matching sufficient replica out of " + buildErrorMessage(sourceFilters, oldEndpoints));
                }
                sources = strictEndpoints;
            } else {
                // Without strict consistency we have given up on correctness so no point in fetching from
                // a random full + transient replica since it's also likely to lose data
                // Also apply testSourceFilters that were given to us so we can safely select a single source
                sources = sorted.apply(oldEndpoints.filter(and(isSufficient, testSourceFilters)));
                // Limit it to just the first possible source, we don't need more than one and downstream
                // will fetch from every source we supply
                sources = sources.size() > 0 ? sources.subList(0, 1) : sources;
            }
            // storing range and preferred endpoint set
            rangesToFetchWithPreferredEndpoints.putAll(toFetch, sources, Conflict.NONE);
            logger.debug("Endpoints to fetch for {} are {}", toFetch, sources);
        }
        EndpointsForRange addressList = rangesToFetchWithPreferredEndpoints.getIfPresent(toFetch);
        if (addressList == null)
            throw new IllegalStateException("Failed to find endpoints to fetch " + toFetch);
        /*
              * When we move forwards (shrink our bucket) we are the one losing a range and no one else loses
              * from that action (we also don't gain). When we move backwards there are two people losing a range. One is a full replica
              * and the other is a transient replica. So we must need fetch from two places in that case for the full range we gain.
              * For a transient range we only need to fetch from one.
              */
        if (useStrictConsistency && addressList.size() > 1 && (addressList.filter(Replica::isFull).size() > 1 || addressList.filter(Replica::isTransient).size() > 1))
            throw new IllegalStateException(String.format("Multiple strict sources found for %s, sources: %s", toFetch, addressList));
        // We must have enough stuff to fetch from
        if (!any(addressList, isSufficient)) {
            if (strat.getReplicationFactor().allReplicas == 1) {
                if (useStrictConsistency) {
                    logger.warn("A node required to move the data consistently is down");
                    throw new IllegalStateException("Unable to find sufficient sources for streaming range " + toFetch + " in keyspace " + keyspace + " with RF=1. " + "Ensure this keyspace contains replicas in the source datacenter.");
                } else
                    logger.warn("Unable to find sufficient sources for streaming range {} in keyspace {} with RF=1. " + "Keyspace might be missing data.", toFetch, keyspace);
            } else {
                if (useStrictConsistency)
                    logger.warn("A node required to move the data consistently is down");
                throw new IllegalStateException("Unable to find sufficient sources for streaming range " + toFetch + " in keyspace " + keyspace);
            }
        }
    }
    return rangesToFetchWithPreferredEndpoints.build();
}

Example 27 with Range

use of org.apache.commons.lang3.Range in project neo4j by neo4j.

the class KeySearchTest method shouldSearchAndFindOnRandomData.

@Test
void shouldSearchAndFindOnRandomData() throws IOException {
    // GIVEN a leaf node with random, although sorted (as of course it must be to binary-search), data
    node.initializeLeaf(cursor, STABLE_GENERATION, UNSTABLE_GENERATION);
    List<MutableLong> keys = new ArrayList<>();
    int currentKey = random.nextInt(10_000);
    MutableLong key = layout.newKey();
    int keyCount = 0;
    while (true) {
        MutableLong expectedKey = layout.newKey();
        key.setValue(currentKey);
        if (node.leafOverflow(cursor, keyCount, key, dummyValue) != NO) {
            break;
        }
        layout.copyKey(key, expectedKey);
        keys.add(keyCount, expectedKey);
        node.insertKeyValueAt(cursor, key, dummyValue, keyCount, keyCount, STABLE_GENERATION, UNSTABLE_GENERATION, NULL);
        currentKey += random.nextInt(100) + 10;
        keyCount++;
    }
    TreeNode.setKeyCount(cursor, keyCount);
    // WHEN searching for random keys within that general range
    MutableLong searchKey = layout.newKey();
    for (int i = 0; i < 1_000; i++) {
        searchKey.setValue(random.nextInt(currentKey + 10));
        int searchResult = search(cursor, node, LEAF, searchKey, readKey, keyCount, NULL);
        // THEN position should be as expected
        boolean exists = contains(keys, searchKey, layout);
        int position = KeySearch.positionOf(searchResult);
        assertEquals(exists, KeySearch.isHit(searchResult));
        if (layout.compare(searchKey, keys.get(0)) <= 0) {
            // Our search key was lower than any of our keys, expect 0
            assertEquals(0, position);
        } else {
            // step backwards through our expected keys and see where it should fit, assert that fact
            boolean found = false;
            for (int j = keyCount - 1; j >= 0; j--) {
                if (layout.compare(searchKey, keys.get(j)) > 0) {
                    assertEquals(j + 1, position);
                    found = true;
                    break;
                }
            }
            assertTrue(found);
        }
    }
}

Example 28 with Range

use of org.apache.commons.lang3.Range in project gerrit by GerritCodeReview.

the class HttpPluginServlet method sendAutoIndex.

private void sendAutoIndex(PluginContentScanner scanner, final String prefix, final String pluginName, PluginResourceKey cacheKey, HttpServletResponse res, long lastModifiedTime) throws IOException {
    List<PluginEntry> cmds = new ArrayList<>();
    List<PluginEntry> servlets = new ArrayList<>();
    List<PluginEntry> restApis = new ArrayList<>();
    List<PluginEntry> docs = new ArrayList<>();
    PluginEntry about = null;
    PluginEntry toc = null;
    Predicate<PluginEntry> filter = entry -> {
        String name = entry.getName();
        Optional<Long> size = entry.getSize();
        if (name.startsWith(prefix) && (name.endsWith(".md") || name.endsWith(".html")) && size.isPresent()) {
            if (size.get() <= 0 || size.get() > SMALL_RESOURCE) {
                logger.atWarning().log("Plugin %s: %s omitted from document index. " + "Size %d out of range (0,%d).", pluginName, name.substring(prefix.length()), size.get(), SMALL_RESOURCE);
                return false;
            }
            return true;
        }
        return false;
    };
    List<PluginEntry> entries = scanner.entries().filter(filter).collect(toList());
    for (PluginEntry entry : entries) {
        String name = entry.getName().substring(prefix.length());
        if (name.startsWith("cmd-")) {
            cmds.add(entry);
        } else if (name.startsWith("servlet-")) {
            servlets.add(entry);
        } else if (name.startsWith("rest-api-")) {
            restApis.add(entry);
        } else if (name.startsWith("about.")) {
            if (about == null) {
                about = entry;
            } else {
                logger.atWarning().log("Plugin %s: Multiple 'about' documents found; using %s", pluginName, about.getName().substring(prefix.length()));
            }
        } else if (name.startsWith("toc.")) {
            if (toc == null) {
                toc = entry;
            } else {
                logger.atWarning().log("Plugin %s: Multiple 'toc' documents found; using %s", pluginName, toc.getName().substring(prefix.length()));
            }
        } else {
            docs.add(entry);
        }
    }
    cmds.sort(PluginEntry.COMPARATOR_BY_NAME);
    docs.sort(PluginEntry.COMPARATOR_BY_NAME);
    StringBuilder md = new StringBuilder();
    md.append(String.format("# Plugin %s #\n", pluginName));
    md.append("\n");
    appendPluginInfoTable(md, scanner.getManifest().getMainAttributes());
    if (about != null) {
        appendPageAsSection(scanner, about, "About", md);
    }
    if (toc != null) {
        appendPageAsSection(scanner, toc, "Documentaion", md);
    } else {
        appendEntriesSection(scanner, docs, "Documentation", md, prefix, 0);
        appendEntriesSection(scanner, servlets, "Servlets", md, prefix, "servlet-".length());
        appendEntriesSection(scanner, restApis, "REST APIs", md, prefix, "rest-api-".length());
        appendEntriesSection(scanner, cmds, "Commands", md, prefix, "cmd-".length());
    }
    sendMarkdownAsHtml(md.toString(), pluginName, cacheKey, res, lastModifiedTime);
}

Example 29 with Range

use of org.apache.commons.lang3.Range in project hbase by apache.

the class BackupAdminImpl method checkIfValidForMerge.

/**
 * Verifies that backup images are valid for merge.
 *
 * <ul>
 * <li>All backups MUST be in the same destination
 * <li>No FULL backups are allowed - only INCREMENTAL
 * <li>All backups must be in COMPLETE state
 * <li>No holes in backup list are allowed
 * </ul>
 * <p>
 * @param backupIds list of backup ids
 * @param table backup system table
 * @throws IOException if the backup image is not valid for merge
 */
private void checkIfValidForMerge(String[] backupIds, BackupSystemTable table) throws IOException {
    String backupRoot = null;
    final Set<TableName> allTables = new HashSet<>();
    final Set<String> allBackups = new HashSet<>();
    long minTime = Long.MAX_VALUE, maxTime = Long.MIN_VALUE;
    for (String backupId : backupIds) {
        BackupInfo bInfo = table.readBackupInfo(backupId);
        if (bInfo == null) {
            String msg = "Backup session " + backupId + " not found";
            throw new IOException(msg);
        }
        if (backupRoot == null) {
            backupRoot = bInfo.getBackupRootDir();
        } else if (!bInfo.getBackupRootDir().equals(backupRoot)) {
            throw new IOException("Found different backup destinations in a list of a backup sessions " + "\n1. " + backupRoot + "\n" + "2. " + bInfo.getBackupRootDir());
        }
        if (bInfo.getType() == BackupType.FULL) {
            throw new IOException("FULL backup image can not be merged for: \n" + bInfo);
        }
        if (bInfo.getState() != BackupState.COMPLETE) {
            throw new IOException("Backup image " + backupId + " can not be merged becuase of its state: " + bInfo.getState());
        }
        allBackups.add(backupId);
        allTables.addAll(bInfo.getTableNames());
        long time = bInfo.getStartTs();
        if (time < minTime) {
            minTime = time;
        }
        if (time > maxTime) {
            maxTime = time;
        }
    }
    final long startRangeTime = minTime;
    final long endRangeTime = maxTime;
    final String backupDest = backupRoot;
    // Check we have no 'holes' in backup id list
    // Filter 1 : backupRoot
    // Filter 2 : time range filter
    // Filter 3 : table filter
    BackupInfo.Filter destinationFilter = info -> info.getBackupRootDir().equals(backupDest);
    BackupInfo.Filter timeRangeFilter = info -> {
        long time = info.getStartTs();
        return time >= startRangeTime && time <= endRangeTime;
    };
    BackupInfo.Filter tableFilter = info -> {
        List<TableName> tables = info.getTableNames();
        return !Collections.disjoint(allTables, tables);
    };
    BackupInfo.Filter typeFilter = info -> info.getType() == BackupType.INCREMENTAL;
    BackupInfo.Filter stateFilter = info -> info.getState() == BackupState.COMPLETE;
    List<BackupInfo> allInfos = table.getBackupHistory(-1, destinationFilter, timeRangeFilter, tableFilter, typeFilter, stateFilter);
    if (allInfos.size() != allBackups.size()) {
        // Yes we have at least one  hole in backup image sequence
        List<String> missingIds = new ArrayList<>();
        for (BackupInfo info : allInfos) {
            if (allBackups.contains(info.getBackupId())) {
                continue;
            }
            missingIds.add(info.getBackupId());
        }
        String errMsg = "Sequence of backup ids has 'holes'. The following backup images must be added:" + org.apache.hadoop.util.StringUtils.join(",", missingIds);
        throw new IOException(errMsg);
    }
}

Example 30 with Range

use of org.apache.commons.lang3.Range in project Asqatasun by Asqatasun.

the class Rgaa40Rule110204Test method setProcess.

@Override
protected void setProcess() {
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-01---------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-01");
    checkResultIsPreQualified(processResult, 2, 2);
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.INPUT_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-for-input-without-type-attribute"));
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.INPUT_ELEMENT, 2, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-for-input-with-type-equal-to-text"));
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-02---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-02");
    checkResultIsPreQualified(processResult, 17, 17);
    HashMap<Integer, String> mapTypeAttribute = new HashMap<Integer, String>();
    mapTypeAttribute.put(1, "checkbox");
    mapTypeAttribute.put(2, "color");
    mapTypeAttribute.put(3, "date");
    mapTypeAttribute.put(4, "datetime-local");
    mapTypeAttribute.put(5, "email");
    mapTypeAttribute.put(6, "file");
    mapTypeAttribute.put(7, "month");
    mapTypeAttribute.put(8, "number");
    mapTypeAttribute.put(9, "password");
    mapTypeAttribute.put(10, "radio");
    mapTypeAttribute.put(11, "range");
    mapTypeAttribute.put(12, "search");
    mapTypeAttribute.put(13, "tel");
    mapTypeAttribute.put(14, "text");
    mapTypeAttribute.put(15, "time");
    mapTypeAttribute.put(16, "url");
    mapTypeAttribute.put(17, "week");
    for (Map.Entry item : mapTypeAttribute.entrySet()) {
        int position = ((int) item.getKey());
        checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.INPUT_ELEMENT, position, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-for-input-with-type-equal-to-" + item.getValue()));
    }
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-03---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-03");
    checkResultIsPreQualified(processResult, 1, 1);
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.TEXTAREA_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-TEXTAREA"));
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-04---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-04");
    checkResultIsPreQualified(processResult, 3, 3);
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.SELECT_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-SELECT"));
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.OPTGROUP_ELEMENT, 2, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-OPTGROUP"));
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.OPTION_ELEMENT, 3, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-OPTION"));
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-05---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-05");
    checkResultIsPreQualified(processResult, 1, 1);
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.DATALIST_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-DATALIST"));
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-06---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-06");
    checkResultIsPreQualified(processResult, 3, 3);
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.PROGRESS_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-PROGRESS"));
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.OUTPUT_ELEMENT, 2, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-OUTPUT"));
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.METER_ELEMENT, 3, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-METER"));
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-07---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-07");
    checkResultIsPreQualified(processResult, 11, 11);
    HashMap<Integer, String> mapRoleAttribute = new HashMap<Integer, String>();
    mapRoleAttribute.put(1, "checkbox");
    mapRoleAttribute.put(2, "combobox");
    mapRoleAttribute.put(3, "listbox");
    mapRoleAttribute.put(4, "progressbar");
    mapRoleAttribute.put(5, "option");
    mapRoleAttribute.put(6, "radio");
    mapRoleAttribute.put(7, "searchbox");
    mapRoleAttribute.put(8, "slider");
    mapRoleAttribute.put(9, "spinbutton");
    mapRoleAttribute.put(10, "switch");
    mapRoleAttribute.put(11, "textbox");
    for (Map.Entry item : mapRoleAttribute.entrySet()) {
        int position = ((int) item.getKey());
        checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.DIV_ELEMENT, position, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-id-for-ROLE-" + item.getValue()));
    }
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-08---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa40.Test.11.2.4-3NMI-08");
    checkResultIsPreQualified(processResult, 1, 1);
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.INPUT_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby-for-input-without-parent-form-tag"));
    checkRemarkIsPresent(processResult, TestSolution.NEED_MORE_INFO, RemarkMessageStore.MANUAL_CHECK_ON_ELEMENTS_MSG, HtmlElementStore.INPUT_ELEMENT, 1, new ImmutablePair(ARIA_LABELLEDBY_ATTR, "aria-labelledby1 aria-labelledby2 aria-labelledby-for-input-without-parent-form-tag"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-01----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-01"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-02----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-02"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-03----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-03"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-04----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-04"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-05----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-05"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-06----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-06"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-07----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-07"));
    // ----------------------------------------------------------------------
    // ------------------------------4NA-08----------------------------------
    // ----------------------------------------------------------------------
    checkResultIsNotApplicable(processPageTest("Rgaa40.Test.11.2.4-4NA-08"));
}