text:
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="40dp"
    android:height="40dp"
    android:viewportWidth="40"
    android:viewportHeight="40"
    android:tint="?attr/colorControlNormal">
  <path
      android:fillColor="@android:color/white"
      android:pathData="M18.25,31.833 L24.25,21.5H3.5V18.5H24.25L18.25,8.167L36.875,20Z"/>
</vector>


text:
#ifndef GCANVAS_GFRAMEBUFFEROBJECT_H
#define GCANVAS_GFRAMEBUFFEROBJECT_H

#include "GTexture.h"
#include "GPoint.h"
#include "GTransform.h"

#include <map>
#include <string>
#include <vector>
#include <map>
#include <set>

struct GCanvasLog;

class GFrameBufferObject
{
public:
    GFrameBufferObject();

    ~GFrameBufferObject();

    GFrameBufferObject(GFrameBufferObject&& src);

    bool InitFBO(int width, int height, GColorRGBA color, std::vector<GCanvasLog> *errVec = nullptr);

    bool InitFBO(int width, int height, GColorRGBA color, bool enableMsaa, std::vector<GCanvasLog> *errVec = nullptr);

    void BindFBO();

    void UnbindFBO();

    void DeleteFBO();

    int DetachTexture();

    void GLClearScreen(GColorRGBA color);

    int Width()
    {
        return mFboTexture.GetWidth();
    }

    int Height()
    {
        return mFboTexture.GetHeight();

    }

    void SetSize(int w, int h)
    {
        mWidth=w;
        mHeight=h;
    }
    int ExpectedWidth()
    {
        return mWidth;
    }

    int ExpectedHeight()
    {
        return mHeight;
    }

    bool mIsFboSupported = true;

    GTexture mFboTexture;
    GLuint mFboFrame = 0;
    GLuint mFboStencil = 0;
    GLint mSaveFboFrame = 0;
    GTransform mSavedTransform;

    int mWidth;
    int mHeight;
};

typedef std::shared_ptr<GFrameBufferObject> GFrameBufferObjectPtr;

class GFrameBufferObjectPool
{
public:
    typedef std::pair<int, int> Key;
    typedef std::multimap<Key, GFrameBufferObject*> Map;

public:
    GFrameBufferObjectPool() = default;

    ~GFrameBufferObjectPool()
    {
        for(auto& i : mPool)
        {
            delete i.second;
        }
    }

    GFrameBufferObjectPtr GetFrameBuffer(int width, int height);

private:

    Map mPool;
};

#endif /* GCANVAS_GFRAMEBUFFEROBJECT_H */

redpajama_set_name: RedPajamaGithub


text:
"""Setup script for log service SDK.

You need to install google protocol buffer, setuptools and python-requests.
https://code.google.com/p/protobuf/
https://pypi.python.org/pypi/setuptools
http://docs.python-requests.org/

Depending on your version of Python, these libraries may also should be installed:
http://pypi.python.org/pypi/simplejson/

"""

try:
    from setuptools import setup
except ImportError:
    from distutils.core import setup

import sys
import re

if sys.version_info[:2] == (2, 6):
    install_requires = ['requests', 'protobuf <= 3.4.0', 'six', 'enum34', 'futures', 'python-dateutil']
elif sys.version_info[0] == 2:
    install_requires = ['requests', 'protobuf', 'six', 'enum34', 'futures', 'python-dateutil']
elif sys.version_info[0] == 3:
    install_requires = ['requests', 'protobuf', 'six', 'enum34', 'python-dateutil']

packages = [
            'aliyun',
            'aliyun.log',
            'aliyun.log.consumer',
            'aliyun.log.es_migration'
            ]

version = ''
with open('aliyun/log/version.py', 'r') as fd:
    version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]',
                        fd.read(), re.MULTILINE).group(1)

classifiers = [
            'Development Status :: 5 - Production/Stable',
            'License :: OSI Approved :: MIT License',
            'Operating System :: OS Independent',
            'Programming Language :: Python :: 2.6',
            'Programming Language :: Python :: 2.7',
            'Programming Language :: Python :: 3.3',
            'Programming Language :: Python :: 3.4',
            'Programming Language :: Python :: 3.5',
            'Programming Language :: Python :: 3.6',
            'Programming Language :: Python :: Implementation :: PyPy'
    ]

long_description = """
Python SDK for Alicloud Log Service
http://aliyun-log-python-sdk.readthedocs.io
"""

setup(
      name='aliyun-log-python-sdk',
      version=version,
      description='Aliyun log service Python client SDK',
      author='Aliyun',
      url='https://github.com/aliyun/aliyun-log-python-sdk',
      install_requires=install_requires,
      packages=packages,
      classifiers=classifiers,
      long_description=long_description
     )


text:
namespace SurgSim
{

namespace Collision
{
class ContactCalculation;
}

namespace Framework
{
class Logger;
}

namespace Physics
{
class PhysicsManagerState;

/// Computation to determine the contacts between a list of CollisionPairs.
/// This Computation class takes a list of representations, it will generate a list of collision pairs
/// from this list on every frame, for each CollisionPair, it uses a two dimensional table of
/// function objects (ContactCalculation) to determine how to calculate a contact between the two
/// members of each pair, if no specific function exists a default function will be used.
/// will update the collision pairs accordingly.
/// \note When a new ContactCalculation type gets implemented, the type needs to be registered with the table
/// inside of ContactCalculation
class PrepareCollisionPairs : public Computation
{
public:
	/// Constructor
	/// \param doCopyState Specify if the output state in Computation::Update() is a copy or not of the input state
	explicit PrepareCollisionPairs(bool doCopyState = false);

	SURGSIM_CLASSNAME(SurgSim::Physics::PrepareCollisionPairs);

	/// Destructor
	virtual ~PrepareCollisionPairs();

protected:
	std::shared_ptr<PhysicsManagerState> doUpdate(const double& dt, const std::shared_ptr<PhysicsManagerState>& state)
		override;

private:
	/// The time since the collision pairs were last logged.
	double m_timeSinceLog;

	/// The logger.
	std::shared_ptr<Framework::Logger> m_logger;
};

}; // Physics
}; // SurgSim

#endif // SURGSIM_PHYSICS_PREPARECOLLISIONPAIRS_H


text:
package models.dao;

import java.util.Random;

import models.Sample;
import play.utils.dao.DAOListener;

public class SampleDAOListener implements DAOListener<Long, Sample> {

	Random random = new Random();

	@Override
	public void beforeCreate(Sample m) {
		m.setRandomValue(random.nextInt());
	}

	@Override
	public void beforeUpdate(Sample m) {
		m.setRandomValue(random.nextInt());
	}

	@Override
	public void afterCreate(Long key, Sample m) {
	}

	@Override
	public void afterRemove(Long key, Sample m) {
	}

	@Override
	public void afterUpdate(Sample m) {
	}

	@Override
	public void beforeRemove(Long key) {
	}

}


text:
package DBProxy.MySQL.Protocol;

import java.util.ArrayList;

public class Com_Ping extends Packet {

    public ArrayList<byte[]> getPayload() {
        ArrayList<byte[]> payload = new ArrayList<byte[]>();

        payload.add(Proto.build_byte(Flags.COM_PING));

        return payload;
    }

    public static Com_Ping loadFromPacket(byte[] packet) {
        Com_Ping obj = new Com_Ping();
        Proto proto = new Proto(packet, 3);

        obj.sequenceId = proto.get_fixed_int(1);

        return obj;
    }
}


text:
package org.sirix.node.json;

import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import org.jetbrains.annotations.NotNull;
import org.sirix.api.visitor.JsonNodeVisitor;
import org.sirix.api.visitor.VisitResult;
import org.sirix.node.NodeKind;
import org.sirix.node.delegates.StructNodeDelegate;
import org.sirix.node.immutable.json.ImmutableNullNode;

/**
 * @author Johannes Lichtenberger mail
 */
public final class NullNode extends AbstractNullNode {

  /**
   * Constructor.
   *
   * @param structNodeDelegate {@link StructNodeDelegate} to be set
   */
  public NullNode(final StructNodeDelegate structNodeDelegate) {
    super(structNodeDelegate);
  }

  @Override
  public NodeKind getKind() {
    return NodeKind.NULL_VALUE;
  }

  @Override
  public VisitResult acceptVisitor(final JsonNodeVisitor visitor) {
    return visitor.visit(ImmutableNullNode.of(this));
  }

  @Override
  public @NotNull String toString() {
    return MoreObjects.toStringHelper(this).toString();
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  @Override
  public boolean equals(final Object obj) {
    if (!(obj instanceof NullNode))
      return false;

    final NullNode other = (NullNode) obj;
    return Objects.equal(delegate(), other.delegate()) && Objects.equal(getHash(), other.getHash());
  }
}


text:
DEFINE_PROTO_FUZZER(
    const safe_browsing::ClientSidePhishingFuzzerCase& fuzzing_case) {
  if (!fuzzing_case.model().IsInitialized())
    return;

  std::string model_str;
  if (!fuzzing_case.model().SerializeToString(&model_str))
    return;
  std::unique_ptr<safe_browsing::Scorer> scorer(
      safe_browsing::ProtobufModelScorer::Create(model_str, base::File()));
  if (!scorer)
    return;

  safe_browsing::FeatureMap features;
  for (const std::string& boolean_feature : fuzzing_case.boolean_features()) {
    if (!features.AddBooleanFeature(boolean_feature))
      return;
  }

  for (const safe_browsing::ClientSidePhishingFuzzerCase::RealFeature&
           real_feature : fuzzing_case.real_features()) {
    if (!features.AddRealFeature(real_feature.name(), real_feature.value()))
      return;
  }

  scorer->ComputeScore(features);
}


text:
layout: post
title: MyVeryFirstTime - Baby voice Lucy Doll gets two dicks for the first time
titleinfo: pornvd
desc: Watch MyVeryFirstTime - Baby voice Lucy Doll gets two dicks for the first time. Pornhub is the ultimate xxx porn and sex site.
---

MyVeryFirstTime - Baby voice Lucy Doll gets two dicks for the first time

Watch MyVeryFirstTime - Baby voice Lucy Doll gets two dicks for the first time. Pornhub is the ultimate xxx porn and sex site.


text:
namespace SADFM.Data
{
    using System;
    using System.Collections.Generic;

    public partial class FunderAccountPermission
    {
        public System.Guid FunderAccountPermissionId { get; set; }
        public System.Guid FunderId { get; set; }
        public System.Guid AccountId { get; set; }
        public System.Guid PermissionId { get; set; }

        public virtual Account Account { get; set; }
        public virtual ListItem Funder { get; set; }
        public virtual ListItem Permission { get; set; }
    }
}


text:
package org.apereo.cas.configuration.model.core.authentication;

import org.apereo.cas.configuration.model.SpringResourceProperties;
import org.apereo.cas.configuration.support.RequiresModule;

import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;

/**
 * This is {@link GroovyPrincipalTransformationProperties}.
 * Transform the user id prior to executing the authentication sequence.
 * Each authentication strategy in CAS provides settings to properly transform
 * the principal. Refer to the relevant settings for the authentication strategy at hand to learn more.
 *
 * @author Misagh Moayyed
 * @since 5.0.0
 */
@RequiresModule(name = "cas-server-core-authentication", automated = true)
@Getter
@Setter
@Accessors(chain = true)
public class GroovyPrincipalTransformationProperties extends SpringResourceProperties {
    private static final long serialVersionUID = 8079027843747126083L;
}


text:
<?php
$_pluginInfo=array(
	'name'=>'Rediff',
	'version'=>'1.2.2',
	'description'=>"Get the contacts from a Rediff account",
	'base_version'=>'1.8.1',
	'type'=>'email',
	'check_url'=>'http://mail.rediff.com',
	'requirement'=>'user',
	'allowed_domains'=>false,
	'imported_details'=>array('first_name','email_1'),
	);
/**
 * Rediff Plugin
 *
 * Import user's contacts from Rediff's AddressBook
 *
 * @author OpenInviter
 * @version 1.1.6
 */
class rediff extends openinviter_base
{
	private $login_ok=false;
	public $showContacts=true;
	private $sess_id, $username, $siteAddr;
	public $debug_array=array(
			  'login_post'=>'href="',
			  'url_contacts'=>'var session_id',
			  'url_contacts_form'=>'els',
			  'file_contacts'=>'Name',
	);

	/**
	 * Login function
	 *
	 * Makes all the necessary requests to authenticate
	 * the current user to the server.
	 *
	 * @param string $user The current user.
	 * @param string $pass The password for the current user.
	 * @return bool TRUE if the current user was authenticated successfully, FALSE otherwise.
	 */
	public function login($user,$pass)
		{
		$this->resetDebugger();
		$this->service='rediff';
		$this->service_user=$user;
		$this->service_password=$pass;
		if (!$this->init()) return false;
		$post_elements=array("id"=>"{$user}",
							"num"=>"{$pass}",
							"remember"=>0,
							"r_controller"=>0,
							"r_action"=>0,
							"login"=>$user,
							"passwd"=>$pass,
							"FormName"=>"existing");
		$res=$this->post("http://mail.rediff.com/cgi-bin/login.cgi",$post_elements,true);
		if ($this->checkResponse("login_post",$res))
			$this->updateDebugBuffer('login_post',"http://mail.rediff.com/cgi-bin/login.cgi",'POST',true,$post_elements);
		else
			{
			$this->updateDebugBuffer('login_post',"http://mail.rediff.com/cgi-bin/login.cgi",'POST',false,$post_elements);
			$this->debugRequest();
			$this->stopPlugin();
			return false;
			}
		$url_redirect=$this->getElementString($res,'href="','"');
		$res=$this->get($url_redirect);
		$this->login_ok="http://f1mail.rediff.com/ajaxprism/exportaddrbook?service=outlook";
		$logout_url="http://login.rediff.com/bn/logout.cgi?formname=general&login={$this->username}&session_id={$this->sess_id}&function_name=logout";
		file_put_contents($this->getLogoutPath(),$logout_url);
		return true;
		}

	/**
	 * Get the current user's contacts
	 *
	 * Makes all the necesarry requests to import
	 * the current user's contacts
	 *
	 * @return mixed The array if contacts if importing was successful, FALSE otherwise.
	 */
	public function getMyContacts()
		{
		if (!$this->login_ok)
			{
			$this->debugRequest();
			$this->stopPlugin();
			return false;
			}
		else $url=$this->login_ok;

		$post_elements=array("exporttype"=>"outlook");
		$form_action="http://f1mail.rediff.com/ajaxprism/exportaddrbook?service=outlook";
		$res=$this->post($form_action,$post_elements);
		if ($this->checkResponse("file_contacts",$res))
			$this->updateDebugBuffer('file_contacts',"{$form_action}",'POST',true,$post_elements);
		else
			{
			$this->updateDebugBuffer('file_contacts',"{$form_action}",'POST',false,$post_elements);
			$this->debugRequest();
			$this->stopPlugin();
			return false;
			}
		$temp=$this->parseCSV($res);
		$contacts=array();
		foreach ($temp as $values)
			{
			$name=$values['0'].(empty($values['1'])?'':(empty($values['0'])?'':'-')."{$values['1']}").(empty($values['3'])?'':" \"{$values['3']}\"").(empty($values['2'])?'':' '.$values['2']);
			if (!empty($values['5']))
				$contacts[$values['5']]=array('first_name'=>$name,'email_1'=>$values['5']);
			}

		foreach ($contacts as $email=>$name) if (!$this->isEmail($email)) unset($contacts[$email]);
		return $this->returnContacts($contacts);
		}

	/**
	 * Terminate session
	 *
	 * Terminates the current user's session,
	 * debugs the request and reset's the internal
	 * debudder.
	 *
	 * @return bool TRUE if the session was terminated successfully, FALSE otherwise.
	 */
	public function logout()
		{
		if (!$this->checkSession()) return false;
		if (file_exists($this->getLogoutPath()))
			{
			 $url_logout=file_get_contents($this->getLogoutPath());
			if (!empty($url_logout)) $res=$this->get($url_logout);
			}
			$this->debugRequest();
			$this->resetDebugger();
			$this->stopPlugin();
		}
}
?>


text:
import { promises as fs } from 'fs';
import { basename } from 'path';

const prefix = 'asset-url:';

export default function assetPlugin({ hashChunk = () => true }) {
  return {
    name: 'asset-plugin',
    async resolveId(id, importer) {
      if (!id.startsWith(prefix)) return;
      return (
        prefix + (await this.resolve(id.slice(prefix.length), importer)).id
      );
    },
    async load(id) {
      if (!id.startsWith(prefix)) return;
      const realId = id.slice(prefix.length);
      const emitOpts = {
        type: 'asset',
        source: await fs.readFile(realId),
      };
      this.addWatchFile(realId);

      emitOpts[hashChunk(realId) ? 'name' : 'fileName'] = basename(realId);

      return `export default import.meta.ROLLUP_FILE_URL_${this.emitFile(
        emitOpts,
      )}`;
    },
  };
}


text:
<?php
namespace TYPO3\Flow\Object\Proxy;

use Doctrine\ORM\Mapping as ORM;
use TYPO3\Flow\Annotations as Flow;

/**
 * Representation of a Proxy Class during rendering time
 *
 * @Flow\Proxy(false)
 */
class ProxyClass
{
    /**
     * Namespace, extracted from the fully qualified original class name
     *
     * @var string
     */
    protected $namespace = '';

    /**
     * The original class name
     *
     * @var string
     */
    protected $originalClassName;

    /**
     * Fully qualified class name of the original class
     *
     * @var string
     */
    protected $fullOriginalClassName;

    /**
     * @var \TYPO3\Flow\Object\Proxy\ProxyConstructor
     */
    protected $constructor;

    /**
     * @var array
     */
    protected $methods = [];

    /**
     * @var array
     */
    protected $constants = [];

    /**
     * Note: Not using ProxyInterface::class here, since the interface names must have a leading backslash.
     *
     * @var array
     */
    protected $interfaces = array('\TYPO3\Flow\Object\Proxy\ProxyInterface');

    /**
     * @var array
     */
    protected $traits = [];

    /**
     * @var array
     */
    protected $properties = [];

    /**
     * @var \TYPO3\Flow\Reflection\ReflectionService
     */
    protected $reflectionService;

    /**
     * Creates a new ProxyClass instance.
     *
     * @param string $fullOriginalClassName The fully qualified class name of the original class
     */
    public function __construct($fullOriginalClassName)
    {
        if (strpos($fullOriginalClassName, '\\') === false) {
            $this->originalClassName = $fullOriginalClassName;
        } else {
            $this->namespace = substr($fullOriginalClassName, 0, strrpos($fullOriginalClassName, '\\'));
            $this->originalClassName = substr($fullOriginalClassName, strlen($this->namespace) + 1);
        }
        $this->fullOriginalClassName = $fullOriginalClassName;
    }

    /**
     * Injects the Reflection Service
     *
     * @param \TYPO3\Flow\Reflection\ReflectionService $reflectionService
     * @return void
     */
    public function injectReflectionService(\TYPO3\Flow\Reflection\ReflectionService $reflectionService)
    {
        $this->reflectionService = $reflectionService;
    }

    /**
     * Returns the ProxyConstructor for this ProxyClass. Creates it if needed.
     *
     * @return \TYPO3\Flow\Object\Proxy\ProxyConstructor
     */
    public function getConstructor()
    {
        if (!isset($this->constructor)) {
            $this->constructor = new \TYPO3\Flow\Object\Proxy\ProxyConstructor($this->fullOriginalClassName);
            $this->constructor->injectReflectionService($this->reflectionService);
        }
        return $this->constructor;
    }

    /**
     * Returns the named ProxyMethod for this ProxyClass. Creates it if needed.
     *
     * @param string $methodName The name of the methods to return
     * @return \TYPO3\Flow\Object\Proxy\ProxyMethod
     */
    public function getMethod($methodName)
    {
        if ($methodName === '__construct') {
            return $this->getConstructor();
        }
        if (!isset($this->methods[$methodName])) {
            $this->methods[$methodName] = new \TYPO3\Flow\Object\Proxy\ProxyMethod($this->fullOriginalClassName, $methodName);
            $this->methods[$methodName]->injectReflectionService($this->reflectionService);
        }
        return $this->methods[$methodName];
    }

    /**
     * Adds a constant to this proxy class
     *
     * @param string $name Name of the constant. Should be ALL_UPPERCASE_WITH_UNDERSCORES
     * @param string $valueCode PHP code which assigns the value. Example: 'foo' (including quotes!)
     * @return void
     */
    public function addConstant($name, $valueCode)
    {
        $this->constants[$name] = $valueCode;
    }

    /**
     * Adds a class property to this proxy class
     *
     * @param string $name Name of the property
     * @param string $initialValueCode PHP code of the initial value assignment
     * @param string $visibility
     * @param string $docComment
     * @return void
     */
    public function addProperty($name, $initialValueCode, $visibility = 'private', $docComment = '')
    {
        $this->properties[$name] = array(
            'initialValueCode' => $initialValueCode,
            'visibility' => $visibility,
            'docComment' => $docComment
        );
    }

    /**
     * Adds one or more interfaces to the "implements" section of the class definition.
     *
     * Note that the passed interface names must already have a leading backslash,
     * for example "\TYPO3\Flow\Foo\BarInterface".
     *
     * @param array $interfaceNames Fully qualified names of the interfaces to introduce
     * @return void
     */
    public function addInterfaces(array $interfaceNames)
    {
        $this->interfaces = array_merge($this->interfaces, $interfaceNames);
    }

    /**
     * Adds one or more traits to the class definition.
     *
     * Note that the passed trait names must have a leading backslash,
     * for example "\TYPO3\Flow\Object\Proxy\PropertyInjectionTrait".
     *
     * @param array $traitNames
     * @return void
     */
    public function addTraits(array $traitNames)
    {
        $this->traits = array_merge($this->traits, $traitNames);
    }

    /**
     * Renders and returns the PHP code for this ProxyClass.
     *
     * @return string
     */
    public function render()
    {
        $namespace = $this->namespace;
        $proxyClassName = $this->originalClassName;
        $originalClassName = $this->originalClassName . \TYPO3\Flow\Object\Proxy\Compiler::ORIGINAL_CLASSNAME_SUFFIX;
        $abstractKeyword = $this->reflectionService->isClassAbstract($this->fullOriginalClassName) ? 'abstract ' : '';

        $constantsCode = $this->renderConstantsCode();
        $propertiesCode = $this->renderPropertiesCode();
        $traitsCode = $this->renderTraitsCode();

        $methodsCode = isset($this->constructor) ? $this->constructor->render() : '';
        foreach ($this->methods as $proxyMethod) {
            $methodsCode .= $proxyMethod->render();
        }

        if ($methodsCode . $constantsCode === '') {
            return '';
        }
        $classCode = ($namespace !== '' ? 'namespace ' . $namespace . ";\n\n" : '') .
            "use Doctrine\\ORM\\Mapping as ORM;\n" .
            "use TYPO3\\Flow\\Annotations as Flow;\n" .
            "\n" .
            $this->buildClassDocumentation() .
            $abstractKeyword . 'class ' . $proxyClassName . ' extends ' . $originalClassName . ' implements ' . implode(', ', array_unique($this->interfaces)) . " {\n\n" .
            $traitsCode .
            $constantsCode .
            $propertiesCode .
            $methodsCode .
            '}';
        return $classCode;
    }

    /**
     * Builds the class documentation block for the specified class keeping doc comments and vital annotations
     *
     * @return string $methodDocumentation DocComment for the given method
     */
    protected function buildClassDocumentation()
    {
        $classDocumentation = "/**\n";

        $classReflection = new \TYPO3\Flow\Reflection\ClassReflection($this->fullOriginalClassName);
        $classDescription = $classReflection->getDescription();
        $classDocumentation .= ' * ' . str_replace("\n", "\n * ", $classDescription) . "\n";

        foreach ($this->reflectionService->getClassAnnotations($this->fullOriginalClassName) as $annotation) {
            $classDocumentation .= ' * ' . \TYPO3\Flow\Object\Proxy\Compiler::renderAnnotation($annotation) . "\n";
        }

        $classDocumentation .= " */\n";
        return $classDocumentation;
    }

    /**
     * Renders code for the added class constants
     *
     * @return string
     */
    protected function renderConstantsCode()
    {
        $code = '';
        foreach ($this->constants as $name => $valueCode) {
            $code .= '    const ' . $name . ' = ' . $valueCode . ";\n\n";
        }
        return $code;
    }

    /**
     * Renders code for the added class properties
     *
     * @return string
     */
    protected function renderPropertiesCode()
    {
        $code = '';
        foreach ($this->properties as $name => $attributes) {
            if (!empty($attributes['docComment'])) {
                $code .= '    ' . $attributes['docComment'] . "\n";
            }
            $code .= '    ' . $attributes['visibility'] . ' $' . $name . ' = ' . $attributes['initialValueCode'] . ";\n\n";
        }
        return $code;
    }

    /**
     * Renders code for added traits
     *
     * @return string
     */
    protected function renderTraitsCode()
    {
        if ($this->traits === []) {
            return '';
        }

        return '    use ' . implode(', ', $this->traits) . ";\n\n";
    }
}


text:
/*
 * UBI scanning unit.
 *
 * This unit is responsible for scanning the flash media, checking UBI
 * headers and providing complete information about the UBI flash image.
 *
 * The scanning information is represented by a &struct ubi_scan_info' object.
 * Information about found volumes is represented by &struct ubi_scan_volume
 * objects which are kept in volume RB-tree with root at the @volumes field.
 * The RB-tree is indexed by the volume ID.
 *
 * Found logical eraseblocks are represented by &struct ubi_scan_leb objects.
 * These objects are kept in per-volume RB-trees with the root at the
 * corresponding &struct ubi_scan_volume object. To put it differently, we keep
 * an RB-tree of per-volume objects and each of these objects is the root of
 * RB-tree of per-eraseblock objects.
 *
 * Corrupted physical eraseblocks are put to the @corr list, free physical
 * eraseblocks are put to the @free list and the physical eraseblock to be
 * erased are put to the @erase list.
 */

#ifdef UBI_LINUX
#include <linux/err.h>
#include <linux/crc32.h>
#include <asm/div64.h>
#endif

#include <ubi_uboot.h>
#include "ubi.h"

#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
static int paranoid_check_si(struct ubi_device *ubi, struct ubi_scan_info *si);
#else
#define paranoid_check_si(ubi, si) 0
#endif

/* Temporary variables used during scanning */
static struct ubi_ec_hdr *ech;
static struct ubi_vid_hdr *vidh;

/**
 * add_to_list - add physical eraseblock to a list.
 * @si: scanning information
 * @pnum: physical eraseblock number to add
 * @ec: erase counter of the physical eraseblock
 * @list: the list to add to
 *
 * This function adds physical eraseblock @pnum to free, erase, corrupted or
 * alien lists. Returns zero in case of success and a negative error code in
 * case of failure.
 */
static int add_to_list(struct ubi_scan_info *si, int pnum, int ec,
		       struct list_head *list)
{
	struct ubi_scan_leb *seb;

	if (list == &si->free)
		dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
	else if (list == &si->erase)
		dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
	else if (list == &si->corr)
		dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
	else if (list == &si->alien)
		dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
	else
		BUG();

	seb = kmalloc(sizeof(struct ubi_scan_leb), GFP_KERNEL);
	if (!seb)
		return -ENOMEM;

	seb->pnum = pnum;
	seb->ec = ec;
	list_add_tail(&seb->u.list, list);
	return 0;
}

/**
 * validate_vid_hdr - check that volume identifier header is correct and
 * consistent.
 * @vid_hdr: the volume identifier header to check
 * @sv: information about the volume this logical eraseblock belongs to
 * @pnum: physical eraseblock number the VID header came from
 *
 * This function checks that data stored in @vid_hdr is consistent. Returns
 * non-zero if an inconsistency was found and zero if not.
 *
 * Note, UBI does sanity check of everything it reads from the flash media.
 * Most of the checks are done in the I/O unit. Here we check that the
 * information in the VID header is consistent to the information in other VID
 * headers of the same volume.
 */
static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,
			    const struct ubi_scan_volume *sv, int pnum)
{
	int vol_type = vid_hdr->vol_type;
	int vol_id = be32_to_cpu(vid_hdr->vol_id);
	int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
	int data_pad = be32_to_cpu(vid_hdr->data_pad);

	if (sv->leb_count != 0) {
		int sv_vol_type;

		/*
		 * This is not the first logical eraseblock belonging to this
		 * volume. Ensure that the data in its VID header is consistent
		 * to the data in previous logical eraseblock headers.
		 */

		if (vol_id != sv->vol_id) {
			dbg_err("inconsistent vol_id");
			goto bad;
		}

		if (sv->vol_type == UBI_STATIC_VOLUME)
			sv_vol_type = UBI_VID_STATIC;
		else
			sv_vol_type = UBI_VID_DYNAMIC;

		if (vol_type != sv_vol_type) {
			dbg_err("inconsistent vol_type");
			goto bad;
		}

		if (used_ebs != sv->used_ebs) {
			dbg_err("inconsistent used_ebs");
			goto bad;
		}

		if (data_pad != sv->data_pad) {
			dbg_err("inconsistent data_pad");
			goto bad;
		}
	}

	return 0;

bad:
	ubi_err("inconsistent VID header at PEB %d", pnum);
	ubi_dbg_dump_vid_hdr(vid_hdr);
	ubi_dbg_dump_sv(sv);
	return -EINVAL;
}

/**
 * add_volume - add volume to the scanning information.
 * @si: scanning information
 * @vol_id: ID of the volume to add
 * @pnum: physical eraseblock number
 * @vid_hdr: volume identifier header
 *
 * If the volume corresponding to the @vid_hdr logical eraseblock is already
 * present in the scanning information, this function does nothing. Otherwise
 * it adds corresponding volume to the scanning information. Returns a pointer
 * to the scanning volume object in case of success and a negative error code
 * in case of failure.
 */
static struct ubi_scan_volume *add_volume(struct ubi_scan_info *si, int vol_id,
					  int pnum,
					  const struct ubi_vid_hdr *vid_hdr)
{
	struct ubi_scan_volume *sv;
	struct rb_node **p = &si->volumes.rb_node, *parent = NULL;

	ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));

	/* Walk the volume RB-tree to look if this volume is already present */
	while (*p) {
		parent = *p;
		sv = rb_entry(parent, struct ubi_scan_volume, rb);

		if (vol_id == sv->vol_id)
			return sv;

		if (vol_id > sv->vol_id)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}

	/* The volume is absent - add it */
	sv = kmalloc(sizeof(struct ubi_scan_volume), GFP_KERNEL);
	if (!sv)
		return ERR_PTR(-ENOMEM);

	sv->highest_lnum = sv->leb_count = 0;
	sv->vol_id = vol_id;
	sv->root = RB_ROOT;
	sv->used_ebs = be32_to_cpu(vid_hdr->used_ebs);
	sv->data_pad = be32_to_cpu(vid_hdr->data_pad);
	sv->compat = vid_hdr->compat;
	sv->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME
							    : UBI_STATIC_VOLUME;
	if (vol_id > si->highest_vol_id)
		si->highest_vol_id = vol_id;

	rb_link_node(&sv->rb, parent, p);
	rb_insert_color(&sv->rb, &si->volumes);
	si->vols_found += 1;
	dbg_bld("added volume %d", vol_id);
	return sv;
}

/**
 * compare_lebs - find out which logical eraseblock is newer.
 * @ubi: UBI device description object
 * @seb: first logical eraseblock to compare
 * @pnum: physical eraseblock number of the second logical eraseblock to
 * compare
 * @vid_hdr: volume identifier header of the second logical eraseblock
 *
 * This function compares 2 copies of a LEB and informs which one is newer. In
 * case of success this function returns a positive value, in case of failure, a
 * negative error code is returned. The success return codes use the following
 * bits:
 *     o bit 0 is cleared: the first PEB (described by @seb) is newer then the
 *       second PEB (described by @pnum and @vid_hdr);
 *     o bit 0 is set: the second PEB is newer;
 *     o bit 1 is cleared: no bit-flips were detected in the newer LEB;
 *     o bit 1 is set: bit-flips were detected in the newer LEB;
 *     o bit 2 is cleared: the older LEB is not corrupted;
 *     o bit 2 is set: the older LEB is corrupted.
 */
static int compare_lebs(struct ubi_device *ubi, const struct ubi_scan_leb *seb,
			int pnum, const struct ubi_vid_hdr *vid_hdr)
{
	void *buf;
	int len, err, second_is_newer, bitflips = 0, corrupted = 0;
	uint32_t data_crc, crc;
	struct ubi_vid_hdr *vh = NULL;
	unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);

	if (seb->sqnum == 0 && sqnum2 == 0) {
		long long abs, v1 = seb->leb_ver, v2 = be32_to_cpu(vid_hdr->leb_ver);

		/*
		 * UBI constantly increases the logical eraseblock version
		 * number and it can overflow. Thus, we have to bear in mind
		 * that versions that are close to %0xFFFFFFFF are less then
		 * versions that are close to %0.
		 *
		 * The UBI WL unit guarantees that the number of pending tasks
		 * is not greater then %0x7FFFFFFF. So, if the difference
		 * between any two versions is greater or equivalent to
		 * %0x7FFFFFFF, there was an overflow and the logical
		 * eraseblock with lower version is actually newer then the one
		 * with higher version.
		 *
		 * FIXME: but this is anyway obsolete and will be removed at
		 * some point.
		 */
		dbg_bld("using old crappy leb_ver stuff");

		if (v1 == v2) {
			ubi_err("PEB %d and PEB %d have the same version %lld",
				seb->pnum, pnum, v1);
			return -EINVAL;
		}

		abs = v1 - v2;
		if (abs < 0)
			abs = -abs;

		if (abs < 0x7FFFFFFF)
			/* Non-overflow situation */
			second_is_newer = (v2 > v1);
		else
			second_is_newer = (v2 < v1);
	} else
		/* Obviously the LEB with lower sequence counter is older */
		second_is_newer = sqnum2 > seb->sqnum;

	/*
	 * Now we know which copy is newer. If the copy flag of the PEB with
	 * newer version is not set, then we just return, otherwise we have to
	 * check data CRC. For the second PEB we already have the VID header,
	 * for the first one - we'll need to re-read it from flash.
	 *
	 * FIXME: this may be optimized so that we wouldn't read twice.
	 */

	if (second_is_newer) {
		if (!vid_hdr->copy_flag) {
			/* It is not a copy, so it is newer */
			dbg_bld("second PEB %d is newer, copy_flag is unset",
				pnum);
			return 1;
		}
	} else {
		pnum = seb->pnum;

		vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
		if (!vh)
			return -ENOMEM;

		err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
		if (err) {
			if (err == UBI_IO_BITFLIPS)
				bitflips = 1;
			else {
				dbg_err("VID of PEB %d header is bad, but it "
					"was OK earlier", pnum);
				if (err > 0)
					err = -EIO;

				goto out_free_vidh;
			}
		}

		if (!vh->copy_flag) {
			/* It is not a copy, so it is newer */
			dbg_bld("first PEB %d is newer, copy_flag is unset",
				pnum);
			err = bitflips << 1;
			goto out_free_vidh;
		}

		vid_hdr = vh;
	}

	/* Read the data of the copy and check the CRC */

	len = be32_to_cpu(vid_hdr->data_size);
	buf = vmalloc(len);
	if (!buf) {
		err = -ENOMEM;
		goto out_free_vidh;
	}

	err = ubi_io_read_data(ubi, buf, pnum, 0, len);
	if (err && err != UBI_IO_BITFLIPS)
		goto out_free_buf;

	data_crc = be32_to_cpu(vid_hdr->data_crc);
	crc = crc32(UBI_CRC32_INIT, buf, len);
	if (crc != data_crc) {
		dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x",
			pnum, crc, data_crc);
		corrupted = 1;
		bitflips = 0;
		second_is_newer = !second_is_newer;
	} else {
		dbg_bld("PEB %d CRC is OK", pnum);
		bitflips = !!err;
	}

	vfree(buf);
	ubi_free_vid_hdr(ubi, vh);

	if (second_is_newer)
		dbg_bld("second PEB %d is newer, copy_flag is set", pnum);
	else
		dbg_bld("first PEB %d is newer, copy_flag is set", pnum);

	return second_is_newer | (bitflips << 1) | (corrupted << 2);

out_free_buf:
	vfree(buf);
out_free_vidh:
	ubi_free_vid_hdr(ubi, vh);
	return err;
}

/**
 * ubi_scan_add_used - add information about a physical eraseblock to the
 * scanning information.
 * @ubi: UBI device description object
 * @si: scanning information
 * @pnum: the physical eraseblock number
 * @ec: erase counter
 * @vid_hdr: the volume identifier header
 * @bitflips: if bit-flips were detected when this physical eraseblock was read
 *
 * This function adds information about a used physical eraseblock to the
 * 'used' tree of the corresponding volume. The function is rather complex
 * because it has to handle cases when this is not the first physical
 * eraseblock belonging to the same logical eraseblock, and the newer one has
 * to be picked, while the older one has to be dropped. This function returns
 * zero in case of success and a negative error code in case of failure.
 */
int ubi_scan_add_used(struct ubi_device *ubi, struct ubi_scan_info *si,
		      int pnum, int ec, const struct ubi_vid_hdr *vid_hdr,
		      int bitflips)
{
	int err, vol_id, lnum;
	uint32_t leb_ver;
	unsigned long long sqnum;
	struct ubi_scan_volume *sv;
	struct ubi_scan_leb *seb;
	struct rb_node **p, *parent = NULL;

	vol_id = be32_to_cpu(vid_hdr->vol_id);
	lnum = be32_to_cpu(vid_hdr->lnum);
	sqnum = be64_to_cpu(vid_hdr->sqnum);
	leb_ver = be32_to_cpu(vid_hdr->leb_ver);

	dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, ver %u, bitflips %d",
		pnum, vol_id, lnum, ec, sqnum, leb_ver, bitflips);

	sv = add_volume(si, vol_id, pnum, vid_hdr);
	if (IS_ERR(sv) < 0)
		return PTR_ERR(sv);

	if (si->max_sqnum < sqnum)
		si->max_sqnum = sqnum;

	/*
	 * Walk the RB-tree of logical eraseblocks of volume @vol_id to look
	 * if this is the first instance of this logical eraseblock or not.
	 */
	p = &sv->root.rb_node;
	while (*p) {
		int cmp_res;

		parent = *p;
		seb = rb_entry(parent, struct ubi_scan_leb, u.rb);
		if (lnum != seb->lnum) {
			if (lnum < seb->lnum)
				p = &(*p)->rb_left;
			else
				p = &(*p)->rb_right;
			continue;
		}

		/*
		 * There is already a physical eraseblock describing the same
		 * logical eraseblock present.
		 */

		dbg_bld("this LEB already exists: PEB %d, sqnum %llu, "
			"LEB ver %u, EC %d", seb->pnum, seb->sqnum,
			seb->leb_ver, seb->ec);

		/*
		 * Make sure that the logical eraseblocks have different
		 * versions. Otherwise the image is bad.
		 */
		if (seb->leb_ver == leb_ver && leb_ver != 0) {
			ubi_err("two LEBs with same version %u", leb_ver);
			ubi_dbg_dump_seb(seb, 0);
			ubi_dbg_dump_vid_hdr(vid_hdr);
			return -EINVAL;
		}

		/*
		 * Make sure that the logical eraseblocks have different
		 * sequence numbers. Otherwise the image is bad.
		 *
		 * FIXME: remove 'sqnum != 0' check when leb_ver is removed.
		 */
		if (seb->sqnum == sqnum && sqnum != 0) {
			ubi_err("two LEBs with same sequence number %llu",
				sqnum);
			ubi_dbg_dump_seb(seb, 0);
			ubi_dbg_dump_vid_hdr(vid_hdr);
			return -EINVAL;
		}

		/*
		 * Now we have to drop the older one and preserve the newer
		 * one.
		 */
		cmp_res = compare_lebs(ubi, seb, pnum, vid_hdr);
		if (cmp_res < 0)
			return cmp_res;

		if (cmp_res & 1) {
			/*
			 * This logical eraseblock is newer then the one
			 * found earlier.
			 */
			err = validate_vid_hdr(vid_hdr, sv, pnum);
			if (err)
				return err;

			if (cmp_res & 4)
				err = add_to_list(si, seb->pnum, seb->ec,
						  &si->corr);
			else
				err = add_to_list(si, seb->pnum, seb->ec,
						  &si->erase);
			if (err)
				return err;

			seb->ec = ec;
			seb->pnum = pnum;
			seb->scrub = ((cmp_res & 2) || bitflips);
			seb->sqnum = sqnum;
			seb->leb_ver = leb_ver;

			if (sv->highest_lnum == lnum)
				sv->last_data_size =
					be32_to_cpu(vid_hdr->data_size);

			return 0;
		} else {
			/*
			 * This logical eraseblock is older then the one found
			 * previously.
			 */
			if (cmp_res & 4)
				return add_to_list(si, pnum, ec, &si->corr);
			else
				return add_to_list(si, pnum, ec, &si->erase);
		}
	}

	/*
	 * We've met this logical eraseblock for the first time, add it to the
	 * scanning information.
	 */

	err = validate_vid_hdr(vid_hdr, sv, pnum);
	if (err)
		return err;

	seb = kmalloc(sizeof(struct ubi_scan_leb), GFP_KERNEL);
	if (!seb)
		return -ENOMEM;

	seb->ec = ec;
	seb->pnum = pnum;
	seb->lnum = lnum;
	seb->sqnum = sqnum;
	seb->scrub = bitflips;
	seb->leb_ver = leb_ver;

	if (sv->highest_lnum <= lnum) {
		sv->highest_lnum = lnum;
		sv->last_data_size = be32_to_cpu(vid_hdr->data_size);
	}

	sv->leb_count += 1;
	rb_link_node(&seb->u.rb, parent, p);
	rb_insert_color(&seb->u.rb, &sv->root);
	return 0;
}

/**
 * ubi_scan_find_sv - find information about a particular volume in the
 * scanning information.
 * @si: scanning information
 * @vol_id: the requested volume ID
 *
 * This function returns a pointer to the volume description or %NULL if there
 * are no data about this volume in the scanning information.
 */
struct ubi_scan_volume *ubi_scan_find_sv(const struct ubi_scan_info *si,
					 int vol_id)
{
	struct ubi_scan_volume *sv;
	struct rb_node *p = si->volumes.rb_node;

	while (p) {
		sv = rb_entry(p, struct ubi_scan_volume, rb);

		if (vol_id == sv->vol_id)
			return sv;

		if (vol_id > sv->vol_id)
			p = p->rb_left;
		else
			p = p->rb_right;
	}

	return NULL;
}

/**
 * ubi_scan_find_seb - find information about a particular logical
 * eraseblock in the volume scanning information.
 * @sv: a pointer to the volume scanning information
 * @lnum: the requested logical eraseblock
 *
 * This function returns a pointer to the scanning logical eraseblock or %NULL
 * if there are no data about it in the scanning volume information.
 */
struct ubi_scan_leb *ubi_scan_find_seb(const struct ubi_scan_volume *sv,
				       int lnum)
{
	struct ubi_scan_leb *seb;
	struct rb_node *p = sv->root.rb_node;

	while (p) {
		seb = rb_entry(p, struct ubi_scan_leb, u.rb);

		if (lnum == seb->lnum)
			return seb;

		if (lnum > seb->lnum)
			p = p->rb_left;
		else
			p = p->rb_right;
	}

	return NULL;
}

/**
 * ubi_scan_rm_volume - delete scanning information about a volume.
 * @si: scanning information
 * @sv: the volume scanning information to delete
 */
void ubi_scan_rm_volume(struct ubi_scan_info *si, struct ubi_scan_volume *sv)
{
	struct rb_node *rb;
	struct ubi_scan_leb *seb;

	dbg_bld("remove scanning information about volume %d", sv->vol_id);

	while ((rb = rb_first(&sv->root))) {
		seb = rb_entry(rb, struct ubi_scan_leb, u.rb);
		rb_erase(&seb->u.rb, &sv->root);
		list_add_tail(&seb->u.list, &si->erase);
	}

	rb_erase(&sv->rb, &si->volumes);
	kfree(sv);
	si->vols_found -= 1;
}

/**
 * ubi_scan_erase_peb - erase a physical eraseblock.
 * @ubi: UBI device description object
 * @si: scanning information
 * @pnum: physical eraseblock number to erase;
 * @ec: erase counter value to write (%UBI_SCAN_UNKNOWN_EC if it is unknown)
 *
 * This function erases physical eraseblock 'pnum', and writes the erase
 * counter header to it. This function should only be used on UBI device
 * initialization stages, when the EBA unit had not been yet initialized. This
 * function returns zero in case of success and a negative error code in case
 * of failure.
 */
int ubi_scan_erase_peb(struct ubi_device *ubi, const struct ubi_scan_info *si,
		       int pnum, int ec)
{
	int err;
	struct ubi_ec_hdr *ec_hdr;

	if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
		/*
		 * Erase counter overflow. Upgrade UBI and use 64-bit
		 * erase counters internally.
		 */
		ubi_err("erase counter overflow at PEB %d, EC %d", pnum, ec);
		return -EINVAL;
	}

	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
	if (!ec_hdr)
		return -ENOMEM;

	ec_hdr->ec = cpu_to_be64(ec);

	err = ubi_io_sync_erase(ubi, pnum, 0);
	if (err < 0)
		goto out_free;

	err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);

out_free:
	kfree(ec_hdr);
	return err;
}

/**
 * ubi_scan_get_free_peb - get a free physical eraseblock.
 * @ubi: UBI device description object
 * @si: scanning information
 *
 * This function returns a free physical eraseblock. It is supposed to be
 * called on the UBI initialization stages when the wear-leveling unit is not
 * initialized yet. This function picks a physical eraseblocks from one of the
 * lists, writes the EC header if it is needed, and removes it from the list.
 *
 * This function returns scanning physical eraseblock information in case of
 * success and an error code in case of failure.
 */
struct ubi_scan_leb *ubi_scan_get_free_peb(struct ubi_device *ubi,
					   struct ubi_scan_info *si)
{
	int err = 0, i;
	struct ubi_scan_leb *seb;

	if (!list_empty(&si->free)) {
		seb = list_entry(si->free.next, struct ubi_scan_leb, u.list);
		list_del(&seb->u.list);
		dbg_bld("return free PEB %d, EC %d", seb->pnum, seb->ec);
		return seb;
	}

	for (i = 0; i < 2; i++) {
		struct list_head *head;
		struct ubi_scan_leb *tmp_seb;

		if (i == 0)
			head = &si->erase;
		else
			head = &si->corr;

		/*
		 * We try to erase the first physical eraseblock from the @head
		 * list and pick it if we succeed, or try to erase the
		 * next one if not. And so forth. We don't want to take care
		 * about bad eraseblocks here - they'll be handled later.
		 */
		list_for_each_entry_safe(seb, tmp_seb, head, u.list) {
			if (seb->ec == UBI_SCAN_UNKNOWN_EC)
				seb->ec = si->mean_ec;

			err = ubi_scan_erase_peb(ubi, si, seb->pnum, seb->ec+1);
			if (err)
				continue;

			seb->ec += 1;
			list_del(&seb->u.list);
			dbg_bld("return PEB %d, EC %d", seb->pnum, seb->ec);
			return seb;
		}
	}

	ubi_err("no eraseblocks found");
	return ERR_PTR(-ENOSPC);
}

/**
 * process_eb - read UBI headers, check them and add corresponding data
 * to the scanning information.
 * @ubi: UBI device description object
 * @si: scanning information
 * @pnum: the physical eraseblock number
 *
 * This function returns a zero if the physical eraseblock was successfully
 * handled and a negative error code in case of failure.
 */
static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si, int pnum)
{
	long long uninitialized_var(ec);
	int err, bitflips = 0, vol_id, ec_corr = 0;

	dbg_bld("scan PEB %d", pnum);

	/* Skip bad physical eraseblocks */
	err = ubi_io_is_bad(ubi, pnum);
	if (err < 0)
		return err;
	else if (err) {
		/*
		 * FIXME: this is actually duty of the I/O unit to initialize
		 * this, but MTD does not provide enough information.
		 */
		si->bad_peb_count += 1;
		return 0;
	}

	err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
	if (err < 0)
		return err;
	else if (err == UBI_IO_BITFLIPS)
		bitflips = 1;
	else if (err == UBI_IO_PEB_EMPTY)
		return add_to_list(si, pnum, UBI_SCAN_UNKNOWN_EC, &si->erase);
	else if (err == UBI_IO_BAD_EC_HDR) {
		/*
		 * We have to also look at the VID header, possibly it is not
		 * corrupted. Set %bitflips flag in order to make this PEB be
		 * moved and EC be re-created.
		 */
		ec_corr = 1;
		ec = UBI_SCAN_UNKNOWN_EC;
		bitflips = 1;
	}

	si->is_empty = 0;

	if (!ec_corr) {
		/* Make sure UBI version is OK */
		if (ech->version != UBI_VERSION) {
			ubi_err("this UBI version is %d, image version is %d",
				UBI_VERSION, (int)ech->version);
			return -EINVAL;
		}

		ec = be64_to_cpu(ech->ec);
		if (ec > UBI_MAX_ERASECOUNTER) {
			/*
			 * Erase counter overflow. The EC headers have 64 bits
			 * reserved, but we anyway make use of only 31 bit
			 * values, as this seems to be enough for any existing
			 * flash. Upgrade UBI and use 64-bit erase counters
			 * internally.
			 */
			ubi_err("erase counter overflow, max is %d",
				UBI_MAX_ERASECOUNTER);
			ubi_dbg_dump_ec_hdr(ech);
			return -EINVAL;
		}
	}

	/* OK, we've done with the EC header, let's look at the VID header */

	err = ubi_io_read_vid_hdr(ubi, pnum, vidh, 0);
	if (err < 0)
		return err;
	else if (err == UBI_IO_BITFLIPS)
		bitflips = 1;
	else if (err == UBI_IO_BAD_VID_HDR ||
		 (err == UBI_IO_PEB_FREE && ec_corr)) {
		/* VID header is corrupted */
		err = add_to_list(si, pnum, ec, &si->corr);
		if (err)
			return err;
		goto adjust_mean_ec;
	} else if (err == UBI_IO_PEB_FREE) {
		/* No VID header - the physical eraseblock is free */
		err = add_to_list(si, pnum, ec, &si->free);
		if (err)
			return err;
		goto adjust_mean_ec;
	}

	vol_id = be32_to_cpu(vidh->vol_id);
	if (vol_id > UBI_MAX_VOLUMES && vol_id != UBI_LAYOUT_VOLUME_ID) {
		int lnum = be32_to_cpu(vidh->lnum);

		/* Unsupported internal volume */
		switch (vidh->compat) {
		case UBI_COMPAT_DELETE:
			ubi_msg("\"delete\" compatible internal volume %d:%d"
				" found, remove it", vol_id, lnum);
			err = add_to_list(si, pnum, ec, &si->corr);
			if (err)
				return err;
			break;

		case UBI_COMPAT_RO:
			ubi_msg("read-only compatible internal volume %d:%d"
				" found, switch to read-only mode",
				vol_id, lnum);
			ubi->ro_mode = 1;
			break;

		case UBI_COMPAT_PRESERVE:
			ubi_msg("\"preserve\" compatible internal volume %d:%d"
				" found", vol_id, lnum);
			err = add_to_list(si, pnum, ec, &si->alien);
			if (err)
				return err;
			si->alien_peb_count += 1;
			return 0;

		case UBI_COMPAT_REJECT:
			ubi_err("incompatible internal volume %d:%d found",
				vol_id, lnum);
			return -EINVAL;
		}
	}

	/* Both UBI headers seem to be fine */
	err = ubi_scan_add_used(ubi, si, pnum, ec, vidh, bitflips);
	if (err)
		return err;

adjust_mean_ec:
	if (!ec_corr) {
		si->ec_sum += ec;
		si->ec_count += 1;
		if (ec > si->max_ec)
			si->max_ec = ec;
		if (ec < si->min_ec)
			si->min_ec = ec;
	}

	return 0;
}

/**
 * ubi_scan - scan an MTD device.
 * @ubi: UBI device description object
 *
 * This function does full scanning of an MTD device and returns complete
 * information about it. In case of failure, an error code is returned.
 */
struct ubi_scan_info *ubi_scan(struct ubi_device *ubi)
{
	int err, pnum;
	struct rb_node *rb1, *rb2;
	struct ubi_scan_volume *sv;
	struct ubi_scan_leb *seb;
	struct ubi_scan_info *si;

	si = kzalloc(sizeof(struct ubi_scan_info), GFP_KERNEL);
	if (!si)
		return ERR_PTR(-ENOMEM);

	INIT_LIST_HEAD(&si->corr);
	INIT_LIST_HEAD(&si->free);
	INIT_LIST_HEAD(&si->erase);
	INIT_LIST_HEAD(&si->alien);
	si->volumes = RB_ROOT;
	si->is_empty = 1;

	err = -ENOMEM;
	ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
	if (!ech)
		goto out_si;

	vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
	if (!vidh)
		goto out_ech;

	for (pnum = 0; pnum < ubi->peb_count; pnum++) {
		cond_resched();

		dbg_msg("process PEB %d", pnum);
		err = process_eb(ubi, si, pnum);
		if (err < 0)
			goto out_vidh;
	}

	dbg_msg("scanning is finished");

	/* Calculate mean erase counter */
	if (si->ec_count) {
		do_div(si->ec_sum, si->ec_count);
		si->mean_ec = si->ec_sum;
	}

	if (si->is_empty)
		ubi_msg("empty MTD device detected");

	/*
	 * In case of unknown erase counter we use the mean erase counter
	 * value.
	 */
	ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb) {
		ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb)
			if (seb->ec == UBI_SCAN_UNKNOWN_EC)
				seb->ec = si->mean_ec;
	}

	list_for_each_entry(seb, &si->free, u.list) {
		if (seb->ec == UBI_SCAN_UNKNOWN_EC)
			seb->ec = si->mean_ec;
	}

	list_for_each_entry(seb, &si->corr, u.list)
		if (seb->ec == UBI_SCAN_UNKNOWN_EC)
			seb->ec = si->mean_ec;

	list_for_each_entry(seb, &si->erase, u.list)
		if (seb->ec == UBI_SCAN_UNKNOWN_EC)
			seb->ec = si->mean_ec;

	err = paranoid_check_si(ubi, si);
	if (err) {
		if (err > 0)
			err = -EINVAL;
		goto out_vidh;
	}

	ubi_free_vid_hdr(ubi, vidh);
	kfree(ech);

	return si;

out_vidh:
	ubi_free_vid_hdr(ubi, vidh);
out_ech:
	kfree(ech);
out_si:
	ubi_scan_destroy_si(si);
	return ERR_PTR(err);
}

/**
 * destroy_sv - free the scanning volume information
 * @sv: scanning volume information
 *
 * This function destroys the volume RB-tree (@sv->root) and the scanning
 * volume information.
 */
static void destroy_sv(struct ubi_scan_volume *sv)
{
	struct ubi_scan_leb *seb;
	struct rb_node *this = sv->root.rb_node;

	while (this) {
		if (this->rb_left)
			this = this->rb_left;
		else if (this->rb_right)
			this = this->rb_right;
		else {
			seb = rb_entry(this, struct ubi_scan_leb, u.rb);
			this = rb_parent(this);
			if (this) {
				if (this->rb_left == &seb->u.rb)
					this->rb_left = NULL;
				else
					this->rb_right = NULL;
			}

			kfree(seb);
		}
	}
	kfree(sv);
}

/**
 * ubi_scan_destroy_si - destroy scanning information.
 * @si: scanning information
 */
void ubi_scan_destroy_si(struct ubi_scan_info *si)
{
	struct ubi_scan_leb *seb, *seb_tmp;
	struct ubi_scan_volume *sv;
	struct rb_node *rb;

	list_for_each_entry_safe(seb, seb_tmp, &si->alien, u.list) {
		list_del(&seb->u.list);
		kfree(seb);
	}
	list_for_each_entry_safe(seb, seb_tmp, &si->erase, u.list) {
		list_del(&seb->u.list);
		kfree(seb);
	}
	list_for_each_entry_safe(seb, seb_tmp, &si->corr, u.list) {
		list_del(&seb->u.list);
		kfree(seb);
	}
	list_for_each_entry_safe(seb, seb_tmp, &si->free, u.list) {
		list_del(&seb->u.list);
		kfree(seb);
	}

	/* Destroy the volume RB-tree */
	rb = si->volumes.rb_node;
	while (rb) {
		if (rb->rb_left)
			rb = rb->rb_left;
		else if (rb->rb_right)
			rb = rb->rb_right;
		else {
			sv = rb_entry(rb, struct ubi_scan_volume, rb);

			rb = rb_parent(rb);
			if (rb) {
				if (rb->rb_left == &sv->rb)
					rb->rb_left = NULL;
				else
					rb->rb_right = NULL;
			}

			destroy_sv(sv);
		}
	}

	kfree(si);
}

#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID

/**
 * paranoid_check_si - check if the scanning information is correct and
 * consistent.
 * @ubi: UBI device description object
 * @si: scanning information
 *
 * This function returns zero if the scanning information is all right, %1 if
 * not and a negative error code if an error occurred.
 */
static int paranoid_check_si(struct ubi_device *ubi, struct ubi_scan_info *si)
{
	int pnum, err, vols_found = 0;
	struct rb_node *rb1, *rb2;
	struct ubi_scan_volume *sv;
	struct ubi_scan_leb *seb, *last_seb;
	uint8_t *buf;

	/*
	 * At first, check that scanning information is OK.
	 */
	ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb) {
		int leb_count = 0;

		cond_resched();

		vols_found += 1;

		if (si->is_empty) {
			ubi_err("bad is_empty flag");
			goto bad_sv;
		}

		if (sv->vol_id < 0 || sv->highest_lnum < 0 ||
		    sv->leb_count < 0 || sv->vol_type < 0 || sv->used_ebs < 0 ||
		    sv->data_pad < 0 || sv->last_data_size < 0) {
			ubi_err("negative values");
			goto bad_sv;
		}

		if (sv->vol_id >= UBI_MAX_VOLUMES &&
		    sv->vol_id < UBI_INTERNAL_VOL_START) {
			ubi_err("bad vol_id");
			goto bad_sv;
		}

		if (sv->vol_id > si->highest_vol_id) {
			ubi_err("highest_vol_id is %d, but vol_id %d is there",
				si->highest_vol_id, sv->vol_id);
			goto out;
		}

		if (sv->vol_type != UBI_DYNAMIC_VOLUME &&
		    sv->vol_type != UBI_STATIC_VOLUME) {
			ubi_err("bad vol_type");
			goto bad_sv;
		}

		if (sv->data_pad > ubi->leb_size / 2) {
			ubi_err("bad data_pad");
			goto bad_sv;
		}

		last_seb = NULL;
		ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb) {
			cond_resched();

			last_seb = seb;
			leb_count += 1;

			if (seb->pnum < 0 || seb->ec < 0) {
				ubi_err("negative values");
				goto bad_seb;
			}

			if (seb->ec < si->min_ec) {
				ubi_err("bad si->min_ec (%d), %d found",
					si->min_ec, seb->ec);
				goto bad_seb;
			}

			if (seb->ec > si->max_ec) {
				ubi_err("bad si->max_ec (%d), %d found",
					si->max_ec, seb->ec);
				goto bad_seb;
			}

			if (seb->pnum >= ubi->peb_count) {
				ubi_err("too high PEB number %d, total PEBs %d",
					seb->pnum, ubi->peb_count);
				goto bad_seb;
			}

			if (sv->vol_type == UBI_STATIC_VOLUME) {
				if (seb->lnum >= sv->used_ebs) {
					ubi_err("bad lnum or used_ebs");
					goto bad_seb;
				}
			} else {
				if (sv->used_ebs != 0) {
					ubi_err("non-zero used_ebs");
					goto bad_seb;
				}
			}

			if (seb->lnum > sv->highest_lnum) {
				ubi_err("incorrect highest_lnum or lnum");
				goto bad_seb;
			}
		}

		if (sv->leb_count != leb_count) {
			ubi_err("bad leb_count, %d objects in the tree",
				leb_count);
			goto bad_sv;
		}

		if (!last_seb)
			continue;

		seb = last_seb;

		if (seb->lnum != sv->highest_lnum) {
			ubi_err("bad highest_lnum");
			goto bad_seb;
		}
	}

	if (vols_found != si->vols_found) {
		ubi_err("bad si->vols_found %d, should be %d",
			si->vols_found, vols_found);
		goto out;
	}

	/* Check that scanning information is correct */
	ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb) {
		last_seb = NULL;
		ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb) {
			int vol_type;

			cond_resched();

			last_seb = seb;

			err = ubi_io_read_vid_hdr(ubi, seb->pnum, vidh, 1);
			if (err && err != UBI_IO_BITFLIPS) {
				ubi_err("VID header is not OK (%d)", err);
				if (err > 0)
					err = -EIO;
				return err;
			}

			vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?
				   UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
			if (sv->vol_type != vol_type) {
				ubi_err("bad vol_type");
				goto bad_vid_hdr;
			}

			if (seb->sqnum != be64_to_cpu(vidh->sqnum)) {
				ubi_err("bad sqnum %llu", seb->sqnum);
				goto bad_vid_hdr;
			}

			if (sv->vol_id != be32_to_cpu(vidh->vol_id)) {
				ubi_err("bad vol_id %d", sv->vol_id);
				goto bad_vid_hdr;
			}

			if (sv->compat != vidh->compat) {
				ubi_err("bad compat %d", vidh->compat);
				goto bad_vid_hdr;
			}

			if (seb->lnum != be32_to_cpu(vidh->lnum)) {
				ubi_err("bad lnum %d", seb->lnum);
				goto bad_vid_hdr;
			}

			if (sv->used_ebs != be32_to_cpu(vidh->used_ebs)) {
				ubi_err("bad used_ebs %d", sv->used_ebs);
				goto bad_vid_hdr;
			}

			if (sv->data_pad != be32_to_cpu(vidh->data_pad)) {
				ubi_err("bad data_pad %d", sv->data_pad);
				goto bad_vid_hdr;
			}

			if (seb->leb_ver != be32_to_cpu(vidh->leb_ver)) {
				ubi_err("bad leb_ver %u", seb->leb_ver);
				goto bad_vid_hdr;
			}
		}

		if (!last_seb)
			continue;

		if (sv->highest_lnum != be32_to_cpu(vidh->lnum)) {
			ubi_err("bad highest_lnum %d", sv->highest_lnum);
			goto bad_vid_hdr;
		}

		if (sv->last_data_size != be32_to_cpu(vidh->data_size)) {
			ubi_err("bad last_data_size %d", sv->last_data_size);
			goto bad_vid_hdr;
		}
	}

	/*
	 * Make sure that all the physical eraseblocks are in one of the lists
	 * or trees.
	 */
	buf = kzalloc(ubi->peb_count, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	for (pnum = 0; pnum < ubi->peb_count; pnum++) {
		err = ubi_io_is_bad(ubi, pnum);
		if (err < 0) {
			kfree(buf);
			return err;
		}
		else if (err)
			buf[pnum] = 1;
	}

	ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb)
		ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb)
			buf[seb->pnum] = 1;

	list_for_each_entry(seb, &si->free, u.list)
		buf[seb->pnum] = 1;

	list_for_each_entry(seb, &si->corr, u.list)
		buf[seb->pnum] = 1;

	list_for_each_entry(seb, &si->erase, u.list)
		buf[seb->pnum] = 1;

	list_for_each_entry(seb, &si->alien, u.list)
		buf[seb->pnum] = 1;

	err = 0;
	for (pnum = 0; pnum < ubi->peb_count; pnum++)
		if (!buf[pnum]) {
			ubi_err("PEB %d is not referred", pnum);
			err = 1;
		}

	kfree(buf);
	if (err)
		goto out;
	return 0;

bad_seb:
	ubi_err("bad scanning information about LEB %d", seb->lnum);
	ubi_dbg_dump_seb(seb, 0);
	ubi_dbg_dump_sv(sv);
	goto out;

bad_sv:
	ubi_err("bad scanning information about volume %d", sv->vol_id);
	ubi_dbg_dump_sv(sv);
	goto out;

bad_vid_hdr:
	ubi_err("bad scanning information about volume %d", sv->vol_id);
	ubi_dbg_dump_sv(sv);
	ubi_dbg_dump_vid_hdr(vidh);

out:
	ubi_dbg_dump_stack();
	return 1;
}

#endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */


text:
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="hibernate.hbm2ddl.auto">create-drop</property>

        <mapping class="org.overlord.rtgov.activity.model.ActivityUnit"/>
		<mapping class="org.overlord.rtgov.activity.model.ActivityType"/>
		<mapping class="org.overlord.rtgov.activity.model.ActivityTypeId"/>
		<mapping class="org.overlord.rtgov.activity.model.Context"/>
		<mapping class="org.overlord.rtgov.activity.model.app.CustomActivity"/>
		<mapping class="org.overlord.rtgov.activity.model.app.LogMessage"/>
		<mapping class="org.overlord.rtgov.activity.model.bpm.BPMActivityType"/>
		<mapping class="org.overlord.rtgov.activity.model.bpm.ProcessCompleted"/>
		<mapping class="org.overlord.rtgov.activity.model.bpm.ProcessStarted"/>
		<mapping class="org.overlord.rtgov.activity.model.bpm.ProcessVariableSet"/>
		<mapping class="org.overlord.rtgov.activity.model.common.MessageExchange"/>
		<mapping class="org.overlord.rtgov.activity.model.mom.MOMActivityType"/>
		<mapping class="org.overlord.rtgov.activity.model.mom.MessageReceived"/>
		<mapping class="org.overlord.rtgov.activity.model.mom.MessageSent"/>
		<mapping class="org.overlord.rtgov.activity.model.soa.RPCActivityType"/>
		<mapping class="org.overlord.rtgov.activity.model.soa.RequestSent"/>
		<mapping class="org.overlord.rtgov.activity.model.soa.RequestReceived"/>
		<mapping class="org.overlord.rtgov.activity.model.soa.ResponseSent"/>
		<mapping class="org.overlord.rtgov.activity.model.soa.ResponseReceived"/>
    </session-factory>

</hibernate-configuration>


text:
import { ADD, LOAD_DATA } from "myTypes_types";
export default {
    state: {
        count: 0,
        myData: {},
        myVal: '',
    },
    getters: {
        countStr: (state) => {
            return '共有' + state.count + '個';
        },
    },
    mutations: {
        [ADD](state, payload) {
            state.count += payload.num;
        },
        setData(state, payload) {
            if (typeof payload.data === 'string') {
                state.myData = JSON.parse(payload.data);
            } else {
                state.myData = payload.data;
            }
        },
        setMyVal(state, payload) {
            state.myVal = payload.val;
        },
    },
    //這是註解ABC123
    actions: {
        [ADD]({ state, commit, rootState }, payload) {
            commit('add', payload);
        },
        async [LOAD_DATA]({ state, commit, rootState }) {
            rootState.isLoading = true;
            try {
                let data = await fetch('./data.json');
                data = await data.json();
                rootState.isLoading = false;
                commit('setData', { data });
            } catch (err) {
                console.error(err);
                rootState.isLoading = false;
            }
        },
        setMyVal({ state, commit, rootState }, payload) {
            commit('setMyVal', payload);
        },
    },
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

    <title>Assert-Match :: Blade :: PowerShell Testing Module</title>
	<link href="styles.css" type="text/css" rel="stylesheet" />

Topics

about_Blade

Commands

Assert-Contains

Assert-ContainsLike

Assert-ContainsNotLike

Assert-DirectoryDoesNotExist

Assert-DirectoryExists

Assert-DoesNotContain

Assert-Empty

Assert-Equal

Assert-Error

Assert-False

Assert-FileContains

Assert-FileDoesNotExist

Assert-FileExists

Assert-GreaterThan

Assert-Is

Assert-LastProcessFailed

Assert-LastProcessSucceeded

Assert-LessThan

Assert-Like

Assert-Match

Assert-NodeDoesNotExist

Assert-NodeExists

Assert-NoError

Assert-NotEmpty

Assert-NotEqual

Assert-NotNull

Assert-Null

Assert-True

New-AssertionException

New-TempDirectory

New-TempDirectoryTree

Test-NodeExists

Scripts

blade.ps1

Import-Blade.ps1

Assert-Match

Asserts that a string matches a regular expression.

Syntax

Assert-Match [-Haystack] <String> [-Regex] <String> [[-Message] <String>] [<CommonParameters>]

Description

Uses PowerShell's -match operator, e.g. $Haystack -match $Regex.

 Parameters

				Name
                Type
				Description
				Required?
				Pipeline Input
				Default Value

				Haystack
				String
				The string that should match the regular expression

				true
				false

				Regex
				String
				The regular expression to use when matching.

				true
				false

				Message
				String
				The message to show when the assertion fails.

				false
				false

EXAMPLE 1

Assert-Match 'Haystack' 'stack'

Demonstrates how to check that a string matches  regular expression.

EXAMPLE 2

Assert-Match 'NONumbers!' '\d' 'Ack! No numbers doesn''t have any numbers.'

Demonstrates how to show a specific message if the assertion fails.


text:
'''
This script prints out the list of CCDs touching a given brick.
'''
from __future__ import print_function
from survey import LegacySurveyData, wcs_for_brick, ccds_touching_wcs
from sys import exit
#
#
#
def main():
    """Main program.
    """
    import argparse
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('brickname',nargs='+',help="Name(s) of brick(s).",metavar='BRICK')
    opt = parser.parse_args()

    survey = LegacySurveyData()
    CCDs = survey.get_ccds()
    for brickname in opt.brickname:
        brick = survey.get_brick_by_name(brickname)
        print('# Brick', brickname, 'RA,Dec', brick.ra, brick.dec)
        wcs = wcs_for_brick(brick)
        I = ccds_touching_wcs(wcs, CCDs)
        for i in I:
            print(i, CCDs.filter[i], CCDs.expnum[i], CCDs.ccdname[i], CCDs.image_filename[i], CCDs.image_hdu[i])
    return 0
#
#
#
if __name__ == '__main__':
    exit(main())


text:
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/animation/inert_effect.h"

#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/renderer/core/animation/animation_test_helpers.h"
#include "third_party/blink/renderer/core/animation/animation_timeline.h"
#include "third_party/blink/renderer/core/animation/keyframe_effect_model.h"
#include "third_party/blink/renderer/core/animation/property_handle.h"

namespace blink {

using animation_test_helpers::CreateSimpleKeyframeEffectModelForTest;

TEST(InertEffectTest, IsCurrent) {
  auto* opacity_model =
      CreateSimpleKeyframeEffectModelForTest(CSSPropertyID::kOpacity, "0", "1");

  {
    Timing timing;
    timing.iteration_duration = ANIMATION_TIME_DELTA_FROM_SECONDS(1000);

    auto* inert_effect = MakeGarbageCollected<InertEffect>(
        opacity_model, timing, /* paused */ false, AnimationTimeDelta(),
        /* timeline_duration */ absl::nullopt, /* playback_rate */ 1.0);
    HeapVector<Member<Interpolation>> interpolations;
    // Calling Sample ensures Timing is calculated.
    inert_effect->Sample(interpolations);
    EXPECT_EQ(1u, interpolations.size());
    EXPECT_TRUE(inert_effect->IsCurrent());
  }

  {
    Timing timing;
    timing.iteration_duration = ANIMATION_TIME_DELTA_FROM_SECONDS(1000);
    timing.start_delay = Timing::Delay(ANIMATION_TIME_DELTA_FROM_SECONDS(500));

    auto* inert_effect = MakeGarbageCollected<InertEffect>(
        opacity_model, timing, /* paused */ false, AnimationTimeDelta(),
        /* timeline_duration */ absl::nullopt, /* playback_rate */ 1.0);
    HeapVector<Member<Interpolation>> interpolations;
    // Calling Sample ensures Timing is calculated.
    inert_effect->Sample(interpolations);
    EXPECT_EQ(1u, interpolations.size());
    EXPECT_TRUE(inert_effect->IsCurrent());
  }

  {
    Timing timing;
    timing.iteration_duration = ANIMATION_TIME_DELTA_FROM_SECONDS(1000);
    timing.start_delay = Timing::Delay(ANIMATION_TIME_DELTA_FROM_SECONDS(500));

    auto* inert_effect = MakeGarbageCollected<InertEffect>(
        opacity_model, timing, /* paused */ false, AnimationTimeDelta(),
        /* timeline_duration */ absl::nullopt, /* playback_rate */ -1.0);
    HeapVector<Member<Interpolation>> interpolations;
    // Calling Sample ensures Timing is calculated.
    inert_effect->Sample(interpolations);
    EXPECT_EQ(1u, interpolations.size());
    EXPECT_FALSE(inert_effect->IsCurrent());
  }
}

TEST(InertEffectTest, Affects) {
  auto* opacity_model =
      CreateSimpleKeyframeEffectModelForTest(CSSPropertyID::kOpacity, "0", "1");
  auto* color_model = CreateSimpleKeyframeEffectModelForTest(
      CSSPropertyID::kColor, "red", "green");

  Timing timing;

  auto* opacity_effect = MakeGarbageCollected<InertEffect>(
      opacity_model, timing, /* paused */ false, AnimationTimeDelta(),
      /* timeline_duration */ absl::nullopt, /* playback_rate */ 1.0);

  auto* color_effect = MakeGarbageCollected<InertEffect>(
      color_model, timing, /* paused */ false, AnimationTimeDelta(),
      /* timeline_duration */ absl::nullopt, /* playback_rate */ 1.0);

  EXPECT_TRUE(opacity_effect->Affects(PropertyHandle(GetCSSPropertyOpacity())));
  EXPECT_FALSE(opacity_effect->Affects(PropertyHandle(GetCSSPropertyColor())));

  EXPECT_TRUE(color_effect->Affects(PropertyHandle(GetCSSPropertyColor())));
  EXPECT_FALSE(color_effect->Affects(PropertyHandle(GetCSSPropertyOpacity())));
}

}  // namespace blink


text:
package com.meowster.mcquad;

import com.meowster.test.AbstractTest;
import org.junit.Test;

import static org.junit.Assert.assertEquals;

/**
 * Unit tests for {@link com.meowster.mcquad.Color}.
 *
 * @author Simon Hunt
 */
public class ColorTest extends AbstractTest {

    private Color color;

    @Test(expected = NumberFormatException.class)
    public void badInput() {
        new Color("fred");
    }

    private void checkComponents(int a, int r, int g, int b, String hex) {
        assertEquals(AM_NEQ, a, color.alpha());
        assertEquals(AM_NEQ, r, color.red());
        assertEquals(AM_NEQ, g, color.green());
        assertEquals(AM_NEQ, b, color.blue());
        assertEquals(AM_NEQ, hex, color.hex());
    }

    @Test
    public void basic() {
        title("basic");
        color = new Color("0x00000000");
        print(color);
        checkComponents(0, 0, 0, 0, "0x0");
    }

    @Test
    public void red() {
        title("red");
        color = Color.RED;
        print(color);
        checkComponents(255, 255, 0, 0, "0xffff0000");
    }

    @Test
    public void green() {
        title("green");
        color = Color.GREEN;
        print(color);
        checkComponents(255, 0, 255, 0, "0xff00ff00");
    }

    @Test
    public void blue() {
        title("blue");
        color = Color.BLUE;
        print(color);
        checkComponents(255, 0, 0, 255, "0xff0000ff");
    }

    @Test
    public void randomColor1() {
        title("randomColor1");
        final int raw = 0xc0112233;
        final String hex = "0xc0112233";

        color = new Color(raw);
        print(color);
        assertEquals(AM_NEQ, 0xc0, color.alpha());
        assertEquals(AM_NEQ, 0x3f, color.transparency());
        assertEquals(AM_NEQ, 0x11, color.red());
        assertEquals(AM_NEQ, 0x22, color.green());
        assertEquals(AM_NEQ, 0x33, color.blue());
        assertEquals(AM_NEQ, 0x33, color.blue());
        assertEquals(AM_NEQ, raw, color.toInt());
        assertEquals(AM_NEQ, hex, color.hex());

        Color copy = new Color(hex);
        assertEquals(AM_NEQ, color, copy);
    }

    @Test
    public void differentConstructions() {
        title("differentConstructions");
        Color c1 = new Color("0xbbeeaadd");
        Color c2 = new Color(0xbbeeaadd);
        Color c3 = new Color(0xbb, 0xee, 0xaa, 0xdd);

        assertEquals(AM_NEQ, c1, c2);
        assertEquals(AM_NEQ, c2, c3);
        assertEquals(AM_NEQ, c1, c1);

        assertEquals(AM_NEQ, c1.toInt(), c2.toInt());
        assertEquals(AM_NEQ, c1.toInt(), c3.toInt());
    }

    @Test
    public void clampedByteConstruction() {
        title("clampedByteConstruction");
        int a = 128;
        int r = 3000;
        int g = 48;
        int b = -17;
        Color c = new Color(a, r, g, b);
        print(c);
        assertEquals(AM_NEQ, 0x80ff3000, c.toInt());
    }

    // ====================================================================

    @Test
    public void shade() {
        title("shade");
        checkShade(0, 0, 0);
        checkShade(0xff203040, 1, 0xff213141);
        checkShade(0x00a0b0c0, 0x52, 0x00f2ffff);
        checkShade(0xffbbeedd, -0x11, 0xffaaddcc);
    }

    private void checkShade(int color, int amt, int exp) {
        Color origColor = new Color(color);
        Color expColor = new Color(exp);
        Color actColor = origColor.shade(amt);
        print("shade(color:{}, amt:{}} => {}", origColor.hex(), amt, actColor.hex());
        assertEquals(AM_NEQ, expColor, actColor);
    }

    @Test
    public void overlay() {
        title("overlay");
        checkOverlay(0, 0, 0);
        //         1.0,30,40,50  0.25,128,128,128  1.0,54,62,69
        checkOverlay(0xff1e2832, 0x40808080,       0xff363e45);
        //         0.5,50,40,30  0.25,128,192,192  0.625,69,78,70
        checkOverlay(0x8032281e, 0x4080c0c0, 0x9f454e46);
    }

    private void checkOverlay(int color, int overlay, int exp) {
        Color origColor = new Color(color);
        Color overlayColor = new Color(overlay);
        Color expColor = new Color(exp);
        Color actColor = origColor.overlay(overlayColor);

        print("overlay(color:{}, overlay:{}) => {}",
                origColor.hex(), overlayColor.hex(), actColor.hex());
        assertEquals(AM_NEQ, expColor, actColor);
    }

    @Test
    public void repeatOverlay() {
        title("repeatOverlay");
        checkRepeatOverlay(0, 0, 4, 0);
        checkRepeatOverlay(0xff0000ff, 0x1000ff80, 1, 0xff0010f7);
        checkRepeatOverlay(0xff0000ff, 0x1000ff80, 2, 0xff001eef);
        checkRepeatOverlay(0xff0000ff, 0x1000ff80, 3, 0xff002ce8);
        checkRepeatOverlay(0xff0000ff, 0x1000ff80, 4, 0xff0039e1);
    }

    private void checkRepeatOverlay(int color, int overlay, int rep, int exp) {
        Color origColor = new Color(color);
        Color overlayColor = new Color(overlay);
        Color expColor = new Color(exp);
        Color actColor = origColor.overlay(overlayColor, rep);

        print("overlay(color:{}, overlay:{}, repeat:{}) => {}",
                origColor.hex(), overlayColor.hex(), rep, actColor.hex());
        assertEquals(AM_NEQ, expColor, actColor);
    }

    @Test
    public void demultiplyAlpha() {
        title("demultiplyAlpha");
        checkDemultiplyAlpha(0, 0);
        checkDemultiplyAlpha(0x80204060, 0x803f7fbf);  // div 0.5  = x2
        checkDemultiplyAlpha(0x40204060, 0x407fffff);  // div 0.25 = x4
        checkDemultiplyAlpha(0xff204060, 0xff204060);  // div 1.0  = x1
    }

    private void checkDemultiplyAlpha(int color, int exp) {
        Color origColor = new Color(color);
        Color expColor = new Color(exp);
        Color actColor = origColor.demultiplyAlpha();

        print("demultiplyAlpha({}) => {}", origColor.hex(), actColor.hex());
        assertEquals(AM_NEQ, expColor, actColor);
    }

    @Test
    public void multiply() {
        title("multiply");
        checkMultiply(0, 0, 0);
        checkMultiply(0x80ff0000, 0x80000080, 0x40000000);
        checkMultiply(0x80203040, 0x80403020, 0x40080908);
    }

    private void checkMultiply(int c1, int c2, int exp) {
        Color origColor = new Color(c1);
        Color multColor = new Color(c2);
        Color expColor = new Color(exp);
        Color actColor = origColor.multiply(multColor);

        print("multiply({}, {}) => {}", origColor.hex(), multColor.hex(),
                actColor.hex());
        assertEquals(AM_NEQ, expColor, actColor);
    }

    @Test
    public void multiplySolid() {
        title("multiplySolid");
        checkMultiplySolid(0, 0, 0);
        checkMultiplySolid(0x20444444, 0xff4080c0, 0x20112233);
    }

    private void checkMultiplySolid(int c1, int c2, int exp) {
        Color origColor = new Color(c1);
        Color multColor = new Color(c2);
        Color expColor = new Color(exp);
        Color actColor = origColor.multiplySolid(multColor);

        print("multiplySolid({}, {}) => {}", origColor.hex(), multColor.hex(),
                actColor.hex());
        assertEquals(AM_NEQ, expColor, actColor);
    }

    @Test
    public void averageEmpty() {
        title("averageEmpty");
        Color c = Color.averageColor();
        print(c);
        assertEquals(AM_NEQ, Color.TRANSPARENT, c);
    }

    @Test
    public void averageRed() {
        title("averageRed");
        Color c = Color.averageColor(Color.RED.toInt());
        print(c);
        assertEquals(AM_NEQ, Color.RED, c);
    }

    @Test
    public void averageRedBlue() {
        title("averageRedBlue");
        int r = Color.RED.toInt();
        int b = Color.BLUE.toInt();
        Color c = Color.averageColor(r, b);
        print(c);
        Color exp = new Color(0xff7f007f);
        assertEquals(AM_NEQ, exp, c);
    }

    @Test
    public void averageFour() {
        title("averageFour");
        int c1 = 0xff456689;
        int c2 = 0xff4577af;
        int c3 = 0xff4555a0;
        int c4 = 0xef4566a6;
        Color c = Color.averageColor(c1, c2, c3, c4);
        print(c);
        Color exp = new Color(0xfb45669f);
        assertEquals(AM_NEQ, exp, c);
    }
}


text:
Branflake is a compiler for the Brainf--- language. Its target platform
is 16-bit DOS. I made it using the techniques in NC State University's
[CSC 236][] class.

[CSC 236]: http://courses.ncsu.edu/csc236/lec/001/

## 16-bit DOS? How the flake am I supposed to use it?

Most people don't have 16-bit DOS lying around on an actual machine, so
the best approach (and the one that I used when developing it) is to
install [DOSBox][].

Branflake, and the assembler it generates, is written for the Microsoft Macro
Assembler (MASM), since that is what CSC 236 uses. I plan to support
[JWASM][] as well since it is free, open-source, and MASM-compatible,
and if compatibility with other assemblers can be provided without adding
complexity to `bftrans`, that's great. Pull requests are welcome.

[DOSBox]: http://www.dosbox.com/
[JWASM]: http://www.japheth.de/JWasm.html

## Language Reference

Branflake, as a dialect of Brainf---, is an esoteric and rather difficult
language to write in. However, it's very easy to compile, and Branflake even
performs some optimizations on the generated assembly.

A Branflake program has access to the entire 64K data segment, which it can
access one byte at a time, like the mathematical ideal of a Turing machine.
It has one register (the "data pointer"), which indicates the byte in memory
it is currently manipulating (the "current byte").

There are eight instructions in Branflake (names given only to explain the
source code):

* `>` (`next`) increments the data pointer by one.
* `<` (`prev`) decrements the data pointer by one.
* `+` (`inc`) increments the current byte by one.
* `-` (`dec`) decrements the current byte by one.
* `[` (`skip`) skips the bracketed section if the current byte is zero.
* `]` (`loop`) repeats the bracketed section if the current byte is nonzero.
* `.` (`write`) writes the current byte to standard output.
* `,` (`read`) reads a byte from standard input and stores it in the current byte.

All other characters are comments. The only syntax errors are mismatched
brackets -- either having a `]` when all previous `[` have been closed, or
having a `[` that is not closed by a `]`. These are reported by dropping a
`.ERR` directive in the generated source so that assembly fails.

Each instruction is executed sequentially (taking the effects of `[` and `]`
into account), until the last instruction completes, at which point the
program will exit.

Branflake offers no mechanisms for handling overflows, underflows, or other
mathematical imprecisions. As a consequence, the data pointer will "wrap
around" if increased above 65535 or decreased below 0, and individual bytes
in memory will wrap around if increased above 255 or decreased below 0.

## Invocation

The core of Branflake is `bftrans.asm`, which is a very simple translator.
It accepts Branflake instructions on standard input, and writes assembler
code on standard output. You can assemble and link `bftrans` using MASM
by running the included `make.bat` file.

`bftrans` is supported by `bfio.asm`, which contains some I/O abstraction
subroutines (which are prototyped in `bfio.inc`). These provide character
and line counting, and some functions for formatting output.

Once `bftrans` has been linked, you can invoke it directly, or use `bfml.bat`
to translate, assemble, and link your Branflake source in a single step.
Its usage is:

    bfml hello

Which will assemble a file named `hello.bf` into `hello.exe`, generating
`hello.asm` and `hello.obj` along the way.

## Implementation Details

In the generated assembly, the data pointer is represented by `bx`, and the
current byte by `[bx]`. The `ax` and `dx` registers are used temporarily
for I/O purposes, but in general, all operations are done in memory.

## Current Limitations

* Currently, there are no optimizations.
* All assembler files must be terminated by a DOS EOF character (1Ah).
* Most Brainf--- code on the Internet isn't used to having to check for a
DOS EOF to end input.


text:
var path = require("path");
var ExtractTextPlugin = require("extract-text-webpack-plugin");

var moduleConfig = {
	loaders: [
		{
			test: /\.css$/,
			use: ExtractTextPlugin.extract({
				fallback: "style-loader",
				loader: "css-loader"
			})
		}
	]
};

module.exports = [
	{
		context: path.join(__dirname, "a"),
		entry: "./index",
		output: {
			filename: "[chunkhash].js"
		},
		module: moduleConfig,
		plugins: [
			new ExtractTextPlugin("[contenthash].css")
		]
	},
	{
		context: path.join(__dirname, "b"),
		entry: "./index",
		output: {
			filename: "[chunkhash].js"
		},
		module: moduleConfig,
		plugins: [
			new ExtractTextPlugin("[contenthash].css")
		]
	}
];


text:
import React from 'react';

import './index.css';
import * as vega from 'vega';
import * as vl from 'vega-lite';

const getVersion = (mode) => {
  return mode === 'vega' ? vega.version : vl.version;
}

export default class Toolbar extends React.Component {
  static propTypes = {
    error: React.PropTypes.string,
    renderer: React.PropTypes.string,
    tooltip: React.PropTypes.bool
  }

  showErrorAndWarnings() {
    if (this.props.error) {
      return (

 this.props.showErrorPane()}>
          Error

      );
    } else if (this.props.warningsLogger.warns.length > 0) {
      return (

 this.props.showErrorPane()}>
          Warning

      );
    }
  }

  render() {
    return (

        {this.showErrorAndWarnings()}

          {
            `${this.props.mode} version ${getVersion(this.props.mode)}`
          }

           {this.props.tooltip ? 'Tooltips' : 'No Tooltips'}

          {
            `Renderer: ${this.props.renderer}`
          }

    );
  }
}


text:
<?php
class LanguageLoader
{
    function initialize() {
        $ci =& get_instance();
        $ci->load->helper('language');

        $siteLang = $ci->session->userdata('site_lang');
        if ($siteLang) {
            $ci->lang->load('main',$siteLang);
        } else {
            $ci->lang->load('main','indonesia');
            $ci->session->set_userdata('lang-short','id');
            $ci->session->set_userdata('lang-name','Indonesia');
            $ci->session->set_userdata('lang-alt','Indonesia');
        }
    }
}


text:
package org.cfeclipse.cfml.preferences;

import org.cfeclipse.cfml.CFMLPlugin;
import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.FieldEditorPreferencePage;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;

/**
 * THIS CLASS IS MEANT TO BE FOR THE AUTO-INSERTION/COMPLETION
 * For some reason Eclipse decides to put the wrong pref page under the wrong
 * title. This is a quick fix for the next release. I'll fix it sometime soon..
 *
 * @author Oliver Tupman
 *
 */
public class AutoIndentPreferencePage
		extends FieldEditorPreferencePage
		implements IWorkbenchPreferencePage {

	CFMLPreferenceManager cfmlpm;

	public AutoIndentPreferencePage() {
		super(GRID);
		setPreferenceStore(CFMLPlugin.getDefault().getPreferenceStore());
		setDescription("Here you can manage the behaviour of the auto-insertion of characters such as double quotes, as well as the auto-closing of tags");
		cfmlpm = new CFMLPreferenceManager();
	}

	public void createFieldEditors() {
		try {
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_DOUBLE_QUOTES, "Auto close \"s", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_SINGLE_QUOTES, "Auto close \'s", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_HASHES, "Auto close #s", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_PARENS, "Auto close parenthesis (i.e insert a closing \')\')", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_BRACKETS, "Auto close brackets (i.e insert a closing \']\')", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_BRACES, "Auto close braces (i.e insert a closing \'}\')", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOCLOSE_TAGS, "Auto close tags (i.e. insert a closing \'>\')", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOINSERT_CLOSE_TAGS, "Auto insert a closing tag", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_USE_SMART_INDENT, "Use smart indenting", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_AUTOINDENT_ONTAGCLOSE, "Auto-indent on tag close", getFieldEditorParent()));
		addField(new BooleanFieldEditor(AutoIndentPreferenceConstants.P_USE_SMART_PASTE, "Auto-indent pasted tags", getFieldEditorParent()));
		}
		catch (Exception e){
			e.printStackTrace();
		}
	}

	protected void performDefaults() {
		super.performDefaults();
	}

	public void init(IWorkbench workbench) {
	}
}


text:
<?php

function calendar_template() {
    return <<<END_OF_TEMPLATE

   {table_open}
{/table_open}

   {heading_row_start}
{/heading_row_start}

   {heading_previous_cell}<<	{/heading_previous_cell}
   {heading_title_cell}{heading}	{/heading_title_cell}
   {heading_next_cell}>>	{/heading_next_cell}

   {heading_row_end}
{/heading_row_end}

   {week_row_start}
{/week_row_start}
   {week_day_cell}{week_day}	{/week_day_cell}
   {week_row_end}
{/week_row_end}

   {cal_row_start}
{/cal_row_start}
   {cal_cell_start}{/cal_cell_start}

   {cal_cell_content}{day}{/cal_cell_content}
   {cal_cell_content_today}
{day}
{/cal_cell_content_today}

   {cal_cell_no_content}{day}{/cal_cell_no_content}
   {cal_cell_no_content_today}
{day}
{/cal_cell_no_content_today}

   {cal_cell_blank} {/cal_cell_blank}

   {cal_cell_end}	{/cal_cell_end}
   {cal_row_end}
{/cal_row_end}

   {table_close}
{/table_close}

END_OF_TEMPLATE;

}

function is_curr($link) {
    return (strpos(uri_string(), $link) !== false) ? 'class="current"' : '';
}


text:
Minimal JavaScript plugin to help style `<select>` elements. Built with es6 and Redux.

## Setup
Install depencies with `npm install` then run webpack dev server with `npm start` or create production builds with `npm run build`

**N.B. _Not_ production-ready.**

## Config

```javascript
{
  // Selector string that when set will instantiate plugin only on elements that match it.
  // Default behaviour is to target all <select> elements.
  selector: '.skin-me',
  // Boolean that indicates whether or not the first option in each option list is a title value
  // If true first option not included in the list of Skinr options.
  // Defaults to false.
  titleOption: true
}
```

## Notes

Currently presumes following element structure:

```html
<select>
  <option selected disabled>First option can be placeholder/title</option>
  <option value="value1">Subsequent options must have 'value' attribute</option>
  <option value="value2">Option two</option>
  <option value="value3">Option three</option>
</select>
```


text:
require "spec_helper"
require "fog/brightbox/models/compute/server"

describe Fog::Brightbox::Compute::Server do
  include ModelSetup
  include SupportsResourceLocking

  subject { service.servers.new }

  describe "when asked for collection name" do
    it "responds 'servers'" do
      assert_equal "servers", subject.collection_name
    end
  end

  describe "when asked for resource name" do
    it "responds 'server'" do
      assert_equal "server", subject.resource_name
    end
  end

  describe "when creating" do
    describe "with image_id" do
      it "sends correct JSON" do
        options = {
          image_id: "img-12345"
        }

        stub_request(:post, "http://localhost/1.0/servers").
          with(:query => hash_including(:account_id),
               :headers => { "Authorization" => "Bearer FAKECACHEDTOKEN",
                             "Content-Type" => "application/json" },
                             :body => hash_including(:image => "img-12345")).
        to_return(:status => 202, :body => %q({"id":"srv-12345"}), :headers => {})

        @server = Fog::Brightbox::Compute::Server.new({ :service => service }.merge(options))
        assert @server.save
      end
    end

    describe "with image_id and custom size" do
      it "sends correct JSON" do
        options = {
          image_id: "img-12345",
          volume_size: 25_000
        }
        expected_args = {
          volumes: [
            {
              image: "img-12345",
              size: 25_000
            }
          ]
        }

        stub_request(:post, "http://localhost/1.0/servers").
          with(:query => hash_including(:account_id),
               :headers => { "Authorization" => "Bearer FAKECACHEDTOKEN",
                             "Content-Type" => "application/json" },
                             :body => hash_including(expected_args)).
        to_return(:status => 202, :body => %q({"id":"srv-12345"}), :headers => {})

        @server = Fog::Brightbox::Compute::Server.new({ :service => service }.merge(options))
        assert @server.save
      end
    end

    describe "with additional disk_encrypted" do
      it "sends correct JSON" do
        options = {
          image_id: "img-12345",
          disk_encrypted: true
        }

        stub_request(:post, "http://localhost/1.0/servers").
          with(:query => hash_including(:account_id),
               :headers => { "Authorization" => "Bearer FAKECACHEDTOKEN",
                             "Content-Type" => "application/json" },
                             :body => hash_including(:disk_encrypted => true)).
          to_return(:status => 202,
                    :body => %q({"id":"srv-12345","disk_encrypted":true}),
                    :headers => {})

        @server = Fog::Brightbox::Compute::Server.new({ :service => service }.merge(options))
        assert @server.save
        assert @server.disk_encrypted
      end
    end
  end

  describe "with volume_id" do
    it "sends correct JSON" do
      options = {
        volume_id: "vol-12345"
      }
      expected_args = {
        volumes: [{ volume: "vol-12345" }]
      }

      stub_request(:post, "http://localhost/1.0/servers").
        with(:query => hash_including(:account_id),
             :headers => { "Authorization" => "Bearer FAKECACHEDTOKEN",
                           "Content-Type" => "application/json" },
                           :body => hash_including(expected_args)).
      to_return(:status => 202, :body => %q({"id":"srv-12345"}), :headers => {})

      @server = Fog::Brightbox::Compute::Server.new({ :service => service }.merge(options))
      assert @server.save
    end
  end

  describe "when snapshotting with no options" do
    it "returns the server" do
      stub_request(:post, "http://localhost/1.0/servers/srv-12345/snapshot").
        with(:query => hash_including(:account_id),
             :headers => { "Authorization" => "Bearer FAKECACHEDTOKEN" }).
        to_return(:status => 202, :body => %q({"id": "srv-12345"}), :headers => {})

      @server = Fog::Brightbox::Compute::Server.new(:service => service, :id => "srv-12345")
      assert_kind_of Hash, @server.snapshot
    end
  end

  describe "when snapshotting with link option" do
    it "returns the new image" do
      link = "<https://api.gb1.brightbox.com/1.0/images/img-12345>; rel=snapshot"

      stub_request(:post, "http://localhost/1.0/servers/srv-12345/snapshot").
        with(:headers => { "Authorization" => "Bearer FAKECACHEDTOKEN" }).
        to_return(:status => 202, :body => "{}", :headers => { "Link" => link })

      stub_request(:get, "http://localhost/1.0/images/img-12345").
        with(:query => hash_including(:account_id),
             :headers => { "Authorization" => "Bearer FAKECACHEDTOKEN" }).
        to_return(:status => 200, :body => %q({"id": "img-12345"}))
      @server = Fog::Brightbox::Compute::Server.new(:service => service, :id => "srv-12345")
      assert_kind_of Fog::Brightbox::Compute::Image, @server.snapshot(true)
    end
  end
end


text:
package org.olat.resource.accesscontrol.provider.token.ui;

import org.olat.core.gui.UserRequest;
import org.olat.core.gui.components.form.flexible.FormItemContainer;
import org.olat.core.gui.components.form.flexible.elements.TextElement;
import org.olat.core.gui.components.form.flexible.impl.Form;
import org.olat.core.gui.control.Controller;
import org.olat.core.gui.control.WindowControl;
import org.olat.resource.accesscontrol.model.AccessMethod;
import org.olat.resource.accesscontrol.model.OfferImpl;
import org.olat.resource.accesscontrol.model.OfferAccess;
import org.olat.resource.accesscontrol.ui.AbstractConfigurationMethodController;

/**
 *
 * Description:

 * Configuration for a token
 *
 *

 * Initial Date:  15 avr. 2011

 * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
 */
public class TokenAccessConfigurationController extends AbstractConfigurationMethodController {

	private TextElement descEl;
	private TextElement tokenEl;
	private final OfferAccess link;

	public TokenAccessConfigurationController(UserRequest ureq, WindowControl wControl, OfferAccess link) {
		super(ureq, wControl);
		this.link = link;
		initForm(ureq);
	}

	public TokenAccessConfigurationController(UserRequest ureq, WindowControl wControl, OfferAccess link, Form form) {
		super(ureq, wControl, LAYOUT_DEFAULT, null, form);
		this.link = link;
		initForm(ureq);
	}

	@Override
	protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
		formLayout.setElementCssClass("o_sel_accesscontrol_token_form");

		descEl = uifactory.addTextAreaElement("offer-desc", "offer.description", 2000, 6, 80, false, null, formLayout);
		descEl.setElementCssClass("o_sel_accesscontrol_description");

		String token = "";
		if(link.getOffer() instanceof OfferImpl) {
			token = ((OfferImpl)link.getOffer()).getToken();
		}
		tokenEl = uifactory.addTextElement("token", "accesscontrol.token", 255, token, formLayout);
		tokenEl.setElementCssClass("o_sel_accesscontrol_token");

		super.initForm(formLayout, listener, ureq);
	}

	@Override
	public AccessMethod getMethod() {
		return link.getMethod();
	}

	@Override
	public OfferAccess commitChanges() {
		if(link.getOffer() instanceof OfferImpl) {
			((OfferImpl)link.getOffer()).setToken(tokenEl.getValue());
		}
		link.getOffer().setDescription(descEl.getValue());
		return link;
	}

	@Override
	protected boolean validateFormLogic(UserRequest ureq) {
		boolean allOk = true;

		String token = tokenEl.getValue();
		tokenEl.clearError();
		if(token == null || token.length() < 2) {
			tokenEl.setErrorKey("invalid.token.format", null);
			allOk = false;
		}

		return allOk && super.validateFormLogic(ureq);
	}
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Leptosphaeria aglaja Sacc.

### Remarks
null


text:
import PropTypes from 'prop-types';
import React, { Component } from 'react';
import { withForwardedRef } from '@linkiwi/hoc';
import Spacing from 'components/spacing';
import Text from 'components/text';
import Check from 'icons/check';
import { colors } from 'styles/color';
import { transitionStyle } from 'styles/transition';
import noop from 'util/noop';

/**
 * Styled checkbox element.
 */
class Checkbox extends Component {
  static propTypes = {
    checked: PropTypes.bool,
    label: PropTypes.string,
    style: PropTypes.object,
    disabled: PropTypes.bool,
    onChange: PropTypes.func,
    children: PropTypes.node,
    forwardedRef: PropTypes.oneOfType([
      PropTypes.shape({ current: PropTypes.instanceOf(Element) }),
      PropTypes.func,
    ]),
  };

  static defaultProps = {
    checked: false,
    label: null,
    style: {},
    disabled: false,
    onChange: noop,
    children: null,
    forwardedRef: null,
  };

  state = { isHover: false, isFocus: false };

  handleClick = () => {
    const { checked, onChange, disabled } = this.props;

    return !disabled && onChange(!checked);
  };

  handleHoverChange = (isHover) => () => this.setState({ isHover });

  handleFocusChange = (isFocus) => () => this.setState({ isFocus });

  render() {
    const {
      checked,
      label,
      style: overrides,
      disabled,
      children,
      forwardedRef,
      ...proxyProps
    } = this.props;
    const { isHover, isFocus } = this.state;
    const isActive = isHover || isFocus;

    const backgroundColor = (() => {
      if (checked) {
        return colors.primary;
      }

      return disabled ? colors.gray5 : 'rgb(250, 250, 250)';
    })();

    const borderColor = (() => {
      if (checked) {
        return colors.primary;
      }

      return isActive ? colors.gray20 : colors.gray10;
    })();

    const containerStyle = {
      alignItems: 'center',
      background: 'inherit',
      border: 0,
      cursor: disabled ? 'inherit' : 'pointer',
      display: 'inline-flex',
      ...overrides,
    };

    const checkboxStyle = {
      alignItems: 'center',
      backgroundColor,
      border: `1px solid ${borderColor}`,
      display: 'flex',
      height: '14px',
      justifyContent: 'center',
      opacity: disabled ? 0.5 : 1,
      width: '14px',
      ...transitionStyle(),
    };

    const checkStyle = {
      fill: colors.gray5,
      height: '12px',
      opacity: checked ? 1 : 0,
      ...transitionStyle(),
    };

    return (
      <button
        ref={forwardedRef}
        role="checkbox"
        aria-checked={checked}
        style={containerStyle}
        onClick={this.handleClick}
        onMouseEnter={this.handleHoverChange(true)}
        onMouseLeave={this.handleHoverChange(false)}
        onFocus={this.handleFocusChange(true)}
        onBlur={this.handleFocusChange(false)}
        {...proxyProps}
      >
        <div style={checkboxStyle}>
          <Check style={checkStyle} />
        </div>

        {label && (
          <Spacing size="small" left inline>
            <Text size="iota" color="gray80" inline>
              {label}
            </Text>
          </Spacing>
        )}

        {children}
      </button>
    );
  }
}

export default withForwardedRef(Checkbox);


text:
import { Injectable } from '@angular/core';
import { BehaviorSubject } from 'rxjs';

@Injectable()
export class RouterStub {
  private subject = new BehaviorSubject(null);

  navigate() {
    return this.subject.asObservable();
  }
}