Determine if this reader is a single suite
and initialize the suite collection with the first
suite.
549950
protected function initSuite()
    {
        $suiteNodes = $this->xml->xpath('/testsuites/testsuite/testsuite');
        $this->isSingle = \count($suiteNodes) === 0;
        $node = current($this->xml->xpath('/testsuites/testsuite'));

        if ($node !== false) {
            $this->suites[] = TestSuite::suiteFromNode($node);
        } else {
            $this->suites[] = TestSuite::suiteFromArray(self::$defaultSuite);
        }
    }
555560
private void initialize(CatalogContext catalogContext, List<Pair<Integer, Integer>> localPartitionsToSites,
            boolean isRejoin) {
        try {
            CatalogMap<Connector> connectors = CatalogUtil.getConnectors(catalogContext);
            if (exportLog.isDebugEnabled()) {
                exportLog.debug("initialize for " + connectors.size() + " connectors.");
                CatalogUtil.dumpConnectors(exportLog, connectors);
            }
            if (!CatalogUtil.hasExportedTables(connectors)) {
                return;
            }

            if (exportLog.isDebugEnabled()) {
                exportLog.debug("Creating processor " + m_loaderClass);
            }
            ExportDataProcessor newProcessor = getNewProcessorWithProcessConfigSet(m_processorConfig);
            m_processor.set(newProcessor);

            File exportOverflowDirectory = new File(VoltDB.instance().getExportOverflowPath());
            ExportGeneration generation = new ExportGeneration(exportOverflowDirectory, m_messenger);
            generation.initialize(m_hostId, catalogContext,
                    connectors, newProcessor, localPartitionsToSites, exportOverflowDirectory);

            m_generation.set(generation);
            newProcessor.setExportGeneration(generation);
            newProcessor.readyForData();
        }
        catch (final ClassNotFoundException e) {
            exportLog.l7dlog( Level.ERROR, LogKeys.export_ExportManager_NoLoaderExtensions.name(), e);
            throw new RuntimeException(e);
        }
        catch (final Exception e) {
            exportLog.error("Initialize failed with:", e);
            throw new RuntimeException(e);
        }
    }
664998
public synchronized static void initConfig(ISuite suite) {
        SeLionLogger.getLogger().entering(suite);
        Map<ConfigProperty, String> initialValues = new HashMap<>();
        for (ConfigProperty prop : ConfigProperty.values()) {
            String paramValue = suite.getParameter(prop.getName());
            // empty values may be valid for some properties
            if (paramValue != null) {
                initialValues.put(prop, paramValue);
            }
        }
        initConfig(initialValues);

        SeLionLogger.getLogger().exiting();
    }
1307460
def initializable(self):
        """"""
        return bool(lib.EnvSlotInitableP(self._env, self._cls, self._name))
566608
public function beforeSuite(Suite $suite)
    {
        if ($this->depth == 0) {
            $this->console->writeLn('');
        }

        $this->depth += 1;
        parent::beforeSuite($suite);
    }
309056
public boolean isInitialized() {
    for (int i = 0; i < fields.getNumArrayEntries(); i++) {
      if (!isInitialized(fields.getArrayEntryAt(i))) {
        return false;
      }
    }
    for (final Map.Entry<FieldDescriptorType, Object> entry :
             fields.getOverflowEntries()) {
      if (!isInitialized(entry)) {
        return false;
      }
    }
    return true;
  }
188704
private boolean isFirstAnalysisSecondaryLongLivingBranch() {
    if (analysisMetadataHolder.isFirstAnalysis()) {
      Branch branch = analysisMetadataHolder.getBranch();
      return !branch.isMain() && branch.getType() == BranchType.LONG;
    }
    return false;
  }
896940
def load_visible_suites(cls, paths=None):
        
        suite_paths = cls.visible_suite_paths(paths)
        suites = [cls.load(x) for x in suite_paths]
        return suites
1166654
def check(self, version):
        

        for disjunct in self._disjuncts:
            if self._check_insersection(version, disjunct):
                return True

        return False
879639
def _check_for_single_nested(target, items_by_key, input_order):
    
    out = utils.deepish_copy(items_by_key)
    for (k, t) in input_order.items():
        if t == "var":
            v = items_by_key[tuple(k.split("__"))]
            if _is_nested_single(v, target):
                out[tuple(k.split("__"))] = v[0]
    return out
153886
@Override
  public boolean isInstanceOf(KbCollection collection, Context context) {
    return wrapped().isInstanceOf(collection, context);
  }
239696
def register_suite():
    
    global test_suite
    frm = inspect.stack()[1]
    test_suite = ".".join(os.path.basename(frm[1]).split('.')[0:-1])
1225114
public function init_is_standard() {

        $pluginman = $this->pluginman;
        $standard = $pluginman::standard_plugins_list($this->type);

        if ($standard !== false) {
            $standard = array_flip($standard);
            if (isset($standard[$this->name])) {
                $this->source = core_plugin_manager::PLUGIN_SOURCE_STANDARD;
            } else if (!is_null($this->versiondb) and is_null($this->versiondisk)
                and $pluginman::is_deleted_standard_plugin($this->type, $this->name)) {
                $this->source = core_plugin_manager::PLUGIN_SOURCE_STANDARD; // To be deleted.
            } else {
                $this->source = core_plugin_manager::PLUGIN_SOURCE_EXTENSION;
            }
        }
    }
208859
private void init(Symtab syms, boolean definitive) {
        if (classes != null) return;

        if (definitive) {
            Assert.check(packages == null || packages == syms.packages);
            packages = syms.packages;
            Assert.check(classes == null || classes == syms.classes);
            classes = syms.classes;
        } else {
            packages = new HashMap<Name, PackageSymbol>();
            classes = new HashMap<Name, ClassSymbol>();
        }

        packages.put(names.empty, syms.rootPackage);
        syms.rootPackage.completer = thisCompleter;
        syms.unnamedPackage.completer = thisCompleter;
    }
578003
protected function initSuites()
    {
        if (\is_array($this->suitesName)) {
            foreach ($this->suitesName as $suiteName) {
                $this->loadedSuites[$suiteName] = $this->createFullSuite($suiteName, $this->configuration->getPath());
            }
        } else {
            foreach ($this->files as $path) {
                try {
                    $parser = new Parser($path);
                    if ($class = $parser->getClass()) {
                        $this->loadedSuites[$path] = $this->createSuite($path, $class);
                    }
                } catch (NoClassInFileException $e) {
                    continue;
                }
            }
        }
    }
949225
def is_all_initialized(self):
        '''
        '''
        return frozenset(self._class_map.keys()) == \
            frozenset(self._instance_map.keys())
1321681
private boolean isInitialized()
  {
    if(corpusAdministration.checkDatabaseSchemaVersion() == false)
    {
      btInit.setText("Init to update your database");
      return false;
    }
      
    // hack, just try to list corpora
    try
    {
      corpusAdministration.listCorpusStats();
    }
    catch (Exception ex)
    {
      return false;
    }

    return true;
  }