/**
  * @return void
  */
 public function processData()
 {
     $objectManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
     /** @var FluxService $fluxService */
     $fluxService = $objectManager->get('FluidTYPO3\\Flux\\Service\\FluxService');
     $fluxService->initializeObject();
     /** @var DataMapFactory $dataMapFactory */
     $dataMapFactory = $objectManager->get('TYPO3\\CMS\\Extbase\\Persistence\\Generic\\Mapper\\DataMapFactory');
     $forms = Core::getRegisteredFormsForTables();
     $models = Core::getRegisteredFormsForModelObjectClasses();
     foreach ($forms as $fullTableName => $form) {
         $this->processFormForTable($fullTableName, $form);
     }
     foreach ($models as $modelClassName => $form) {
         $map = $dataMapFactory->buildDataMap($modelClassName);
         $fullTableName = $map->getTableName();
         if (NULL === $form) {
             $form = $this->generateFormInstanceFromClassName($modelClassName, $fullTableName);
         }
         if (NULL === $form->getName()) {
             $form->setName($fullTableName);
         }
         $this->processFormForTable($fullTableName, $form);
     }
 }

 /**
  * Setup
  */
 public function setup()
 {
     $providers = Core::getRegisteredFlexFormProviders();
     if (TRUE === in_array('FluidTYPO3\\Flux\\Service\\FluxService', $providers)) {
         Core::unregisterConfigurationProvider('FluidTYPO3\\Flux\\Service\\FluxService');
     }
 }

 public function testGetContentConfiguration()
 {
     Core::registerProviderExtensionKey('FluidTYPO3.Fluidcontent', 'Content');
     $service = $this->getMock('FluidTYPO3\\Fluidcontent\\Service\\ConfigurationService', array('dummy'), array(), '', FALSE);
     $service->injectConfigurationManager(GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager')->get('TYPO3\\CMS\\Extbase\\Configuration\\ConfigurationManagerInterface'));
     $result = $service->getContentConfiguration();
     $this->assertEquals(array('FluidTYPO3.Fluidcontent' => array('templateRootPaths' => array(10 => 'EXT:fluidcontent/Resources/Private/Templates/'), 'partialRootPaths' => array(10 => 'EXT:fluidcontent/Resources/Private/Partials/'), 'layoutRootPaths' => array(10 => 'EXT:fluidcontent/Resources/Private/Layouts/'))), $result);
 }

 /**
  * Includes static template from extensions
  *
  * @param array $params
  * @param TemplateService $pObj
  * @return void
  */
 public function preprocessIncludeStaticTypoScriptSources(array &$params, TemplateService $pObj)
 {
     if (TRUE === isset($params['row']['root']) && TRUE === (bool) $params['row']['root']) {
         $existingTemplates = GeneralUtility::trimExplode(',', $params['row']['include_static_file']);
         $globalStaticTemplates = Core::getStaticTypoScript();
         $staticTemplates = array_merge($globalStaticTemplates, $existingTemplates);
         $params['row']['include_static_file'] = implode(',', array_unique($staticTemplates));
     }
 }

 /**
  * @test
  */
 public function throwsExceptionWhenResolvingInvalidConfigurationProviderInstances()
 {
     $instance = $this->createInstance();
     $record = array('test' => 'test');
     Core::registerConfigurationProvider('FluidTYPO3\\Flux\\Service\\FluxService');
     $this->setExpectedException('RuntimeException', NULL, 1327173536);
     $instance->flushCache();
     $instance->resolveConfigurationProviders('tt_content', 'pi_flexform', $record);
     Core::unregisterConfigurationProvider('FluidTYPO3\\Flux\\Service\\FluxService');
 }

 /**
  * @test
  */
 public function testResolveDomainFormClassInstancesFromPackages()
 {
     $modelClassName = 'FluidTYPO3\\Flux\\Tests\\Fixtures\\Classes\\Domain\\Model\\Dummy';
     Core::registerAutoFormForModelObjectClassName($modelClassName);
     $classNames = array('FluidTYPO3\\Flux\\Tests\\Fixtures\\Classes\\Domain\\Form\\DummyForm');
     $resolver = $this->getMock('FluidTYPO3\\Flux\\Helper\\Resolver', array('resolveClassNamesInPackageSubNamespace'));
     $resolver->expects($this->once())->method('resolveClassNamesInPackageSubNamespace')->willReturn($classNames);
     $result = $resolver->resolveDomainFormClassInstancesFromPackages(array('foobar'));
     $this->assertInstanceOf($classNames[0], $result[$modelClassName]);
 }

 /**
  * @test
  */
 public function leavesRecordsWhichAreNotRootsUntouched()
 {
     Core::addStaticTypoScript(self::FIXTURE_TYPOSCRIPT_DIR);
     $function = 'FluidTYPO3\\Flux\\Backend\\TypoScriptTemplate->preprocessIncludeStaticTypoScriptSources';
     $template = $this->objectManager->get('TYPO3\\CMS\\Core\\TypoScript\\TemplateService');
     $parameters = array('row' => Records::$sysTemplateRoot);
     $parameters['row']['root'] = 0;
     GeneralUtility::callUserFunction($function, $parameters, $template);
     $this->assertNotContains(self::FIXTURE_TYPOSCRIPT_DIR, $parameters['row']['include_static_file']);
     $this->assertSame(Records::$sysTemplateRoot['include_static_file'], $parameters['row']['include_static_file']);
 }

 /**
  * @test
  */
 public function leavesRecordsWhichAreNotRootsUntouched()
 {
     \FluidTYPO3\Flux\Core::addStaticTypoScript(self::FIXTURE_TYPOSCRIPT_DIR);
     $function = $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSources']['flux'];
     $template = $this->objectManager->get('t3lib_TStemplate');
     $parameters = array('row' => \FluidTYPO3\Flux\Tests\Fixtures\Data\Records::$sysTemplateRoot);
     $parameters['row']['root'] = 0;
     GeneralUtility::callUserFunction($function, $parameters, $template);
     $this->assertNotContains(self::FIXTURE_TYPOSCRIPT_DIR, $parameters['row']['include_static_file']);
     $this->assertSame(\FluidTYPO3\Flux\Tests\Fixtures\Data\Records::$sysTemplateRoot['include_static_file'], $parameters['row']['include_static_file']);
 }

 /**
  * @test
  */
 public function triggersDomainModelAnalysisWhenFormsAreRegistered()
 {
     $class = 'FluidTYPO3\\Flux\\Tests\\Fixtures\\Classes\\Domain\\Model\\Dummy';
     $form = Form::create();
     $form->setExtensionName('FluidTYPO3.Flux');
     Core::registerAutoFormForModelObjectClassName($class);
     $object = GeneralUtility::getUserObj('FluidTYPO3\\Flux\\Backend\\TableConfigurationPostProcessor');
     $object->processData();
     Core::registerFormForModelObjectClassName($class, $form);
     $result = $object->processData();
     $this->assertEmpty($result);
 }

 /**
  * @dataProvider getRegisterModuleBasedOnFluxFormTestValues
  * @param string $extension
  * @param Form $form
  * @param boolean $expectsException
  */
 public function testRegisterModuleBasedOnFluxForm($extension, Form $form, $expectsException)
 {
     $instance = new ConfigurationService();
     Core::registerProviderExtensionKey($extension, 'Backend');
     if (TRUE === $expectsException) {
         $this->setExpectedException('RuntimeException');
     }
     $GLOBALS['TBE_MODULES'] = array('fake' => array());
     $instance->registerModuleBasedOnFluxForm($extension, $form);
     if (FALSE === $expectsException) {
         $this->assertNotEmpty($GLOBALS['TBE_MODULES']);
     }
     unset($GLOBALS['TBE_MODULES']);
 }

 /**
  * @param string $name
  * @return void
  */
 protected function createPipeSheet($name)
 {
     $sheet = $this->createContainer('Sheet', $name)->createContainer('Section', $name);
     $namespace = 'FluidTYPO3\\Flux\\Outlet\\Pipe\\';
     $pipes = FluxCore::getPipes();
     foreach ($pipes as $pipeTypeOrClassName) {
         $className = TRUE === class_exists($pipeTypeOrClassName) ? $pipeTypeOrClassName : $namespace . ucfirst($pipeTypeOrClassName) . 'Pipe';
         if ('FluidTYPO3\\Flux\\Outlet\\Pipe\\StandardPipe' === $className) {
             continue;
         }
         $instance = $this->objectManager->get($className);
         $label = $instance->getLabel();
         /** @var PipeObject $pipe */
         $pipe = $sheet->createContainer('FluidTYPO3\\Fromage\\Backend\\FormComponent\\PipeObject', $pipeTypeOrClassName);
         $pipe->setLabel($label)->addAll($instance->getFormFields());
     }
 }

 /**
  * Get definitions of paths for Page Templates defined in TypoScript
  *
  * @param string $extensionName
  * @return array
  * @api
  */
 public function getPageConfiguration($extensionName = null)
 {
     if (null !== $extensionName && true === empty($extensionName)) {
         // Note: a NULL extensionName means "fetch ALL defined collections" whereas
         // an empty value that is not null indicates an incorrect caller. Instead
         // of returning ALL paths here, an empty array is the proper return value.
         // However, dispatch a debug message to inform integrators of the problem.
         $this->message('Template paths have been attempted fetched using an empty value that is NOT NULL in ' . get_class($this) . '. This indicates a potential problem with your TypoScript configuration - a ' . 'value which is expected to be an array may be defined as a string. This error is not fatal but may ' . 'prevent the affected collection (which cannot be identified here) from showing up', GeneralUtility::SYSLOG_SEVERITY_NOTICE);
         return [];
     }
     if (null !== $extensionName) {
         return $this->getViewConfigurationForExtensionName($extensionName);
     }
     $configurations = [];
     $registeredExtensionKeys = Core::getRegisteredProviderExtensionKeys('Page');
     foreach ($registeredExtensionKeys as $registeredExtensionKey) {
         $configurations[$registeredExtensionKey] = $this->getViewConfigurationForExtensionName($registeredExtensionKey);
     }
     return $configurations;
 }

 /**
  * @return void
  */
 public function processData()
 {
     if (TYPO3_REQUESTTYPE_INSTALL !== (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_INSTALL)) {
         $objectManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
         $objectManager->get('FluidTYPO3\\Flux\\Provider\\ProviderResolver')->loadTypoScriptConfigurationProviderInstances();
         $forms = Core::getRegisteredFormsForTables();
         $models = Core::getRegisteredFormsForModelObjectClasses();
         $packages = array_keys(Core::getRegisteredPackagesForAutoForms());
         foreach ($packages as $packageName) {
             list($vendorName, $extensionName) = explode('.', $packageName);
             $namespace = $vendorName . '\\' . $extensionName . '\\Domain\\';
             $extensionKey = ExtensionNamingUtility::getExtensionKey($packageName);
             $folder = ExtensionManagementUtility::extPath($extensionKey, 'Classes/Domain/Form/');
             $files = glob($folder . '*Form.php');
             $files = FALSE === $files ? array() : $files;
             foreach ($files as $fileName) {
                 $basename = pathinfo($fileName, PATHINFO_FILENAME);
                 $formClassName = $namespace . 'Form\\' . $basename;
                 $modelClassName = $namespace . 'Model\\' . substr($basename, 0, -4);
                 $fullTableName = $this->resolveTableName($modelClassName);
                 $models[$modelClassName] = $formClassName::create();
                 $models[$modelClassName]->setName($fullTableName);
                 $models[$modelClassName]->setExtensionName($packageName);
             }
         }
         foreach ($forms as $fullTableName => $form) {
             $this->processFormForTable($fullTableName, $form);
         }
         foreach ($models as $modelClassName => $form) {
             $fullTableName = $this->resolveTableName($modelClassName);
             if (NULL === $form) {
                 $form = $this->generateFormInstanceFromClassName($modelClassName, $fullTableName);
             }
             if (NULL === $form->getName()) {
                 $form->setName($fullTableName);
             }
             $this->processFormForTable($fullTableName, $form);
         }
     }
 }

<?php

if (!defined('TYPO3_MODE')) {
    die('Access denied.');
}
\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::addStaticFile($_EXTKEY, 'Configuration/TypoScript', 'Gloggi Abteilungen');
\FluidTYPO3\Flux\Core::registerProviderExtensionKey('Bm.' . $_EXTKEY, 'Content');
\FluidTYPO3\Flux\Core::registerProviderExtensionKey('Bm.' . $_EXTKEY, 'Page');
\FluidTYPO3\Flux\Core::registerProviderExtensionKey('Bm.' . $_EXTKEY, 'Backend');
\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::addLLrefForTCAdescr('tx_gloggiabteilungen_domain_model_abteilung', 'EXT:gloggiabteilungen/Resources/Private/Language/locallang_csh_tx_gloggiabteilungen_domain_model_abteilung.xlf');
\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::allowTableOnStandardPages('tx_gloggiabteilungen_domain_model_abteilung');
$GLOBALS['TCA']['tx_gloggiabteilungen_domain_model_abteilung'] = array('ctrl' => array('title' => 'Gloggi Abteilung', 'label' => 'name', 'tstamp' => 'tstamp', 'crdate' => 'crdate', 'cruser_id' => 'cruser_id', 'dividers2tabs' => TRUE, 'versioningWS' => 2, 'versioning_followPages' => TRUE, 'origUid' => 't3_origuid', 'languageField' => 'sys_language_uid', 'transOrigPointerField' => 'l10n_parent', 'transOrigDiffSourceField' => 'l10n_diffsource', 'delete' => 'deleted', 'enablecolumns' => array('disabled' => 'hidden', 'starttime' => 'starttime', 'endtime' => 'endtime'), 'searchFields' => 'name,abkuerzung,logo,einzugsgebiet,koordinaten,beschreib,internet,email,', 'dynamicConfigFile' => \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::extPath($_EXTKEY) . 'Configuration/TCA/Abteilung.php', 'iconfile' => 'EXT:gloggiabteilungen/Resources/Public/Icons/ext_icon.png'));

 /**
  * @return void
  */
 protected function performDummyRegistration()
 {
     Core::registerProviderExtensionKey($this->extensionName, $this->getControllerName());
     $this->assertContains($this->extensionName, Core::getRegisteredProviderExtensionKeys($this->getControllerName()));
 }

 /**
  * Resolves a ConfigurationProvider which can provide a working FlexForm
  * configuration based on the given parameters.
  *
  * @param string $table
  * @param string $fieldName
  * @param array $row
  * @param string $extensionKey
  * @throws \RuntimeException
  * @return ProviderInterface[]
  */
 public function resolveConfigurationProviders($table, $fieldName, array $row = NULL, $extensionKey = NULL)
 {
     $row = FALSE === is_array($row) ? array() : $row;
     $providers = Core::getRegisteredFlexFormProviders();
     $typoScriptConfigurationProviders = $this->loadTypoScriptConfigurationProviderInstances();
     $providers = array_merge($providers, $typoScriptConfigurationProviders);
     $prioritizedProviders = array();
     foreach ($providers as $providerClassNameOrInstance) {
         if (TRUE === is_object($providerClassNameOrInstance)) {
             $provider =& $providerClassNameOrInstance;
         } else {
             $provider = $this->objectManager->get($providerClassNameOrInstance);
         }
         if (FALSE === in_array('FluidTYPO3\\Flux\\Provider\\ProviderInterface', class_implements($providerClassNameOrInstance))) {
             throw new \RuntimeException(is_object($providerClassNameOrInstance) ? get_class($providerClassNameOrInstance) : $providerClassNameOrInstance . ' must implement ProviderInterfaces from Flux/Provider', 1327173536);
         }
         if (TRUE === $provider->trigger($row, $table, $fieldName, $extensionKey)) {
             $priority = $provider->getPriority($row);
             if (FALSE === is_array($prioritizedProviders[$priority])) {
                 $prioritizedProviders[$priority] = array();
             }
             $prioritizedProviders[$priority][] = $provider;
         }
     }
     ksort($prioritizedProviders);
     $providersToReturn = array();
     foreach ($prioritizedProviders as $providerSet) {
         foreach ($providerSet as $provider) {
             array_push($providersToReturn, $provider);
         }
     }
     return $providersToReturn;
 }

<?php

if (!defined('TYPO3_MODE')) {
    die('Access denied.');
}
\TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin('FluidTYPO3.Fluidcontent', 'Content', array('Content' => 'render'), array(), \TYPO3\CMS\Extbase\Utility\ExtensionUtility::PLUGIN_TYPE_CONTENT_ELEMENT);
\FluidTYPO3\Flux\Core::registerConfigurationProvider('FluidTYPO3\\Fluidcontent\\Provider\\ContentProvider');
\FluidTYPO3\Flux\Core::registerConfigurationProvider('FluidTYPO3\\Fluidcontent\\Provider\\BackendUserGroupProvider');
if ('BE' === TYPO3_MODE) {
    $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['cms']['db_new_content_el']['wizardItemsHook']['fluidcontent'] = 'FluidTYPO3\\Fluidcontent\\Hooks\\WizardItemsHookSubscriber';
    $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauthgroup.php']['fetchGroups_postProcessing']['fluidcontent'] = 'FluidTYPO3\\Fluidcontent\\Hooks\\GroupAccessListPostProcessor->addAccessLists';
    $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['GLOBAL']['extTablesInclusion-PostProcessing']['fluidcontent'] = 'FluidTYPO3\\Fluidcontent\\Backend\\TableConfigurationPostProcessor';
}
if (!is_array($GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['fluidcontent'])) {
    $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['fluidcontent'] = array('groups' => array('system'));
}

<?php

if (!defined('TYPO3_MODE')) {
    die('Access denied.');
}
\FluidTYPO3\Flux\Core::unregisterConfigurationProvider('Tx_Fed_Provider_Configuration_PageConfigurationProvider');
\FluidTYPO3\Flux\Core::registerConfigurationProvider('FluidTYPO3\\Fluidpages\\Provider\\PageProvider');
\FluidTYPO3\Flux\Core::addStaticTypoScript('EXT:fluidpages/Configuration/TypoScript/');
\TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin($_EXTKEY, 'Page', array('Page' => 'render,error'), array(), \TYPO3\CMS\Extbase\Utility\ExtensionUtility::PLUGIN_TYPE_PLUGIN);
$GLOBALS['TYPO3_CONF_VARS']['FE']['addRootLineFields'] .= ($GLOBALS['TYPO3_CONF_VARS']['FE']['addRootLineFields'] == '' ? '' : ',') . 'tx_fed_page_controller_action,tx_fed_page_controller_action_sub,tx_fed_page_flexform,tx_fed_page_flexform_sub,';
$GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects']['TYPO3\\CMS\\Backend\\View\\BackendLayoutView'] = array('className' => 'FluidTYPO3\\Fluidpages\\Override\\Backend\\View\\BackendLayoutView');
$GLOBALS['TYPO3_CONF_VARS']['SYS']['Objects']['TYPO3\\CMS\\Backend\\View\\PageLayoutView'] = array('className' => 'FluidTYPO3\\Fluidpages\\Override\\Backend\\View\\PageLayoutView');

<?php

if (!defined('TYPO3_MODE')) {
    die('Access denied.');
}
$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['fromage']['setup'] = unserialize($_EXTCONF);
if (FALSE === isset($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['fromage']['setup']['defaultFormClassName'])) {
    $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['fromage']['setup']['defaultFormClassName'] = 'FluidTYPO3\\Fromage\\Form\\StandardForm';
}
\TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin('FluidTYPO3.Fromage', 'Form', array('Form' => 'form,submit,receipt'), array('Form' => 'submit'), \TYPO3\CMS\Extbase\Utility\ExtensionUtility::PLUGIN_TYPE_CONTENT_ELEMENT);
\TYPO3\CMS\Extbase\Utility\ExtensionUtility::configurePlugin('FluidTYPO3.Fromage', 'Receipt', array('Form' => 'form,submit,receipt'), array('Form' => 'submit'), \TYPO3\CMS\Extbase\Utility\ExtensionUtility::PLUGIN_TYPE_CONTENT_ELEMENT);
if (TRUE === class_exists('FluidTYPO3\\Flux\\Core')) {
    \FluidTYPO3\Flux\Core::registerConfigurationProvider('FluidTYPO3\\Fromage\\Provider\\FromageProvider');
}
if (TRUE === class_exists('FluidTYPO3\\Fromage\\Core')) {
    // native field type registrations. Added using simple names which are easy to target (see Core class' doc comment)
    \FluidTYPO3\Fromage\Core::registerFieldObject('content');
    \FluidTYPO3\Fromage\Core::registerFieldObject('row');
    \FluidTYPO3\Fromage\Core::registerFieldObject('input');
    \FluidTYPO3\Fromage\Core::registerFieldObject('text');
    \FluidTYPO3\Fromage\Core::registerFieldObject('checkbox');
    \FluidTYPO3\Fromage\Core::registerFieldObject('select');
    \FluidTYPO3\Fromage\Core::registerFieldObject('relation');
    // native button types
    \FluidTYPO3\Fromage\Core::registerButtonObject('submit');
    \FluidTYPO3\Fromage\Core::registerButtonObject('reset');
    \FluidTYPO3\Fromage\Core::registerButtonObject('button');
    // native sheet types, there's only one of these and it is called "Grouping" and allows all fields to be used
    \FluidTYPO3\Fromage\Core::registerSheetObject('grouping');
}

<?php

\FluidTYPO3\Flux\Core::registerProviderExtensionKey('AppZap.ThemeFoundationApps', 'Page');