public function testProxy()
 {
     $expect = "<strong>I’ll be back!</strong>";
     $proxy = new Proxy();
     $result = $proxy->send();
     $this->assertEquals($result, $expect);
 }

 public function testGetAdditionalHtmlAttribute()
 {
     $this->objectManagerMock->expects($this->once())->method('create')->with('Magento\\Framework\\Translate\\Inline')->will($this->returnValue($this->translateMock));
     $this->objectManagerMock->expects($this->never())->method('get');
     $this->translateMock->expects($this->exactly(2))->method('getAdditionalHtmlAttribute')->with($this->logicalOr('some_value', null))->will($this->returnArgument(0));
     $model = new Proxy($this->objectManagerMock, 'Magento\\Framework\\Translate\\Inline', false);
     $this->assertEquals('some_value', $model->getAdditionalHtmlAttribute('some_value'));
     $this->assertNull($model->getAdditionalHtmlAttribute());
 }

 function enable_step($old_state)
 {
     global $phpEx;
     global $phpbb_root_path;
     global $request;
     /*Require WP includes*/
     $proxy = new Proxy();
     $proxy->cache();
     //AAAAAAAAAAAAND let's hope it works?
     // Run parent enable step method
     return parent::enable_step($old_state);
 }

function getProxy()
{
    if (!empty($_GET['radomProxy'])) {
        require __DIR__ . '/library/getProxy.php';
        $hoge = new Proxy();
        $hoge->setRandomProxyAndPort();
        $proxy = $hoge->getProxy() . ":" . $hoge->getPort();
        return $proxy;
    } else {
        return false;
    }
}

 /**
  * Tests setting the name and body using the Notification class Constructor.
  */
 public function testConstructor()
 {
     // Create a new Proxy using the Constructor to set the name and data
     $proxy = new Proxy('colors', array('red', 'green', 'blue'));
     $data = $proxy->getData();
     // test assertions
     $this->assertNotNull($proxy, "Expecting proxy not null");
     $this->assertTrue($proxy->getProxyName() == 'colors', "Expecting proxy.getProxyName() == 'colors'");
     $this->assertTrue(sizeof($data) == 3, "Expecting data.length == 3");
     $this->assertTrue($data[0] == 'red', "Expecting data[0] == 'red'");
     $this->assertTrue($data[1] == 'green', "Expecting data[1] == 'green'");
     $this->assertTrue($data[2] == 'blue', "Expecting data[2] == 'blue'");
 }

 /**
  * check authorize info
  */
 private function cAuthorize()
 {
     $return = Proxy::getAuthorize();
     if ($return == false) {
         $this->safeInfo[] = array('content' => '欢迎您使用尚普商城。');
     }
 }

 public function getUrl($url, $timeout = 5)
 {
     $this->initInstance();
     curl_setopt($this->ch, CURLOPT_URL, $url);
     curl_setopt($this->ch, CURLOPT_TIMEOUT, intval($timeout));
     if ($this->cookie) {
         curl_setopt($this->ch, CURLOPT_COOKIE, $this->cookie);
     }
     if (is_array($this->use_proxy)) {
         $retry = $this->use_proxy ? 1 : 3;
         for ($i = 0; $i < $retry; $i++) {
             $proxy = $this->use_proxy ?: Proxy::rand();
             //允许手动指定Proxy配置
             curl_setopt($this->ch, CURLOPT_CONNECTTIMEOUT, $proxy['delay']);
             curl_setopt($this->ch, CURLOPT_PROXY, $proxy['host']);
             curl_setopt($this->ch, CURLOPT_PROXYTYPE, $proxy['type']);
             $result = curl_exec($this->ch);
             if ($result && !curl_errno($this->ch)) {
                 break;
             }
         }
     } else {
         $result = curl_exec($this->ch);
     }
     return curl_errno($this->ch) ? false : $result;
 }

 function errorHandler()
 {
     if (!empty($this->current_fd)) {
         $rsp = Proxy::shutdown_handler();
         $rsp && $this->serv->send($this->current_fd, $rsp);
     }
 }

 /**
  * Deploy
  *
  * @param   remote.server.deploy.Deployable deployment
  */
 public function deployBean($deployment)
 {
     if ($deployment instanceof IncompleteDeployment) {
         throw new DeployException('Incomplete deployment originating from ' . $deployment->origin, $deployment->cause);
     }
     $this->cat && $this->cat->info($this->getClassName(), 'Begin deployment of', $deployment);
     // Register beans classloader. This classloader must be put at the beginning
     // to prevent loading of the home interface not implmenenting BeanInterface
     $cl = $deployment->getClassLoader();
     ClassLoader::getDefault()->registerLoader($cl, TRUE);
     $impl = $cl->loadClass($deployment->getImplementation());
     $interface = $cl->loadClass($deployment->getInterface());
     $directoryName = $deployment->getDirectoryName();
     // Fetch naming directory
     $directory = NamingDirectory::getInstance();
     // Create beanContainer
     // TBI: Check which kind of bean container has to be created
     $beanContainer = StatelessSessionBeanContainer::forClass($impl);
     $this->cat && $beanContainer->setTrace($this->cat);
     // Create invocation handler
     $invocationHandler = new ContainerInvocationHandler();
     $invocationHandler->setContainer($beanContainer);
     // Now bind into directory
     $directory->bind($directoryName, Proxy::newProxyInstance($cl, array($interface), $invocationHandler));
     $this->cat && $this->cat->info($this->getClassName(), 'End deployment of', $impl->getName(), 'with ND entry', $directoryName);
     return $beanContainer;
 }

 /**
  * Parses an XML string and returns a Proxy for it.
  * @param string|Proxy|null $xml
  * @param string $encoding The character set to use, defaults to UTF-8
  * @return Proxy
  */
 public function parse($xml = null, $encoding = null)
 {
     if (!$xml) {
         return Proxy(null);
     }
     if ($xml instanceof Proxy) {
         // already parsed
         return $xml->cloneNode();
     }
     $xml = (string) $xml;
     try {
         return $this->parseFull($xml, $encoding);
     } catch (\arc\UnknownError $e) {
         return $this->parsePartial($xml, $encoding);
     }
 }

 public static function create($batchId, $urlId, $proxyId, $updateBatch)
 {
     SystemUtility::log('PING START', true);
     SystemUtility::log('GATHERING DATA');
     # Update batch here in case something crashes below
     if ($updateBatch) {
         SystemUtility::log('THIS IS THE LAST PING IN BATCH');
         $batch = \Batch::findFirst();
         $batch->updatedAt = SystemUtility::getSqlNowDate();
         $batch->save();
     }
     $url = \Url::findFirst($urlId);
     $proxy = \Proxy::findFirst($proxyId);
     # Create new ping
     $ping = new \Ping();
     $ping->batchId = $batchId;
     $ping->proxyId = $proxyId;
     $ping->httpCode = self::HTTP_CODE_IN_PROGRESS;
     $ping->duration = 0;
     $ping->error = '';
     $ping->save();
     self::doPing($ping, $url, $proxy);
     SystemUtility::log('PING END');
     return $ping;
 }

 public function model($route)
 {
     // Sanitize the call
     $route = str_replace('../', '', (string) $route);
     $file = DIR_APPLICATION . 'model/' . $route . '.php';
     $class = 'Model' . preg_replace('/[^a-zA-Z0-9]/', '', $route);
     if (is_file($file)) {
         include_once $file;
         $proxy = new Proxy();
         foreach (get_class_methods($class) as $method) {
             $proxy->attach($method, $this->closure($this->registry, $route . '/' . $method));
         }
         $this->registry->set('model_' . str_replace(array('/', '-', '.'), array('_', '', ''), (string) $route), $proxy);
     } else {
         throw new \Exception('Error: Could not load model ' . $route . '!');
     }
 }

 public function run()
 {
     $i = 0;
     while ($i < 100) {
         $i++;
         $proxy = $this->proxy->getWorks();
         $this->connector->setProxy($proxy);
         $list = $this->parserFreeProxy->getIpList();
         //$response = $this->connector->getResponse('https://api.ipify.org');
         /*if($response == $proxy->ip){
         			echo 'works';
         		} else {
         			echo 'not wokrs';
         		}*/
         exit;
     }
 }

 /**
  * Returns a value for the given serialized string
  *
  * @param   server.protocol.Serializer serializer
  * @param   remote.protocol.SerializedData serialized
  * @param   [:var] context default array()
  * @return  var
  */
 public function valueOf($serializer, $serialized, $context = array())
 {
     $oid = $serialized->consumeSize();
     $serialized->consume('{');
     $interface = $serializer->valueOf($serialized, $context);
     $serialized->consume('}');
     return Proxy::newProxyInstance(ClassLoader::getDefault(), array(XPClass::forName($serializer->packageMapping($interface))), RemoteInvocationHandler::newInstance((int) $oid, $context['handler']));
 }

 /**
  * The start action, it shows the "search" view
  */
 public function indexAction()
 {
     $searchParams = ['ping.batchId' => 'batchId', 'ping.proxyId' => 'proxyId', 'b.urlId' => 'urlId'];
     Tag::setDefaults(array('urlId' => $this->request->get('urlId'), 'proxyId' => $this->request->get('proxyId'), 'pingId' => $this->request->get('pingId'), 'batchId' => $this->request->get('batchId')));
     $this->view->pings = $this->searchPings($searchParams);
     $this->view->proxies = Proxy::find();
     $this->view->urls = Url::find();
     $this->view->batches = Batch::find();
     #$this->view->disable();
 }

 /**
  * Shows the view to create a "new" product
  */
 public function newAction()
 {
     $reflection = new FormReflectionManager($this->flash);
     $this->view->name = $reflection->get('name');
     $this->view->urls = Url::find() ?: array();
     $this->view->proxies = Proxy::find() ?: array();
     $this->view->reflected_proxyId = explode(',', $reflection->get('proxyId'));
     $this->view->reflected_address = explode(',', $reflection->get('address'));
     #$this->view->disable();
 }

 public static function main(array $args = array())
 {
     $gumballMachine = NULL;
     $count = 0;
     if (count($args) < 2) {
         println("GumballMachine <name> <inventory>");
         exit;
     }
     $count = $args[1];
     $gumballMachine = new GumballMachine($args[0], $count);
     Proxy::runServer($args[0], $gumballMachine, "GumballMachineRemote");
 }

 public static function go($nm_page)
 {
     if ($nm_page == Forward::$_BACK) {
         Forward::goBack();
     } else {
         if ($nm_page == Forward::$_BLOCK) {
             //fica parado
         } else {
             Forward::goURL(Proxy::page($nm_page));
         }
     }
 }

 public static function main(array $args = array())
 {
     $location = array("localhost:10000", "localhost:10000", "localhost:10000");
     $monitor = array();
     for ($i = 0; $i < count($location); $i++) {
         $machine = Proxy::getProxy($location[$i]);
         $monitor[$i] = new GumballMonitor($machine);
         println($monitor[$i]);
     }
     for ($i = 0; $i < count($monitor); $i++) {
         $monitor[$i]->report();
     }
 }

 protected function setOptionProxy(&$descriptor)
 {
     if (is_object($this->proxy)) {
         $proxy = $this->proxy->getProxy($descriptor['descriptor_key'], $descriptor['option'][CURLOPT_URL]);
         if (is_string($proxy['proxy']) && DryPath::isIp($proxy['proxy'])) {
             $this->setOption($descriptor, CURLOPT_PROXY, $proxy['proxy']);
         } else {
             $descriptor['option'][CURLOPT_URL] = false;
         }
     } elseif (is_string($this->proxy)) {
         $this->setOption($descriptor, CURLOPT_PROXY, $this->proxy);
     }
 }