public function createNewServer()
 {
     $F = new Factory("xCal");
     $F->sA("xCalServerActive", "1");
     $F->sA("xCalUserID", Session::currentUser()->getID());
     $F->store();
 }

 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $config = $serviceLocator->get('config_authentification_form');
     $factory = new Factory();
     $form = $factory->createForm($config);
     return $form;
 }

 public function test_create_new()
 {
     /** === Test Data === */
     $TRANS = 'transaction name';
     $CONN = 'connection name';
     /** === Setup Mocks === */
     // $result = $this->_manObj->create(\Praxigento\Core\Transaction\Database\Def\Item::class);
     $mResult = $this->_mock(\Praxigento\Core\Transaction\Database\Def\Item::class);
     $this->mManObj->shouldReceive('create')->once()->andReturn($mResult);
     // $result->setTransactionName($transactionName);
     $mResult->shouldReceive('setTransactionName')->once()->with($TRANS);
     // $result->setConnectionName($connectionName);
     $mResult->shouldReceive('setConnectionName')->once()->with($CONN);
     // $cfgData = $this->_configDeployment->get($cfgName);
     $mCfgData = [];
     $this->mConfigDeployment->shouldReceive('get')->once()->andReturn($mCfgData);
     // $conn = $this->_factoryConn->create($cfgData);
     $mConn = $this->_mock(\Magento\Framework\DB\Adapter\AdapterInterface::class);
     $this->mFactoryConn->shouldReceive('create')->once()->andReturn($mConn);
     // $result->setConnection($conn);
     $mResult->shouldReceive('setConnection')->once();
     /** === Call and asserts  === */
     $res = $this->obj->create($TRANS, $CONN);
     $this->assertTrue($res instanceof \Praxigento\Core\Transaction\Database\IItem);
 }

 public function handle_create(Command\Create $cmd, Factory $factory)
 {
     $this->assert->not(Invariant\UserHasPendingCart::class);
     $cart = $factory->make_new();
     $cart->create($cmd->id, $cmd->customer_id);
     $this->repo->store($cart);
 }

 public function createNew()
 {
     $F = new Factory("TinkerforgeBricklet");
     $F->sA("TinkerforgeBrickletTinkerforgeID", $this->getID());
     $F->store();
     echo $this->bricklets();
 }

 /**
  * Custom validator to check email array
  * 
  * @param  Factory $factory
  * @return $object
  */
 public function validator($factory)
 {
     $campaign_id = $this->route('campaigns');
     $validation = $factory->make($this->all(), $this->rules());
     $validation->each('add_user_email_notification', ['exists:user_has_roles,user_id,campaign_id,' . $campaign_id]);
     return $validation;
 }

 function test_getReflection_should_return_instance_of_current_routed_class()
 {
     $route = new Factory('any', '/', 'DateTime', function () {
         return new \DateTime();
     });
     $refl = $route->getReflection('format');
     $this->assertInstanceOf('ReflectionMethod', $refl);
 }

 public function testShouldFactoryTypeParserWhenSomeArgumentKeyIsANumber()
 {
     $factory = new Factory();
     $arguments = array('a' => true, 'b' => 42, 'c');
     $expectedInstanceType = 'PHPFluent\\Callback\\ArgumentParser\\Type';
     $actualInstance = $factory->parser($arguments);
     $this->assertInstanceOf($expectedInstanceType, $actualInstance);
 }

 public function testJsonFormatter()
 {
     $factory = new Factory();
     $format = $factory->build('json');
     $data = $format->convertToArray($this->rawData);
     $this->assertTrue(is_array($data));
     $this->assertCount(5, $data);
 }

 /**
  * [buildContent description]
  * @param  Factory $fieldFactory The field factory with all fields for the 
  *                               content
  * @param  array   $data         The content data, this should be specified
  *                               as ['group' => [$field_1, $field_2, ...], ...]
  *                               where $field_1 & $field_2 are a stdClass
  *                               objects containing at least 'field' and 
  *                               'value' properties
  * @param  string|ContentInterface $content Content class or class name
  * @return ContentInterface       Returns the build content
  */
 public function buildContent(Factory $fieldFactory, $data, $content = '\\Message\\Cog\\Field\\Content')
 {
     if (!$content instanceof ContentInterface) {
         if (!is_string($content)) {
             throw new \InvalidArgumentException('content must be either ContentInterface or string, ' . gettype($content) == 'object' ? get_class($content) : gettype($content) . ' given');
         }
         $content = new $content();
     }
     foreach ($fieldFactory as $name => $field) {
         if ($field instanceof Group && $field->isRepeatable()) {
             // add sequence variable
             $field->add($fieldFactory->getField('hidden', self::SEQUENCE_FIELD));
             $field = new RepeatableContainer($field);
         }
         $content->set($name, $field);
     }
     // Loop through the content, grouped by group
     foreach ($data as $groupName => $rows) {
         foreach ($rows as $row) {
             // If this field is in a group
             if ($groupName) {
                 $group = $content->get($groupName);
                 if (!$group) {
                     continue;
                 }
                 // Get the right group instance if it's a repeatable group
                 if ($group instanceof RepeatableContainer) {
                     // Ensure the right number of groups are defined
                     while (!$group->get($row->sequence)) {
                         $group->add();
                     }
                     $group = $group->get($row->sequence);
                     // set sequence field value
                     $group->get('_sequence')->setValue($row->sequence);
                 }
                 // Set the field
                 try {
                     $field = $group->{$row->field};
                 } catch (\OutOfBoundsException $e) {
                     continue;
                 }
             } else {
                 $field = $content->get($row->field);
             }
             // Skip the field if we can't find it
             if (!isset($field)) {
                 continue;
             }
             // Set the values
             if ($field instanceof MultipleValueField) {
                 $field->setValue($row->data_name, $row->value);
             } elseif ($field instanceof BaseField) {
                 $field->setValue($row->value);
             }
         }
     }
     return $content;
 }

 public function __construct(Factory $factory)
 {
     $this->factory = $factory;
     $this->db = $factory->getDb();
     $this->logger = $factory->getLogger();
     $this->mainTable = $this->getMainTable();
     $this->relationsTable = $this->getRelationsTable();
     $this->createTables();
 }

 public function main()
 {
     $myShapes = array();
     $myFactory = new Factory();
     $myShapes = $myFactory->getShapes();
     foreach ($myShapes as $myShape) {
         $myShape->draw();
     }
 }

 public function testBehaviorOwner()
 {
     $factory = new Factory('http://localhost/');
     $factory->setRequestClassNamespace('\\Sokil\\Rest\\Client\\RequestMock');
     $factory->attachBehavior('my', new \Sokil\Rest\Client\MyBehavior());
     // exec behavior
     $requert = $factory->createRequest('GetRequestMock');
     $this->assertEquals('http://localhost/some/resource', $requert->getRequestUrl());
 }

 /**
  * Crawl comments page
  *
  * @param array $comment previously received comments page link
  * @param bool $proceed  proceed or not with received comments
  * @return array
  */
 public function crawlComments($comments, $proceed = true)
 {
     $importer = new Factory($this->plugin->config);
     $result = $importer->getImporter()->getComments($comments['page']);
     if ($result && $proceed) {
         $this->proceedPostComments($comments['postId'], $result);
     }
     return $result;
 }

 /**
  * Custom validator to check email array
  * 
  * @param  Factory $factory
  * @return $object
  */
 public function validator($factory)
 {
     $landing_page_id = $this->route('landing_pages');
     $campaign_id = Landing_Page::where('id', $landing_page_id)->first()->campaign->id;
     // Validate email users are part of campaign
     $validation = $factory->make($this->all(), $this->rules());
     $validation->each('add_user_email_notification', ['exists:user_has_roles,user_id,campaign_id,' . $campaign_id]);
     return $validation;
 }

 public function testShouldCreateCacheProviderNonConnectable()
 {
     $cacheSettings = ['adapter_name' => 'Array'];
     $factory = new Factory();
     $mockedProxy = $this->getMockBuilder('Pcelta\\Doctrine\\Cache\\Proxy')->setMethods(['getAdapter'])->getMock();
     $mockedProxy->expects($this->never())->method('getAdapter');
     $factory->setProxy($mockedProxy);
     $result = $factory->create($cacheSettings);
     $this->assertInstanceOf('Doctrine\\Common\\Cache\\ArrayCache', $result);
 }

 /**
  *
  */
 public function __construct()
 {
     $factory = new Factory();
     $list = array();
     foreach ($this->regions as $regionDefinition) {
         $region = $factory->createFromArray($regionDefinition);
         $list[$region->getCode()] = $region;
     }
     parent::__construct($list);
 }

 /**
  * Repository constructor
  *
  * @param string  $name       Repository's name
  * @param Factory $factory    Factory
  * @param array   $parameters Parameters of the repository
  *
  * @api
  */
 public function __construct($name, Factory $factory, array $parameters = array())
 {
     $this->name = $name;
     $this->factory = $factory;
     $this->parameters = $parameters;
     $this->repository = function () use($factory, $parameters) {
         $factoryInstance = $factory->instanciate();
         return $factoryInstance->getRepository($parameters);
     };
 }

 public function registerEnvironment()
 {
     $this->app->bindShared('view', function ($app) {
         $resolver = $app['view.engine.resolver'];
         $finder = $app['view.finder'];
         $env = new Factory($resolver, $finder, $app['events']);
         $env->setContainer($app);
         $env->share('app', $app);
         return $env;
     });
 }

 public function addFrozenItem($name)
 {
     if (preg_match("/[0-9]+/", $name)) {
         $this->addEAN($name, false);
     } elseif (trim($name) != "") {
         $F = new Factory("Gefrierschrank");
         $F->sA("GefrierschrankName", $name);
         $F->sA("GefrierschrankAdded", "1");
         $F->store();
     }
     echo $this->getFrozenListTable();
 }