Java 类org.junit.rules.ErrorCollector 实例源码

/**
 * check all properties of a component for i18n, check form i18n, check ComponentProperties title is i18n
 * 
 * @param componentService where to get all the components
 * @param errorCollector used to collect all errors at once. @see
 *            <a href="http://junit.org/apidocs/org/junit/rules/ErrorCollector.html">ErrorCollector</a>
 * @deprecated use {@link PropertiesTestUtils#assertAlli18nAreSetup(DefinitionRegistryService, ErrorCollector)} and
 *             {@link #assertReturnProperties18nAreSet(DefinitionRegistryService, ErrorCollector)}
 */
@Deprecated
static public void testAlli18n(ComponentService componentService, ErrorCollector errorCollector) {
    Set<ComponentDefinition> allComponents = componentService.getAllComponents();
    for (ComponentDefinition cd : allComponents) {
        ComponentProperties props = (ComponentProperties) PropertiesImpl.createNewInstance(cd.getPropertiesClass(), "root")
                .init();
        // check all properties
        if (props != null) {
            checkAllI18N(props, errorCollector);
        } else {
            System.out.println("No properties to check fo I18n for :" + cd.getName());
        }
        // check component definition title
        errorCollector.checkThat(
                "missing I18n property [" + cd.getTitle() + "] for definition [" + cd.getClass().getName() + "]",
                cd.getTitle().contains("component."), is(false));
        // check return properties i18n
        checkAllPropertyI18n(cd.getReturnProperties(), cd, errorCollector);
    }
}

private void closeViews(final ErrorCollector collector) throws InterruptedException {
    Semaphore done = new Semaphore(1);
    done.acquire();
    SwingUtilities.invokeLater(() -> done.release());
    done.tryAcquire(2, TimeUnit.SECONDS);

    for (Map.Entry<SingleNodeContainer, List<AbstractNodeView<? extends NodeModel>>> e : m_context.getNodeViews()
            .entrySet()) {
        for (AbstractNodeView<? extends NodeModel> view : e.getValue()) {
            try {
                Node.invokeCloseView(view);
            } catch (Exception ex) {
                String msg =
                        "View '" + view + "' of node '" + e.getKey().getNameWithID() + "' has thrown a "
                                + ex.getClass().getSimpleName() + " during close: " + ex.getMessage();
                collector.addError(new Throwable(msg, ex));
            }
        }
    }
}

public void run(final ErrorCollector collector) {
    try {
        assert !SwingUtilities.isEventDispatchThread() : "This part must not be executed in the AWT thread";
        SwingUtilities.invokeAndWait(new Runnable() {
            @Override
            public void run() {
                // do nothing, just wait for all previous events to be processed (e.g. close dialog and views)
            }
        });
        synchronized (m_context.getUncaughtExceptions()) {
            for (Pair<Thread, Throwable> p : m_context.getUncaughtExceptions()) {
                Throwable error = new Throwable("Thread " + p.getFirst().getName() + " has thrown an uncaught "
                                + p.getSecond().getClass().getSimpleName() + ": " + p.getSecond().getMessage(), p.getSecond());
                collector.addError(error);
            }
        }
    } catch (Throwable t) {
        collector.addError(t);
    } finally {
        Thread.setDefaultUncaughtExceptionHandler(null);
    }
}

public void run(final ErrorCollector collector, WorkflowTestContext m_context) {
    try {
        m_context.getWorkflowManager().shutdown();
        m_context.getWorkflowManager().getParent().removeNode(m_context.getWorkflowManager().getID());

        List<NodeContainer> openWorkflows = new ArrayList<NodeContainer>(WorkflowManager.ROOT.getNodeContainers());
        openWorkflows.removeAll(m_context.getAlreadyOpenWorkflows());
        if (openWorkflows.size() > 0) {
            collector.addError(new Throwable(openWorkflows.size()
                    + " dangling workflows detected: " + openWorkflows));
        }

        Collection<Pair<NodeContainer, StackTraceElement[]>> openBuffers =
            BufferTracker.getInstance().getOpenBuffers();
        if (!openBuffers.isEmpty()) {
            collector.addError(new Throwable(openBuffers.size() + " open buffers detected: "
                + openBuffers.stream().map(p -> p.getFirst().getNameWithID()).collect(Collectors.joining(", "))));
        }
        BufferTracker.getInstance().clear();
    } catch (Throwable t) {
        collector.addError(t);
    }
}

public static Properties checkSerialize(Properties props, ErrorCollector errorCollector) {
    String s = props.toSerialized();
    SerializerDeserializer.Deserialized<Properties> d = Properties.Helper.fromSerializedPersistent(s, Properties.class);
    Properties deserProps = d.object;
    checkAllI18N(deserProps, errorCollector);
    assertFalse(d.migrated);
    List<NamedThing> newProps = deserProps.getProperties();
    List<Form> newForms = deserProps.getForms();
    int i = 0;
    for (NamedThing prop : props.getProperties()) {
        LOGGER.debug(prop.getName());
        assertEquals(prop.getName(), newProps.get(i).getName());
        i++;
    }
    i = 0;
    for (Form form : props.getForms()) {
        LOGGER.debug("Form: " + form.getName());
        Form newForm = newForms.get(i++);
        assertEquals(form.getName(), form.getName());
        for (Widget widget : form.getWidgets()) {
            NamedThing formChild = widget.getContent();
            String name = formChild.getName();
            if (formChild instanceof Form) {
                name = ((Form) formChild).getProperties().getName();
            }
            LOGGER.debug("  prop: " + formChild.getName() + " name to be used: " + name);
            NamedThing newChild = newForm.getWidget(name).getContent();
            String newName = newChild.getName();
            if (newChild instanceof Form) {
                newName = ((Form) newChild).getProperties().getName();
            }
            assertEquals(name, newName);

        }
    }
    return deserProps;

}

/**
 * check all properties of a component for i18n, check form i18n, check ComponentProperties title is i18n
 * 
 * @param defRegistry where to get all the definitions
 * @param errorCollector used to collect all errors at once. @see <a
 * href="http://junit.org/apidocs/org/junit/rules/ErrorCollector.html">ErrorCollector</a>
 */
static public void assertAlli18nAreSetup(DefinitionRegistryService defRegistry, ErrorCollector errorCollector) {
    Collection<Definition> allDefs = defRegistry.getDefinitionsMapByType(Definition.class).values();
    for (Definition def : allDefs) {
        Class propertiesClass = def.getPropertiesClass();
        if (propertiesClass == null) {
            // log it but do not consider it as a error because
            // tComp Wizard ses it with null (this is bad)
            LOGGER.error("Properties class for definition [" + def.getName() + "] should never be null.");
            continue;
        }
        Properties props = PropertiesImpl.createNewInstance(propertiesClass, "root").init();
        // check all properties
        if (props != null) {
            checkAllI18N(props, errorCollector);
        } else {
            LOGGER.info("No properties to check fo I18n for :" + def.getName());
        }
        // check definition name
        errorCollector.checkThat("displayName for definition [" + def.getClass().getName() + "] must not be null",
                def.getDisplayName(), notNullValue());
        errorCollector.checkThat(
                "missing I18n displayName [" + def.getDisplayName() + "] for definition [" + def.getClass().getName() + "]",
                def.getDisplayName(), not(endsWith(Definition.I18N_DISPLAY_NAME_SUFFIX)));
        // check definition title
        errorCollector.checkThat("title for definition [" + def.getClass().getName() + "] must not be null", def.getTitle(),
                notNullValue());
        errorCollector.checkThat(
                "missing I18n title [" + def.getTitle() + "] for definition [" + def.getClass().getName() + "]",
                def.getTitle(), not(endsWith(Definition.I18N_TITLE_NAME_SUFFIX)));
    }
}

/**
 * check that the property has a display name that is translated. We basically checks that is does not end with
 * ".displayName".
 * 
 * @param errorCollector, to collect the error
 * @param prop the property to check for an i18N {@link Property#getDisplayName()}
 * @param parent, used only for the error message to identify the origin of the property
 */
static public void chekProperty(final ErrorCollector errorCollector, Property<?> prop, Object parent) {
    // check that property.getDisplay name has been translated.
    errorCollector.checkThat(
            "property [" + parent.getClass().getCanonicalName() + "#" + prop.getName()
                    + "] should have a translated message key [property." + prop.getName()
                    + ".displayName] in [the proper messages.properties]",
            prop.getDisplayName().endsWith(".displayName"), is(false));
    if (prop.getDisplayName().endsWith(".displayName")) {// display this to help create the I18N file
        System.out.println("property." + prop.getName() + ".displayName=");
    }
}

@Test
public void testAssertAlli18nAreSetup() {
    DefinitionRegistryService defRegServ = mock(DefinitionRegistryService.class);
    Definition repDef = when(mock(Definition.class).getName()).thenReturn("NAME").getMock();
    when(repDef.getPropertiesClass()).thenReturn(TestProperties.class);
    when(defRegServ.getDefinitionsMapByType(Definition.class)).thenReturn(Collections.singletonMap("NAME", repDef));

    ErrorCollector errorCollector = spy(new ErrorCollector());
    // check when everything is fine
    assertThat(repDef, notNullValue());
    when(repDef.getDisplayName()).thenReturn("foo");
    when(repDef.getTitle()).thenReturn("bar");

    PropertiesTestUtils.assertAlli18nAreSetup(defRegServ, errorCollector);

    verify(errorCollector, times(0)).addError(any(Throwable.class));

    // check when displayName and title is missing
    errorCollector = spy(new ErrorCollector());
    when(repDef.getDisplayName()).thenReturn(Definition.I18N_DISPLAY_NAME_SUFFIX);
    when(repDef.getTitle()).thenReturn(Definition.I18N_TITLE_NAME_SUFFIX);

    PropertiesTestUtils.assertAlli18nAreSetup(defRegServ, errorCollector);

    verify(errorCollector, times(2)).addError(any(Throwable.class));

    // check when displayName and title are null
    errorCollector = spy(new ErrorCollector());
    when(repDef.getDisplayName()).thenReturn(null);
    when(repDef.getTitle()).thenReturn(null);

    PropertiesTestUtils.assertAlli18nAreSetup(defRegServ, errorCollector);

    verify(errorCollector, times(2)).addError(any(Throwable.class));
}

static public void checkAllSchemaPathAreSchemaTypes(ComponentService service, ErrorCollector collector) {
    Set<ComponentDefinition> allComponents = service.getAllComponents();
    for (ComponentDefinition cd : allComponents) {
        ComponentProperties properties = cd.createProperties();
        if (properties instanceof FixedConnectorsComponentProperties) {
            checkAllSchemaPathAreSchemaTypes((FixedConnectorsComponentProperties) properties, collector);
        }
    }
}

private static void checkAllConnector(FixedConnectorsComponentProperties fccp, ErrorCollector collector,
        Set<PropertyPathConnector> allConnectors) {
    for (PropertyPathConnector connector : allConnectors) {
        NamedThing property = fccp.getProperty(connector.getPropertyPath());
        collector.checkThat(property, notNullValue());
        collector.checkThat(property, anyOf(instanceOf(Property.class), instanceOf(SchemaProperties.class)));
    }
}

/**
 * check all properties of a component for i18n, check form i18n, check ComponentProperties title is i18n
 * 
 * @param componentService where to get all the components
 * @param errorCollector used to collect all errors at once. @see
 *            <a href="http://junit.org/apidocs/org/junit/rules/ErrorCollector.html">ErrorCollector</a>
 */
static public void assertReturnProperties18nAreSet(DefinitionRegistryService definitionRegistry,
        ErrorCollector errorCollector) {
    Collection<ComponentDefinition> allComponents = definitionRegistry.getDefinitionsMapByType(ComponentDefinition.class)
            .values();
    for (ComponentDefinition cd : allComponents) {
        // check return properties i18n
        checkAllPropertyI18n(cd.getReturnProperties(), cd, errorCollector);
    }
}

public static void checkAllPropertyI18n(Property<?>[] propertyArray, Object parent, ErrorCollector errorCollector) {
    if (propertyArray != null) {
        for (Property<?> prop : propertyArray) {
            PropertiesTestUtils.chekProperty(errorCollector, prop, parent);
        }
    } // else no property to check so ignore.
}

public LifeCycleManagerResource(ErrorCollector errorCollector, final List<Module> modules) {
    this.errorCollector = errorCollector;
    this.modules = modules;
    this.lifeCycleManager = new LifeCycleManager(new LinkedList<Module>() {{
        add(new CommonModule());
        addAll(modules);
    }});
}

public MountedFileSystem(
        ErrorCollector errorCollector, TempFolderProvider tempFolderProvider,
        LifeCycleManagerResource lifeCycleManager) {
    this.errorCollector = errorCollector;
    this.tempFolderProvider = tempFolderProvider;
    this.lifeCycleManager = lifeCycleManager;
}

public TestFlowRunner(ErrorCollector collector, TestrunConfiguration runConfiguration) {
    super();
    this.collector = collector;
    this.m_runConfiguration = runConfiguration;
    if (m_runConfiguration.isLoadSaveLoad()) {
        throw new UnsupportedOperationException("LoadSaveLoad is not supported");
    }
}

public void run(final ErrorCollector collector) {

        try {
            checkForDeprecatedNodes(collector, m_context.getWorkflowManager());
        } catch (Throwable t) {
            collector.addError(t);
        }
    }

private void checkForDeprecatedNodes(final ErrorCollector collector, final WorkflowManager wfm) {
    for (NodeContainer node : wfm.getNodeContainers()) {
        if (node instanceof SingleNodeContainer) {
            if ("true".equals(((SingleNodeContainer)node).getXMLDescription().getAttribute("deprecated"))) {
                 collector.addError(new Throwable("Node '" + node.getName() + "' is deprecated."));
            }
        } else if (node instanceof WorkflowManager) {
            checkForDeprecatedNodes(collector, (WorkflowManager)node);
        } else {
            throw new IllegalStateException("Unknown node container type: " + node.getClass().getName());
        }
    }
}

public void run(final ErrorCollector collector) {
    try {
        closeViews(collector);
    } catch (Throwable t) {
        collector.addError(t);
    }
}

public void run(final ErrorCollector collector) {

        try {
            checkNodeMessages(collector, m_context.getWorkflowManager(), m_context.getTestflowConfiguration());
        } catch (Throwable t) {
            collector.addError(t);
        }
    }

private void checkNodeMessages(final ErrorCollector collector, final WorkflowManager wfm,
    final TestflowConfiguration flowConfiguration) {
    for (NodeContainer node : wfm.getNodeContainers()) {
        if (!m_context.isPreExecutedNode(node)) {
            if (node instanceof SubNodeContainer) {
                checkNodeMessages(collector, ((SubNodeContainer)node).getWorkflowManager(), flowConfiguration);
            } else if (node instanceof WorkflowManager) {
                checkNodeMessages(collector, (WorkflowManager)node, flowConfiguration);
                checkSingleNode(collector, node, flowConfiguration);
            } else {
                checkSingleNode(collector, node, flowConfiguration);
            }
        }
    }
}

public void run(final ErrorCollector collector) {
    try {
        hiliteRows(collector, m_context.getWorkflowManager(), m_context.getTestflowConfiguration());
    } catch (Throwable t) {
        collector.addError(t);
    }
}

private void hiliteRows(final ErrorCollector collector, final WorkflowManager manager,
                        final TestflowConfiguration flowConfiguration) {
    for (NodeContainer cont : manager.getNodeContainers()) {
        if (cont instanceof WorkflowManager) {
            hiliteRows(collector, (WorkflowManager)cont, flowConfiguration);
        } else if (cont instanceof SingleNodeContainer) {
            hiliteRows(collector, (SingleNodeContainer)cont, flowConfiguration);

        }
    }
}

private void hiliteRows(final ErrorCollector collector, final SingleNodeContainer node,
                        final TestflowConfiguration flowConfiguration) {
    for (int i = 0; i < node.getNrOutPorts(); i++) {
        if (node.getOutputObject(i) instanceof BufferedDataTable) {
            int max = flowConfiguration.getMaxHiliteRows();

            List<RowKey> keys = new ArrayList<RowKey>();
            CloseableRowIterator it = ((BufferedDataTable)node.getOutputObject(i)).iterator();
            while (it.hasNext() && max-- > 0) {
                keys.add(it.next().getKey());
            }
            it.close();

            HiLiteHandler handler = node.getOutputHiLiteHandler(i);
            // hilite all
            handler.fireHiLiteEvent(new HashSet<RowKey>(keys));
            // unhilite sonme
            handler.fireUnHiLiteEvent(new HashSet<RowKey>(keys.subList((int) (0.1 * keys.size()),
                                                                     (int) Math.ceil(0.6 * keys.size()))));
            // unhilite all
            handler.fireClearHiLiteEvent();
        }
    }
}

public void run(final ErrorCollector collector) {
    try {
        m_context.setWorkflowManager(loadWorkflow(this, collector, m_workflowDir, m_testcaseRoot, m_runConfiguration));
    } catch (Throwable t) {
        collector.addError(t);
    }
}

static WorkflowManager loadWorkflow(final WorkflowTest test, final ErrorCollector collector, final File workflowDir,
    final File testcaseRoot, final TestrunConfiguration runConfig) throws IOException, InvalidSettingsException,
    CanceledExecutionException, UnsupportedWorkflowVersionException, LockFailedException {
    WorkflowLoadHelper loadHelper = new WorkflowLoadHelper() {
        /**
         * {@inheritDoc}
         */
        @Override
        public WorkflowContext getWorkflowContext() {
            WorkflowContext.Factory fac = new WorkflowContext.Factory(workflowDir);
            fac.setMountpointRoot(testcaseRoot);
            return fac.createContext();
        }
    };

    WorkflowLoadResult loadRes = WorkflowManager.loadProject(workflowDir, new ExecutionMonitor(), loadHelper);
    if ((loadRes.getType() == LoadResultEntryType.Error)
        || ((loadRes.getType() == LoadResultEntryType.DataLoadError) && loadRes.getGUIMustReportDataLoadErrors())) {
        collector.addError(new Throwable(loadRes.getFilteredError("", LoadResultEntryType.Error)));
    }
    if (runConfig.isCheckForLoadWarnings() && loadRes.hasWarningEntries()) {
        collector.addError(new Throwable(loadRes.getFilteredError("", LoadResultEntryType.Warning)));
    }

    WorkflowManager wfm = loadRes.getWorkflowManager();
    wfm.addWorkflowVariables(true, runConfig.getFlowVariables());
    return wfm;
}

public void run(final ErrorCollector collector) {

        try {
            openViews(collector, m_context.getWorkflowManager());
        } catch (Throwable t) {
            collector.addError(t);
        }
    }

public void run(final ErrorCollector collector) {
    try {
        MemoryUsage currentUsage = getHeapUsage();
        long diff = currentUsage.getUsed() - m_initalUsage.getUsed();
        if (diff > m_runConfiguration.getAllowedMemoryIncrease()) {
            collector.addError(new Throwable("Heap usage increased by " + diff
                    + " bytes which is more than the allowed " + m_runConfiguration.getAllowedMemoryIncrease()
                    + "bytes (before test: " + m_initalUsage.getUsed() + ", after test: " + currentUsage.getUsed()));
        }
    } catch (Throwable t) {
        collector.addError(t);
    }
}

public void run(final ErrorCollector collector, TestflowConfiguration flowConfiguration) {
    try {
        Logger.getRootLogger().removeAppender(m_logAppender);
        checkLogMessages(collector, flowConfiguration);
    } catch (Throwable t) {
        collector.addError(t);
    } finally {
        Logger.getRootLogger().removeAppender(m_logAppender);
        m_logEvents.clear();
    }
}

public void run(final ErrorCollector collector) {
    try {
        checkDialogs(collector, m_context.getWorkflowManager());
    } catch (Throwable t) {
        collector.addError(t);
    }
}

public void run(final ErrorCollector collector) {
    if (m_saveLocation != null) {
        try {
            saveWorkflow();
        } catch (Throwable t) {
            collector.addError(t);
        }
    }
}

@Async
public void getStringInFuture(ErrorCollector collector) {
    final String backendValue = traceeBackend.get("myKey");
    collector.checkThat(backendValue, notNullValue());
    collector.checkThat(oldVals, not(hasItem(backendValue)));
    oldVals.add(backendValue);
    invocationCount.incrementAndGet();
}

public Helper(ErrorCollector collector) {
    this.collector = collector;
}

public Helper(ErrorCollector collector) {
    this.collector = collector;
}

public SyncHelper(ErrorCollector collector) {
    this.collector = collector;
}

public AsyncHelper(ErrorCollector collector) {
    this.collector = collector;
}

public Helper(ErrorCollector collector) {
    this.collector = collector;
}

@Test
public void testAssertAnIconIsSetup() {
    // create a registry with one definition
    DefinitionRegistryService defRegServ = mock(DefinitionRegistryService.class);
    Definition repDef = when(mock(ADefinition.class).getName()).thenReturn("NAME").getMock();
    when(repDef.getPropertiesClass()).thenReturn(TestProperties.class);
    when(defRegServ.getDefinitionsMapByType(Definition.class)).thenReturn(Collections.singletonMap("NAME", repDef));

    // check when everything is fine
    assertThat(repDef, notNullValue());

    // There is a PNG icon available.
    ErrorCollector errorCollector = spy(new ErrorCollector());
    when(repDef.getImagePath(DefinitionImageType.PALETTE_ICON_32X32))
            .thenReturn("/org/talend/daikon/properties/messages.properties");
    when(repDef.getImagePath(DefinitionImageType.SVG_ICON)).thenReturn(null);
    when(repDef.getIconKey()).thenReturn(null);

    PropertiesTestUtils.assertAnIconIsSetup(defRegServ, errorCollector);
    verify(errorCollector, times(0)).addError(any(Throwable.class));

    // There is an SVG icon available.
    errorCollector = spy(new ErrorCollector());
    when(repDef.getImagePath(DefinitionImageType.PALETTE_ICON_32X32)).thenReturn(null);
    when(repDef.getImagePath(DefinitionImageType.SVG_ICON)).thenReturn("/org/talend/daikon/properties/messages.properties");
    when(repDef.getIconKey()).thenReturn(null);

    PropertiesTestUtils.assertAnIconIsSetup(defRegServ, errorCollector);
    verify(errorCollector, times(0)).addError(any(Throwable.class));

    // There is an iconKey available.
    errorCollector = spy(new ErrorCollector());
    when(repDef.getImagePath(DefinitionImageType.PALETTE_ICON_32X32)).thenReturn(null);
    when(repDef.getImagePath(DefinitionImageType.SVG_ICON)).thenReturn(null);
    when(repDef.getIconKey()).thenReturn("icon-key");

    PropertiesTestUtils.assertAnIconIsSetup(defRegServ, errorCollector);
    verify(errorCollector, times(0)).addError(any(Throwable.class));

    // check when no icon information is present
    errorCollector = spy(new ErrorCollector());
    when(repDef.getImagePath(DefinitionImageType.PALETTE_ICON_32X32)).thenReturn(null);
    when(repDef.getImagePath(DefinitionImageType.SVG_ICON)).thenReturn(null);
    when(repDef.getIconKey()).thenReturn(null);

    PropertiesTestUtils.assertAnIconIsSetup(defRegServ, errorCollector);
    verify(errorCollector, times(1)).addError(any(Throwable.class));

    // There is a PNG icon available, but the path is wrong
    errorCollector = spy(new ErrorCollector());
    when(repDef.getImagePath(DefinitionImageType.PALETTE_ICON_32X32)).thenReturn("foo");
    when(repDef.getImagePath(DefinitionImageType.SVG_ICON)).thenReturn(null);
    when(repDef.getIconKey()).thenReturn(null);

    PropertiesTestUtils.assertAnIconIsSetup(defRegServ, errorCollector);
    verify(errorCollector, times(1)).addError(any(Throwable.class));

    // There is an SVG icon available.
    errorCollector = spy(new ErrorCollector());
    when(repDef.getImagePath(DefinitionImageType.PALETTE_ICON_32X32)).thenReturn(null);
    when(repDef.getImagePath(DefinitionImageType.SVG_ICON)).thenReturn("foo");
    when(repDef.getIconKey()).thenReturn(null);

    PropertiesTestUtils.assertAnIconIsSetup(defRegServ, errorCollector);
    verify(errorCollector, times(1)).addError(any(Throwable.class));
}

static public void checkAllSchemaPathAreSchemaTypes(FixedConnectorsComponentProperties fccp, ErrorCollector collector) {
    Set<PropertyPathConnector> allConnectors = fccp.getAllSchemaPropertiesConnectors(true);
    checkAllConnector(fccp, collector, allConnectors);
    allConnectors = fccp.getAllSchemaPropertiesConnectors(false);
    checkAllConnector(fccp, collector, allConnectors);
}

public static Properties checkSerialize(Properties props, ErrorCollector errorCollector) {
    return PropertiesTestUtils.checkSerialize(props, errorCollector);
}

static public void checkAllI18N(Properties checkedProps, ErrorCollector errorCollector) {
    PropertiesTestUtils.checkAllI18N(checkedProps, errorCollector);
}