text:
_A french Contemporary RPG based on the D20 system / OGL 3.5._

Chroniques Oubliées Contemporain est un jeu de rôle doté d'un système simple mais complet basé sur le système d20/OGL 3.5.

Cette feuilles de personnage inclut quelques jets et règles optionnelles.

Le jeu complet est disponible sur le site de l'éditeur [Black Book Editions](http://www.black-book-editions.fr/produit.php?id=4349).

# Version courante

3.9.2 [Screenshot](coc_v2.png)

# Notes de version

## v3.9.2 (2021-04-27)

- Correction d'un bug sur le titre de la capacité de rang 4 de la voie n°2
- Correction du calcul du rang dans une voie : la case doit être cochée et soit le titre soit le texte de la capacité doit être renseigné

## v3.9.1 (2021-04-25)

- Correction d'un bug sur le titre de la capacité de rang 3 de la voie n°3 dupliquée dans la voie n°8

## v3.9.0 (2021-03-30)

- Ajout d'un champ titre pour chaque capacité (attributs @{voieN-tR} où N = no de voie et R = rang)
  - Migration automatique d'une version antérieure : la première ligne de la capacité est considérée comme titre
  - Prise en compte dans les autres fonctions (liaison d'un jet de capacité à une voie+rang, import de données de profil JSON)
- Correction d'un bug après suppression du seul modificateur d'attaque ou de DM de la liste (le modificateur n'est plus pris en compte dans les jets d'attaque)

## v3.8.1 (2021-03-01)

Suppression du code de remise en forme des textes de capacités par élimination des retours à la ligne

## v3.8 (2021-02-22)

_Fiche de PJ_

- Déplacement de l'initiative sur la 1ère ligne de la section combat
- Amélioration de la reconnaissance des propriétés d'équipement
  - **DEF : x** pour indiquer le bonus de DEFense d'une armure
  - **DEF- : x** pour indiquer le malus d'encombrement d'une armure
  - **RD : x** pour indiquer la réduction des DM d'une armure
  - **DM : dm type** pour indiquer les dés et le type de DM
    - Où _dm_ est {nombre}d{faces}
    - Suffixer _dm_ avec + ou ! pour des DM explosifs
  - **DM2 : dm2 type2** pour indiquer un second type et dés de DM

_Fiche de Véhicule_

- Ajout d'un type de véhicule et d'un bouton sur l'onglet Configuration
- Cliquer sur le bouton permet de générer une liste par défaut des jets de véhicule

## v3.7 (2020-12-21)

- Ajout d'un compteur optionnel sur l'onglet Caractéristiques sous les états préjudiciables
  - comporte un intitulé et une valeur (pas de valeur max.)
  - l'activation du compteur et son intitulé sont déterminés par le setting choisi sur l'onglet Configuration
  - permet de comptabiliser les Points de Folie (Cthulhu), Tension (Menace-X), Pulsion (Monstres), Ame/Rage/Sang (Surhumains Démons/Loups-garous/Vampires), etc...
- Ajout d'un champ Origine sous les champs Profil et Famille dans l'entête de la fiche. Les intitulés 'Profil', 'Famille' et 'Origine' sont modifiés en fonction du setting
- Pour le setting Monstres, remplacement de l'état Affaibli par la Poisse (moins bon de deux d20) pour tous les états préjudiciables utilisant le d12.
- Sur une fiche de véhicule, la section des traits physiques (sexe, âge, taille, poids) n'est pas affichée

## v3.6 (2020-09-04)

- Case à cocher sur l'onglet Capacités de la fiche de PJ permettant de basculer entre :
  - le mode Affichage, avec nom et description textuelle complète des capacités
  - le mode Edition, où l'utilisateur peut entrer le texte des capacités (la première ligne de texte est toujours considérée comme étant le nom de la capacité).
- Possibilité d'importer la liste des voies et des capacités du profil du personnage. Consulter la [documentation](https://stephaned68.github.io/ChroniquesContemporaines/import-abilities) pour plus de détails.
- Possibilité de lier un jet de capacité avec l'une des capacités de la grille, en indiquant le numéro de voie et le rang correspondant. Cette information est principalement utilisée par le script API COlib.

Le script API compagnon [COlib](https://github.com/stephaned68/COlib) permet un import des données, non seulement dans la fiche de personnage mais aussi dans le journal Roll20. Consulter la [documentation](https://stephaned68.github.io/COlib/commands) pour plus de détails.

## v3.5 (2020-08-22)

- Gestion des dés d'usure en mode CO Bitume. Pour chaque pièce d'équipement concernée, indiquer dans la liste des propriétés une propriété nommée Ud et donner en valeur le chiffre du dé d'usure (8 pour d8, 10 pour d10, etc...). Un bouton sous la liste des équipements permet de lancer un test d'usure en sélectionnant d'abord l'équipement concerné. En cas d'échec (le chiffre du jet dans le chat apparait en rouge), le dé d'usure de cette équipement doit être baissé d'un cran (ex : de 'Ud : 8' à 'Ud : 6', cf livre de règles).
- Gestion de la fiche de véhicule spécifique à Bitume avec :
  - Une liste des modifications du véhicule pour laquelle on peut indiquer :
    - le nombre d'emplacements pris par la modification, en cas de dépassement du nombre maximum (valeur de la caractéristique EMP) le nombre d'emplacement est remis à 0.
    - une liste éventuelle des caractéristiques que la modification booste (RAP, MAN, IMP).
    - une case permettant d'activer ou non la modification (et donc d'appliquer le buff correspondant)
  - Une gestion des dés d'usure du véhicule, avec possibilité d'indiquer le Ud maximum et le Ud courant et de faire les jets d'usure correspondant. Le Ud courant est automatiquement mis à jour d'une part en fonction du Ud maximum, et d'autre part en fonction des points d'avaries accumulés.

## v3.4 (2020-08-15)

- Amélioration de la logique d'import d'un statblock de PNJ ou de créature
- Lancement de l'import du statblock via un bouton

## v3.3 (2020-08-04)

- Génération automatique de lignes de ressources sur l'onglet équipement en fonction de l'univers choisi
- Ajout d'une liste de choix de surhumains permettant de générer automatique des lignes de ressources et/ou de déterminer les dés de vie, caractéristiques magiques, etc...

## v3.2 (2020-04-28)

- Modifications internes sur les champs INIT et DEF pour permettre la liaison de ces attributs avec un token (contourne un bug de Roll20 sur la liaison avec des champs auto-calculés)
- Ajout de cases à cocher pour chaque capacité (permet de remplir les voies à l'avance)
- Modifications cosmétiques (alignement des attributs sur le premier onglet de la fiche)

## v3.1 (2020-04-23)

- Déplacement des buffs généraux vers l'onglet **Capacités**
- Nouvelle présentation des buffs généraux :
  - Il s'agit à présent d'une liste répétable d'éléments
  - On indique le nom du buff, et la liste des attributs auxquels il s'applique, sous la forme _nom attribut : valeur de buff_, séparés par des virgules si le buff s'applique à plusieurs attributs.
  - Une case à cocher permet d'activer ou désactiver le buff
  - A chaque modification, les buffs par attributs sont recalculés et ré-assignés à la case **Divers** de chaque attribut.
  - On peut afficher le détail des buffs par attributs en cliquant sur la flèche appropriée.
- Remplacement des deux champs de modificateurs circonstanciels à l'attaque et aux dommages par deux listes répétables similaires à celles des buffs généraux
  - On indique le nom du modificateur et sa valeur.
  - Une case à cocher permet d'activer ou désactiver le modificateur.
  - Tant qu'une case est cochée, le modificateur correspondant est appliqué à chaque jet d'attaque et/ou de dommages.
  - Lorsqu'un modificateur d'attaque est activé ou désactivé, un buff général du même nom est recherché sur l'onglet **Capacités**, et s'il existe, celui-ci est synchronisé avec le modificateur d'attaque.
- Rappel sur les valeurs de buffs ou de modificateurs d'attaque :
  - Elles peuvent être une valeur fixe, _ex : Malingre : -1_
  - Elles peuvent être une référence à un attribut, _ex : Vue perçante : +[PER]_ pour utiliser le mod. de PERception
  - Elles peuvent être une référence à un rang dans une voie
    - Soit en utilisant les attributs RANG*VOIEx \_ex : Pilote émérite : +[RANG_VOIE1]*
    - Soit en utilisant le nom de la voie tel qu'il a été entré dans l'onglet **Capacités**, _ex : Pilote émérite : [rang Pilotage]_ pour un bonus de +1 par rang dans la voie, ou _ex : Discrétion : 2[rang Furtivité]_ pour un bonus de +2 par rang
  - Elles peuvent être une formule mathématique mettant en oeuvre plusieurs attributs, _ex Tenue de combat : +[RANG_VOIE1*DEFARMUREON]_
- Sur l'onglet **Equipement**, les deux listes d'équipements sont maintenant regroupées en une seule, permettant de :
  - Gérer l'encombrement (reprise des règles du Compagnon COF) en indiquant pour chaque équipement, une valeur d'encombrement, un nombre en inventaire, et si ce nombre est possédé ou porté (et compte donc dans l'encombrement).
  - Saisir une description détaillée de l'équipement en plus de son nom
  - Ajouter une ligne d'attaque sur l'onglet **Caractéristiques** ou la supprimer, en cochant ou décochant la case appropriée.
  - Indiquer une liste de propriétés (séparées par des virgules) pour l'équipement, avec modification des données correspondantes sur l'onglet **Caractéristiques**. Les propriétés reconnues sont :
    - **DEF : _bonus_** pour le bonus de DEFense d'une armure
    - **RD : _valeur_** pour la valeur de Réduction des DM d'une armure
    - **DM : _(nb)d(faces)_** pour les dés de DM d'une arme
    - **ATD : _portée_** pour la portée d'une arme à distance (sinon c'est une attaque au contact)
  - _Exemples_
    - _DEF : 2, RD : 5_ (pour un gilet pare-balles)
    - _DM : 1d6, ATD : 10m_ (pour un pistolet léger)
- Sur l'onglet **Capacités**, les jets de capacités ont été modifiés pour permettre d'ajouter à un jet un bonus lié à une voie possédée par le personnage. Il suffit pour cela de :
  - sélectionner la voie dont la possession procure un bonus au jet
  - sélectionner le type de bonus obtenu pour chaque rang possédé (+1 ou +2 par rang dans la voie)

## v2.9 (2020-02-12)

- Déplacement des parties règles optionnelles vers le tab caractéristiques
- Utilisation de coc_settings pour précharger les options de règles par défaut

## v2.8 (2019-10-10)

- Modifications du sheetworker pour éviter erreurs dans la console API
- Homogénéisation des noms des roll buttons
- Séparation des buffs circonstanciels de combat en deux champs : un pour le jet d'attaque et un pour le jet de dommages

## v2.7 (2019-29-06)

### Fiche PJ, onglet Configuration

- Ajout d'un champ de buff pour les PV
- Ajout d'un sélecteur pour le mode de calcul des points de vie (lancer le DV ou utiliser la valeur moyenne du DV)

### Fiche PJ, onglet Caractéristiques

- Modification du roll-button de lancement de dé de vie en action-button permettant d'augmenter le niveau de 1
- Ajout d'un script sheet-worker pour recalculer / lancer les points de vie lorsque le niveau, le mod de constitution, le buff de PV ou le mode de calcul des PV est modifié

### Modifications globales

Modification des attributs name de tous les roll-buttons en "roll_nomJet" et ajout des attributs title

- Permet d'invoquer un jet de dés de la fiche de personnage depuis le chat en indiquant %{selected|nomJet} (si un token est sélectionné) ou %{nomPerso|nomJet}
- Permet d'afficher le nom du jet qui peut être utilisé dans le chat ou les macros

## v2.6 (2019-04-17)

### Fiche de PJ

- Possibilité d'appliquer plusieurs états préjudiciables en même temps
- Gestion de l'encombrement (idem COF)
- Ajout d'un champ de texte sous la liste d'attaques pour les buffs "temporaires"
- Possibilité d'indiquer des buffs aux jets d'attaque et de dommages en langage quasi-naturel : le premier mot est le type d'attaque concernée, le deuxième est le modificateur (avec possibilité de référencer un autre attribut de la fiche en l'encadrant entre crochets []) et à partir du troisième, la description du buff.
- Indiquer ATC (contact), ATD (distance), MAG (att. magique), MEN (att. mentale), pour les types d'attaques, ATT pour toutes les attaques existantes. Indiquer d'abord DM pour un buff aux dommages
- Plusieurs buffs peuvent être indiqués et séparés par un point-virgule (;)
- Exemple : `DM ATC +2d6 Attaque en traître ; ATD +[PER] Visée`
- Il est nécessaire de cliquer en dehors du champ de saisie AVANT de presser un bouton d'attaque afin que le script sheet-worker approprié puisse s'exécuter.
- Ajout d'un bouton "Recycle" sur l'onglet Configuration pour forcer la fiche à recalculer quelques attributs (rangs atteints dans chaque voie, statbloc interne, encombrement)

### Fiche de PNJ

- Ajout Réduction de DM (RD)
- Ajout d'une liste de capacités / traits
- Amélioration du script d'import de statblock
- Ajout d'un script de conversion d'attributs PNJ => PJ

## v2.5 (2019-02-12)

- Gestion des buffs en langage naturel avec référence aux caracs ou voies/rangs
- Réorganisation des lignes d'attaque (PJ et PNJ), gestion des DM secondaires sur la fiche PJ, actions limitées
- Réorganisation des lignes de jets de capacités
- Réorganisation du roll template
- Refactorisation de code dans les sheetworkers

## v2.4 (2019-01-01)

- Fiche de personnage avec sélection du type par dropdown (PJ, PNJ ou Véhicule)
- Modification cosmétique de la fiche avec une bordure aux coins arrondis
- Plus de case Traits/Langues/Niveau de vie sur l'onglet Caractéristiques. Ces informations peuvent être indiquées dans la liste répétable des traits de l'onglet Capacités
- Ajout d'un sheet-worker permettant de détecter si le personnage a subi une blessure grave, quand il perd en une seule fois un nombre de PV supérieur au seuil. La case Blessure est automatiquement cochée et l'état préjudiciable Affaibli activé.
- Ajout d'une case à cocher COCY à côté de l'initiative permettant de gérer les multiples actions par round en Cyberpunk. Après avoir lancé l'initiative, le fait de cocher cette case permet au rang d'initiative du personnage de diminuer de -10 à chaque fois qu'un jet d'attaque est réalisé via la fiche.
- Les Traits sur l'onglet Capacités sont maintenant affichés en permanence
- Possibilité de faire un jet de PC sur l'onglet Equipement qui ne fait qu'un affichage dans le chat
- Trois choix d'initiative dans l'onglet Configuration : normale (init), variable (init + 1d6 explosif), cyberpunk (init + 1d6 explosif, résultat final limité à init de base x 2)
- Ajout de champs dans l'onglet Configuration permettant d'indiquer le bonus de PC ainsi que de les nommer (Points de Choc en Horreur, Points de Cash en Cyberpunk, Points de Chance chargé par défaut à la première ouverture de la fiche)
- Ajout de cases à cocher sur les lignes d'armes/attaques permettant de faire un jet d'attaque sans jet de dommages ou un jet de dommages sans jet d'attaque (fiches PJ et PNJ)
- Ajout d'une option Choix dans les Mods et Mods de test des jets de capacités permettant de choisir la caractéristique à utiliser au moment du jet
- Import du Statblock pour les PNJs
- Ajout d'une fiche de véhicule avec caractéristiques de base et liste répétable de jets permettant d'inclure les caractéristiques de véhicule et celles du personnage (pas de solution satisfaisante trouvée pour aller chercher les caractéristiques de la fiche du pilote dont le nom est indiqué)
- Modification cosmétique avec une bordure aux coins arrondis et un affichage élargi dans les rolls template
- Nouveau tag {{portee= }} permettant d'afficher la portée d'une arme à distance
- Modification du roll-template pour permettre l'affichage d'un jet de dommages même sans jet d'attaque préalable

## V2.3 (2018-12-13)

- Correction d'un bug sur le calcul des buffs Divers ATD et DEF

## v2.2 (2018-12-11)

- Modification du bouton de jet d'attaque pour générer un attribut pour chaque ligne.
- Correction des espaces dans la commande invoquée par le bouton d'attaque pour en permettre l'utilisation à la fois dans le chat et via l'API en appelant la pseudo ability %{nom|repeating*armes*\$n_jet} (où n est le no de ligne, base 0)
- Nommage du checkbox "Plus de voies" (@{voies789}) afin de préserver son état d'un appel à un autre de la fiche de personnage. Ce changement a été oublié dans les commits de la Version 2.1
- Modification du bouton de jet de capacité pour générer un attribut pour chaque ligne.
- Correction des espaces dans la commande invoquée par le bouton de jet de capacité pour en permettre l'utilisation à la fois dans le chat et via l'API en appelant la pseudo ability %{<nom du personnage>|repeating*jetcapas*\$n_jet} (où n est le no de ligne, base 0)
- Modification mineures des textes dans le sélecteur du type de jet de capacité
- Ajout d'un groupe d'options "Attaques" dans le sélecteur du modificateur de jet de capacité pour ajouter les attributs ATKxxx
- Ajout d'une section répétable "Autres traits" dans l'onglet Capacités, sous la liste des jets de capacités. Elle peut être montrée ou cachée (état préservé d'un appel de la fiche à l'autre). Cette nouvelle liste peut typiquement être utilisée pour noter les différents avantages liées aux types de surhumains, ou bien les différents implants d'un personnage cyberpunk, etc... Cette section comporte un bouton avec un picto "bulle" qui murmure la description du trait au joueur dans le chat.
- Réorganisation de l'onglet Equipement
- Ajout d'une section répétables "Autres ressources" avec saisie d'un nom et d'une valeur numérique. Elle peut servir à comptabiliser les points de Provisions, de Munitions ou de Transport en univers Post-Apo, ou le seuil de Cyberlose et la difficulté du test de résistance en univers Cyberpunk
- Ajout d'une section masquable pour les caractéristiques d'un véhicule, avec une liste répétable de jets liés, sur lesquels on peut indiquer à la fois des caractéristiques de personnage et des caractéristiques de véhicule comme modificateurs au jet
- Ajout d'un élément {{text}} dans le roll template (utilisé par les jets d'affichage des "Autres traits")
- Correction d'une typo dans la bulle d'aide du bonus divers à la DEX (DEX_BONUS)
- Nouvelle classe de bouton 'output' représentée par un picto de bulle d'aide (pour affichage des "Autres traits" dans le chat)
- Augmentation à 250 pixels de la hauteur allouée à l'élément {{desc}} d'un roll template
- Ajout d'une classe text pour affichage d'un élément {{text}} dans le roll template (police italique réduite, texte justifié sans limite de hauteur)

## v2.1 (2018-12-07)

- Ajout d'onglets
- Ajout du support des états préjudiciables Aveuglé, Etourdi, Immobilisé, Renversé, Surpris avec buffs aux statistiques de combat correspondantes
- Ajout d'une option "Explosif" dans le sélecteur du type de jet pour des jets ouverts / sans limite
- Ajout du d3 au selecteur des dés de dommages
- Ajout d'un groupe de dés de dommages "sans limite" (armes à feu)
- Ajout de deux options d'attaque sur la deuxième ligne : relance (reroll et reroll once) et seuil de relance (à indiquer sous la forme d'un seuil -- relance des 1 par défaut).
- Ajout d'un état "Poisse" consistant à lancer deux d20 et garder le moins bon
- Race est remplacé par famille sur la fiche

## v1.0 (2018-11-07)

Création de la feuille.


text:
module TrlnArgon
  module SolrDocument
    module Imprint
      def imprint_main_for_header_display
        imprint_main.reverse.map do |imprint|
          imprint_entry(imprint)
        end.join(' / ')
      end

      def imprint_multiple_for_display
        imprint_multiple.map { |imprint| imprint_entry(imprint) }
                        .concat(imprint_main.map { |imprint| imprint_entry(imprint) })
                        .uniq
                        .join('<br />').html_safe
      end

      def imprint_main_to_text
        @imprint_main_to_text ||= imprint_main.map do |imprint|
          imprint_entry(imprint)
        end
      end

      def imprint_main
        @imprint_main ||= deserialize_solr_field(TrlnArgon::Fields::IMPRINT_MAIN,
                                                 { type: '', label: '', value: '' },
                                                 :value)
      end

      def imprint_multiple
        @imprint_multiple ||= deserialize_solr_field(TrlnArgon::Fields::IMPRINT_MULTIPLE,
                                                     { type: '', label: '', value: '' },
                                                     :value)
      end

      private

      def imprint_entry(imprint)
        [imprint_type(imprint),
         imprint_label(imprint),
         imprint_value(imprint)].compact.join(': ')
      end

      def imprint_type(imprint)
        return if imprint[:type].blank? || I18n.t("trln_argon.imprint_type.#{imprint[:type]}").blank?
        I18n.t("trln_argon.imprint_type.#{imprint[:type]}")
      end

      def imprint_label(imprint)
        return if imprint[:label].blank?
        imprint[:label]
      end

      def imprint_value(imprint)
        return if imprint[:value].blank?
        imprint[:value]
      end
    end
  end
end

redpajama_set_name: RedPajamaGithub


text:
namespace content {

namespace {

// Handles the font list request on the blocking pool.
class FontMessageFilter : public ppapi::host::ResourceMessageFilter {
 public:
  FontMessageFilter();

  // ppapi::host::ResourceMessageFilter implementation.
  virtual scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(
      const IPC::Message& msg) OVERRIDE;
  virtual int32_t OnResourceMessageReceived(
      const IPC::Message& msg,
      ppapi::host::HostMessageContext* context) OVERRIDE;

 private:
  virtual ~FontMessageFilter();

  // Message handlers.
  int32_t OnHostMsgGetFontFamilies(ppapi::host::HostMessageContext* context);
  int32_t OnHostMsgGetFontsInFamily(ppapi::host::HostMessageContext* context,
                                    const std::string& family);

  DISALLOW_COPY_AND_ASSIGN(FontMessageFilter);
};

FontMessageFilter::FontMessageFilter() {
}

FontMessageFilter::~FontMessageFilter() {
}

scoped_refptr<base::TaskRunner> FontMessageFilter::OverrideTaskRunnerForMessage(
    const IPC::Message& msg) {
  // Use the blocking pool to get the font list (currently the only message)
  // Since getting the font list is non-threadsafe on Linux (for versions of
  // Pango predating 2013), use a sequenced task runner.
  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
  return pool->GetSequencedTaskRunner(
      pool->GetNamedSequenceToken(kFontListSequenceToken));
}

int32_t FontMessageFilter::OnResourceMessageReceived(
    const IPC::Message& msg,
    ppapi::host::HostMessageContext* context) {
  IPC_BEGIN_MESSAGE_MAP(FontMessageFilter, msg)
    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
        PpapiHostMsg_TrueTypeFontSingleton_GetFontFamilies,
        OnHostMsgGetFontFamilies)
    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
        PpapiHostMsg_TrueTypeFontSingleton_GetFontsInFamily,
        OnHostMsgGetFontsInFamily)
  IPC_END_MESSAGE_MAP()
  return PP_ERROR_FAILED;
}

int32_t FontMessageFilter::OnHostMsgGetFontFamilies(
    ppapi::host::HostMessageContext* context) {
  // OK to use "slow blocking" version since we're on the blocking pool.
  std::vector<std::string> font_families;
  GetFontFamilies_SlowBlocking(&font_families);
  // Sort the names in case the host platform returns them out of order.
  std::sort(font_families.begin(), font_families.end());

  context->reply_msg =
      PpapiPluginMsg_TrueTypeFontSingleton_GetFontFamiliesReply(font_families);
  return base::checked_cast<int32_t>(font_families.size());
}

int32_t FontMessageFilter::OnHostMsgGetFontsInFamily(
    ppapi::host::HostMessageContext* context,
    const std::string& family) {
  // OK to use "slow blocking" version since we're on the blocking pool.
  std::vector<ppapi::proxy::SerializedTrueTypeFontDesc> fonts_in_family;
  GetFontsInFamily_SlowBlocking(family, &fonts_in_family);

  context->reply_msg =
      PpapiPluginMsg_TrueTypeFontSingleton_GetFontsInFamilyReply(
          fonts_in_family);
  return base::checked_cast<int32_t>(fonts_in_family.size());
}

}  // namespace

PepperTrueTypeFontListHost::PepperTrueTypeFontListHost(
    BrowserPpapiHost* host,
    PP_Instance instance,
    PP_Resource resource)
    : ResourceHost(host->GetPpapiHost(), instance, resource) {
  AddFilter(scoped_refptr<ppapi::host::ResourceMessageFilter>(
      new FontMessageFilter()));
}

PepperTrueTypeFontListHost::~PepperTrueTypeFontListHost() {
}

}  // namespace content


text:
{% include 'header.html' %}

Trial research sites associated with {{ nct_id }}

{{ trial_title }}

        {% if facility_list|length > 0 %}

            {% for facility in facility_list %}

                {{ facility.name }}

                {{ facility.address|safe }}

            {% endfor %}

        {% endif %}

{% include 'footer.html' %}


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>About</title>

  <link rel="stylesheet" href="../css/bootstrap.min.css">
  <link rel="stylesheet" href="../css/bootstrap-select.css">

  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.5.0/css/font-awesome.min.css">

  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/ionicons/2.0.1/css/ionicons.min.css">

  <link rel="stylesheet" href="../css/AdminLTE.min.css">

  <link rel="stylesheet" href="../css/_all-skins.min.css">
  <link rel="stylesheet" href="../css/custom.css">

    @foreach($menutops as $menu_top)

      menu_top_link}}">{{$menu_top->menu_top_label}} &nbsp&nbsp&nbsp|

      @endforeach

    Capital Budgets
      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar-collapse">
            Menu
      </button>

      @if($mainmenu != NULL)

            @foreach($menumains as $menu_main)
                @if($menu_main->menu_main_label=='Projects')

menu_main_link}}">{{$menu_main->menu_main_label}} (current)

                @else

menu_main_link}}">{{$menu_main->menu_main_label}} (current)

                @endif
            @endforeach
            @foreach($menutops as $menu_top)

menu_top_link}}">{{$menu_top->menu_top_label}}

            @endforeach

          @foreach($menulefts as $menu_left)

menu_left_link}}" style="margin-right: 10px;">{{$menu_left->menu_left_label}}

          @endforeach

    @else

            @foreach($menumains as $menu_main)
                @if($menu_main->menu_main_label=='Projects')

menu_main_link}}">{{$menu_main->menu_main_label}} (current)

                @else

menu_main_link}}">{{$menu_main->menu_main_label}} (current)

                @endif
            @endforeach
            @foreach($menutops as $menu_top)

menu_top_link}}">{{$menu_top->menu_top_label}}

            @endforeach

          @foreach($menulefts as $menu_left)

menu_left_link}}" style="margin-right: 10px;">{{$menu_left->menu_left_label}}

          @endforeach

    @endif

        @foreach($menulefts as $index => $menu_left)
          @if($index ==3)

menu_left_link}}"> {{$menu_left->menu_left_label}}

          @else

menu_left_link}}"> {{$menu_left->menu_left_label}}

          @endif
        @endforeach

          @foreach($menulefts as $menu_left)

menu_left_link}}">{{$menu_left->menu_left_label}}

          @endforeach

{{$abouts->title}}

                {!! $abouts->body !!}

This work is licensed under a Creative Commons Attribution 4.0 International License. It was funded and developed by Friends of Devin Balkind, a political organization urging you to Vote for Devin Balkind for New York City Public Advocate in November. Learn more at  VoteDevin.com.


text:
<?php

/**
 * @namespace
 */
namespace ZendTest\Json;
use Zend\Json;

/**
 * @category   Zend
 * @package    Zend_JSON
 * @subpackage UnitTests
 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 * @group      Zend_JSON
 */
class JSONTest extends \PHPUnit_Framework_TestCase
{
    private $_originalUseBuiltinEncoderDecoderValue;

    public function setUp()
    {
        $this->_originalUseBuiltinEncoderDecoderValue = Json\Json::$useBuiltinEncoderDecoder;
    }

    public function tearDown()
    {
        Json\Json::$useBuiltinEncoderDecoder = $this->_originalUseBuiltinEncoderDecoderValue;
    }

    public function testJSONWithPhpJSONExtension()
    {
        if (!extension_loaded('json')) {
            $this->markTestSkipped('JSON extension is not loaded');
        }
        Json\Json::$useBuiltinEncoderDecoder = false;
        $this->_testJSON(array('string', 327, true, null));
    }

    public function testJSONWithBuiltins()
    {
        Json\Json::$useBuiltinEncoderDecoder = true;
        $this->_testJSON(array('string', 327, true, null));
    }

    /**
     * Test encoding and decoding in a single step
     * @param array $values   array of values to test against encode/decode
     */
    protected function _testJSON($values)
    {
        $encoded = Json\Json::encode($values);
        $this->assertEquals($values, Json\Json::decode($encoded));
    }

    /**
     * test null encoding/decoding
     */
    public function testNull()
    {
        $this->_testEncodeDecode(array(null));
    }

    /**
     * test boolean encoding/decoding
     */
    public function testBoolean()
    {
        $this->assertTrue(Json\Decoder::decode(Json\Encoder::encode(true)));
        $this->assertFalse(Json\Decoder::decode(Json\Encoder::encode(false)));
    }

    /**
     * test integer encoding/decoding
     */
    public function testInteger()
    {
        $this->_testEncodeDecode(array(-2));
        $this->_testEncodeDecode(array(-1));

        $zero = Json\Decoder::decode(Json\Encoder::encode(0));
        $this->assertEquals(0, $zero, 'Failed 0 integer test. Encoded: ' . serialize(Json\Encoder::encode(0)));
    }

    /**
     * test float encoding/decoding
     */
    public function testFloat()
    {
        $this->_testEncodeDecode(array(-2.1, 1.2));
    }

    /**
     * test string encoding/decoding
     */
    public function testString()
    {
        $this->_testEncodeDecode(array('string'));
        $this->assertEquals('', Json\Decoder::decode(Json\Encoder::encode('')), 'Empty string encoded: ' . serialize(Json\Encoder::encode('')));
    }

    /**
     * Test backslash escaping of string
     */
    public function testString2()
    {
        $string   = 'INFO: Path \\\\test\\123\\abc';
        $expected = '"INFO: Path \\\\\\\\test\\\\123\\\\abc"';
        $encoded = Json\Encoder::encode($string);
        $this->assertEquals($expected, $encoded, 'Backslash encoding incorrect: expected: ' . serialize($expected) . '; received: ' . serialize($encoded) . "\n");
        $this->assertEquals($string, Json\Decoder::decode($encoded));
    }

    /**
     * Test newline escaping of string
     */
    public function testString3()
    {
        $expected = '"INFO: Path\nSome more"';
        $string   = "INFO: Path\nSome more";
        $encoded  = Json\Encoder::encode($string);
        $this->assertEquals($expected, $encoded, 'Newline encoding incorrect: expected ' . serialize($expected) . '; received: ' . serialize($encoded) . "\n");
        $this->assertEquals($string, Json\Decoder::decode($encoded));
    }

    /**
     * Test tab/non-tab escaping of string
     */
    public function testString4()
    {
        $expected = '"INFO: Path\\t\\\\tSome more"';
        $string   = "INFO: Path\t\\tSome more";
        $encoded  = Json\Encoder::encode($string);
        $this->assertEquals($expected, $encoded, 'Tab encoding incorrect: expected ' . serialize($expected) . '; received: ' . serialize($encoded) . "\n");
        $this->assertEquals($string, Json\Decoder::decode($encoded));
    }

    /**
     * Test double-quote escaping of string
     */
    public function testString5()
    {
        $expected = '"INFO: Path \"Some more\""';
        $string   = 'INFO: Path "Some more"';
        $encoded  = Json\Encoder::encode($string);
        $this->assertEquals($expected, $encoded, 'Quote encoding incorrect: expected ' . serialize($expected) . '; received: ' . serialize($encoded) . "\n");
        $this->assertEquals($string, Json\Decoder::decode($encoded));
    }

    /**
     * test indexed array encoding/decoding
     */
    public function testArray()
    {
        $array = array(1, 'one', 2, 'two');
        $encoded = Json\Encoder::encode($array);
        $this->assertSame($array, Json\Decoder::decode($encoded), 'Decoded array does not match: ' . serialize($encoded));
    }

    /**
     * test associative array encoding/decoding
     */
    public function testAssocArray()
    {
        $this->_testEncodeDecode(array(array('one' => 1, 'two' => 2)));
    }

    /**
     * test associative array encoding/decoding, with mixed key types
     */
    public function testAssocArray2()
    {
        $this->_testEncodeDecode(array(array('one' => 1, 2 => 2)));
    }

    /**
     * test associative array encoding/decoding, with integer keys not starting at 0
     */
    public function testAssocArray3()
    {
        $this->_testEncodeDecode(array(array(1 => 'one', 2 => 'two')));
    }

    /**
     * test object encoding/decoding (decoding to array)
     */
    public function testObject()
    {
        $value = new \stdClass();
        $value->one = 1;
        $value->two = 2;

        $array = array('__className' => 'stdClass', 'one' => 1, 'two' => 2);

        $encoded = Json\Encoder::encode($value);
        $this->assertSame($array, Json\Decoder::decode($encoded));
    }

    /**
     * test object encoding/decoding (decoding to stdClass)
     */
    public function testObjectAsObject()
    {
        $value = new \stdClass();
        $value->one = 1;
        $value->two = 2;

        $encoded = Json\Encoder::encode($value);
        $decoded = Json\Decoder::decode($encoded, Json\Json::TYPE_OBJECT);
        $this->assertTrue(is_object($decoded), 'Not decoded as an object');
        $this->assertTrue($decoded instanceof \StdClass, 'Not a StdClass object');
        $this->assertTrue(isset($decoded->one), 'Expected property not set');
        $this->assertEquals($value->one, $decoded->one, 'Unexpected value');
    }

    /**
     * Test that arrays of objects decode properly; see issue #144
     */
    public function testDecodeArrayOfObjects()
    {
        $value = '[{"id":1},{"foo":2}]';
        $expect = array(array('id' => 1), array('foo' => 2));
        $this->assertEquals($expect, Json\Decoder::decode($value));
    }

    /**
     * Test that objects of arrays decode properly; see issue #107
     */
    public function testDecodeObjectOfArrays()
    {
        $value = '{"codeDbVar" : {"age" : ["int", 5], "prenom" : ["varchar", 50]}, "234" : [22, "jb"], "346" : [64, "francois"], "21" : [12, "paul"]}';
        $expect = array(
            'codeDbVar' => array(
                'age'   => array('int', 5),
                'prenom' => array('varchar', 50),
            ),
            234 => array(22, 'jb'),
            346 => array(64, 'francois'),
            21  => array(12, 'paul')
        );
        $this->assertEquals($expect, Json\Decoder::decode($value));
    }

    /**
     * Test encoding and decoding in a single step
     * @param array $values   array of values to test against encode/decode
     */
    protected function _testEncodeDecode($values)
    {
        foreach ($values as $value) {
            $encoded = Json\Encoder::encode($value);
            $this->assertEquals($value, Json\Decoder::decode($encoded));
        }
    }

    /**
     * Test that version numbers such as 4.10 are encoded and decoded properly;
     * See ZF-377
     */
    public function testEncodeReleaseNumber()
    {
        $value = '4.10';

        $this->_testEncodeDecode(array($value));
    }

    /**
     * Tests that spaces/linebreaks prior to a closing right bracket don't throw
     * exceptions. See ZF-283.
     */
    public function testEarlyLineBreak()
    {
        $expected = array('data' => array(1, 2, 3, 4));

        $json = '{"data":[1,2,3,4' . "\n]}";
        $this->assertEquals($expected, Json\Decoder::decode($json));

        $json = '{"data":[1,2,3,4 ]}';
        $this->assertEquals($expected, Json\Decoder::decode($json));
    }

    /**
     * Tests for ZF-504
     *
     * Three confirmed issues reported:
     * - encoder improperly encoding empty arrays as structs
     * - decoder happily decoding clearly borked JSON
     * - decoder decoding octal values improperly (shouldn't decode them at all, as JSON does not support them)
     */
    public function testZf504()
    {
        $test = array();
        $this->assertSame('[]', Json\Encoder::encode($test));

        try {
            $json = '[a"],["a],[][]';
            $test = Json\Decoder::decode($json);
            $this->fail("Should not be able to decode '$json'");

            $json = '[a"],["a]';
            $test = Json\Decoder::decode($json);
            $this->fail("Should not be able to decode '$json'");
        } catch (\Exception $e) {
            // success
        }

        try {
            $expected = 010;
            $test = Json\Decoder::decode('010');
            $this->fail('Octal values are not supported in JSON notation');
        } catch (\Exception $e) {
            // sucess
        }
    }

    /**
     * Tests for ZF-461
     *
     * Check to see that cycling detection works properly
     */
    public function testZf461()
    {
        $item1 = new Item() ;
        $item2 = new Item() ;
        $everything = array() ;
        $everything['allItems'] = array($item1, $item2) ;
        $everything['currentItem'] = $item1 ;

        try {
            $encoded = Json\Encoder::encode($everything);
        } catch (\Exception $e) {
            $this->fail('Object cycling checks should check for recursion, not duplicate usage of an item');
        }

        try {
            $encoded = Json\Encoder::encode($everything, true);
            $this->fail('Object cycling not allowed when cycleCheck parameter is true');
        } catch (\Exception $e) {
            // success
        }
    }

    /**
     * Test for ZF-4053
     *
     * Check to see that cyclical exceptions are silenced when
     * $option['silenceCyclicalExceptions'] = true is used
     */
    public function testZf4053()
    {
        $item1 = new Item() ;
        $item2 = new Item() ;
        $everything = array() ;
        $everything['allItems'] = array($item1, $item2) ;
        $everything['currentItem'] = $item1 ;

        $options = array('silenceCyclicalExceptions'=>true);

        Json\Json::$useBuiltinEncoderDecoder = true;
        $encoded = Json\Json::encode($everything, true, $options);
        $json = '{"allItems":[{"__className":"ZendTest\\\\Json\\\\Item"},{"__className":"ZendTest\\\\Json\\\\Item"}],"currentItem":"* RECURSION (ZendTest\\\\Json\\\\Item) *"}';

        $this->assertEquals($json, $encoded);
    }

    public function testEncodeObject()
    {
        $actual  = new Object();
        $encoded = Json\Encoder::encode($actual);
        $decoded = Json\Decoder::decode($encoded, Json\Json::TYPE_OBJECT);

        $this->assertTrue(isset($decoded->__className));
        $this->assertEquals('ZendTest\Json\Object', $decoded->__className);
        $this->assertTrue(isset($decoded->foo));
        $this->assertEquals('bar', $decoded->foo);
        $this->assertTrue(isset($decoded->bar));
        $this->assertEquals('baz', $decoded->bar);
        $this->assertFalse(isset($decoded->_foo));
    }

    public function testEncodeClass()
    {
        $encoded = Json\Encoder::encodeClass('ZendTest\Json\Object');

        $this->assertContains("Class.create('ZendTest\\Json\\Object'", $encoded);
        $this->assertContains("ZAjaxEngine.invokeRemoteMethod(this, 'foo'", $encoded);
        $this->assertContains("ZAjaxEngine.invokeRemoteMethod(this, 'bar'", $encoded);
        $this->assertNotContains("ZAjaxEngine.invokeRemoteMethod(this, 'baz'", $encoded);

        $this->assertContains('variables:{foo:"bar",bar:"baz"}', $encoded);
        $this->assertContains('constants : {FOO: "bar"}', $encoded);
    }

    public function testEncodeClasses()
    {
        $encoded = Json\Encoder::encodeClasses(array('ZendTest\Json\Object', 'Zend\Json\Json'));

        $this->assertContains("Class.create('ZendTest\\Json\\Object'", $encoded);
        $this->assertContains("Class.create('Zend\\Json\\Json'", $encoded);
    }

    public function testToJSONSerialization()
    {
        $toJSONObject = new ToJSONClass();

        $result = Json\Json::encode($toJSONObject);

        $this->assertEquals('{"firstName":"John","lastName":"Doe","email":"john@doe.com"}', $result);
    }

     /**
     * test encoding array with Zend_JSON_Expr
     *
     * @group ZF-4946
     */
    public function testEncodingArrayWithExpr()
    {
        $expr = new Json\Expr('window.alert("Zend JSON Expr")');
        $array = array('expr'=>$expr, 'int'=>9, 'string'=>'text');
        $result = Json\Json::encode($array, false, array('enableJsonExprFinder' => true));
        $expected = '{"expr":window.alert("Zend JSON Expr"),"int":9,"string":"text"}';
        $this->assertEquals($expected, $result);
    }

    /**
     * test encoding object with Zend_JSON_Expr
     *
     * @group ZF-4946
     */
    public function testEncodingObjectWithExprAndInternalEncoder()
    {
        Json\Json::$useBuiltinEncoderDecoder = true;

        $expr = new Json\Expr('window.alert("Zend JSON Expr")');
        $obj = new \stdClass();
        $obj->expr = $expr;
        $obj->int = 9;
        $obj->string = 'text';
        $result = Json\Json::encode($obj, false, array('enableJsonExprFinder' => true));
        $expected = '{"__className":"stdClass","expr":window.alert("Zend JSON Expr"),"int":9,"string":"text"}';
        $this->assertEquals($expected, $result);
    }

    /**
     * test encoding object with Zend_JSON_Expr
     *
     * @group ZF-4946
     */
    public function testEncodingObjectWithExprAndExtJSON()
    {
        if(!function_exists('json_encode')) {
            $this->markTestSkipped('Test only works with ext/json enabled!');
        }

        Json\Json::$useBuiltinEncoderDecoder = false;

        $expr = new Json\Expr('window.alert("Zend JSON Expr")');
        $obj = new \stdClass();
        $obj->expr = $expr;
        $obj->int = 9;
        $obj->string = 'text';
        $result = Json\Json::encode($obj, false, array('enableJsonExprFinder' => true));
        $expected = '{"expr":window.alert("Zend JSON Expr"),"int":9,"string":"text"}';
        $this->assertEquals($expected, $result);
    }

    /**
     * test encoding object with ToJSON and Zend_JSON_Expr
     *
     * @group ZF-4946
     */
    public function testToJSONWithExpr()
    {
        Json\Json::$useBuiltinEncoderDecoder = true;

        $obj = new ToJSONWithExpr();
        $result = Json\Json::encode($obj, false, array('enableJsonExprFinder' => true));
        $expected = '{"expr":window.alert("Zend JSON Expr"),"int":9,"string":"text"}';
        $this->assertEquals($expected, $result);
    }

    /**
     * Regression tests for Zend_JSON_Expr and mutliple keys with the same name.
     *
     * @group ZF-4946
     */
    public function testEncodingMultipleNestedSwitchingSameNameKeysWithDifferentJSONExprSettings()
    {
        $data = array(
            0 => array(
                "alpha" => new Json\Expr("function(){}"),
                "beta"  => "gamma",
            ),
            1 => array(
                "alpha" => "gamma",
                "beta"  => new Json\Expr("function(){}"),
            ),
            2 => array(
                "alpha" => "gamma",
                "beta" => "gamma",
            )
        );
        $result = Json\Json::encode($data, false, array('enableJsonExprFinder' => true));

        $this->assertEquals(
            '[{"alpha":function(){},"beta":"gamma"},{"alpha":"gamma","beta":function(){}},{"alpha":"gamma","beta":"gamma"}]',
            $result
        );
    }

    /**
     * Regression tests for Zend_JSON_Expr and mutliple keys with the same name.
     *
     * @group ZF-4946
     */
    public function testEncodingMultipleNestedIteratedSameNameKeysWithDifferentJSONExprSettings()
    {
        $data = array(
            0 => array(
                "alpha" => "alpha"
            ),
            1 => array(
                "alpha" => "beta",
            ),
            2 => array(
                "alpha" => new Json\Expr("gamma"),
            ),
            3 => array(
                "alpha" => "delta",
            ),
            4 => array(
                "alpha" => new Json\Expr("epsilon"),
            )
        );
        $result = Json\Json::encode($data, false, array('enableJsonExprFinder' => true));

        $this->assertEquals('[{"alpha":"alpha"},{"alpha":"beta"},{"alpha":gamma},{"alpha":"delta"},{"alpha":epsilon}]', $result);
    }

    public function testDisabledJSONExprFinder()
    {
        Json\Json::$useBuiltinEncoderDecoder = true;

        $data = array(
            0 => array(
                "alpha" => new Json\Expr("function(){}"),
                "beta"  => "gamma",
            ),
        );
        $result = Json\Json::encode($data);

        $this->assertEquals(
            '[{"alpha":{"__className":"Zend\\\\Json\\\\Expr"},"beta":"gamma"}]',
            $result
        );
    }

    /**
     * @group ZF-4054
     */
    public function testEncodeWithUtf8IsTransformedToPackedSyntax()
    {
        $data = array("Отмена");
        $result = Json\Encoder::encode($data);

        $this->assertEquals('["\u041e\u0442\u043c\u0435\u043d\u0430"]', $result);
    }

    /**
     * @group ZF-4054
     *
     * This test contains assertions from the Solar Framework by Paul M. Jones
     * @link http://solarphp.com
     */
    public function testEncodeWithUtf8IsTransformedSolarRegression()
    {
        $expect = '"h\u00c3\u00a9ll\u00c3\u00b6 w\u00c3\u00b8r\u00c5\u201ad"';
        $this->assertEquals($expect,           Json\Encoder::encode('héllö wørłd'));
        $this->assertEquals('héllö wørłd', Json\Decoder::decode($expect));

        $expect = '"\u0440\u0443\u0441\u0441\u0438\u0448"';
        $this->assertEquals($expect,  Json\Encoder::encode("руссиш"));
        $this->assertEquals("руссиш", Json\Decoder::decode($expect));
    }

    /**
     * @group ZF-4054
     */
    public function testEncodeUnicodeStringSolarRegression()
    {
        $value    = 'héllö wørłd';
        $expected = 'h\u00c3\u00a9ll\u00c3\u00b6 w\u00c3\u00b8r\u00c5\u201ad';
        $this->assertEquals($expected, Json\Encoder::encodeUnicodeString($value));

        $value    = "\xC3\xA4";
        $expected = '\u00e4';
        $this->assertEquals($expected, Json\Encoder::encodeUnicodeString($value));

        $value    = "\xE1\x82\xA0\xE1\x82\xA8";
        $expected = '\u10a0\u10a8';
        $this->assertEquals($expected, Json\Encoder::encodeUnicodeString($value));
    }

    /**
     * @group ZF-4054
     */
    public function testDecodeUnicodeStringSolarRegression()
    {
        $expected = 'héllö wørłd';
        $value    = 'h\u00c3\u00a9ll\u00c3\u00b6 w\u00c3\u00b8r\u00c5\u201ad';
        $this->assertEquals($expected, Json\Decoder::decodeUnicodeString($value));

        $expected = "\xC3\xA4";
        $value    = '\u00e4';
        $this->assertEquals($expected, Json\Decoder::decodeUnicodeString($value));

        $value    = '\u10a0';
        $expected = "\xE1\x82\xA0";
        $this->assertEquals($expected, Json\Decoder::decodeUnicodeString($value));
    }

    /**
     * @group ZF-4054
     *
     * This test contains assertions from the Solar Framework by Paul M. Jones
     * @link http://solarphp.com
     */
    public function testEncodeWithUtf8IsTransformedSolarRegressionEqualsJSONExt()
    {
        if(function_exists('json_encode') == false) {
            $this->markTestSkipped('Test can only be run, when ext/json is installed.');
        }

        $this->assertEquals(
            json_encode('héllö wørłd'),
            Json\Encoder::encode('héllö wørłd')
        );

        $this->assertEquals(
            json_encode("руссиш"),
            Json\Encoder::encode("руссиш")
        );
    }

    /**
     * @group ZF-4946
     */
    public function testUtf8JSONExprFinder()
    {
        $data = array("Отмена" => new Json\Expr("foo"));

        Json\Json::$useBuiltinEncoderDecoder = true;
        $result = Json\Json::encode($data, false, array('enableJsonExprFinder' => true));
        $this->assertEquals('{"\u041e\u0442\u043c\u0435\u043d\u0430":foo}', $result);
        Json\Json::$useBuiltinEncoderDecoder = false;

        $result = Json\Json::encode($data, false, array('enableJsonExprFinder' => true));
        $this->assertEquals('{"\u041e\u0442\u043c\u0435\u043d\u0430":foo}', $result);
    }

    /**
     * @group ZF-4437
     */
    public function testKommaDecimalIsConvertedToCorrectJSONWithDot()
    {
        $localeInfo = localeconv();
        if($localeInfo['decimal_point'] != ",") {
            $this->markTestSkipped("This test only works for platforms where , is the decimal point separator.");
        }

        Json\Json::$useBuiltinEncoderDecoder = true;
        $this->assertEquals("[1.20, 1.68]", Json\Encoder::encode(array(
            (float)"1,20", (float)"1,68"
        )));
    }

    public function testEncodeObjectImplementingIterator()
    {
        $this->markTestIncomplete('Test is not yet finished.');
    }

    /**
     * @group ZF-8663
     */
    public function testNativeJSONEncoderWillProperlyEncodeSolidusInStringValues()
    {
        $source = "</foo><foo>bar</foo>";
        $target = '"<\\/foo><foo>bar<\\/foo>"';

        // first test ext/json
        Json\Json::$useBuiltinEncoderDecoder = false;
        $this->assertEquals($target, Json\Json::encode($source));
    }

    /**
     * @group ZF-8663
     */
    public function testBuiltinJSONEncoderWillProperlyEncodeSolidusInStringValues()
    {
        $source = "</foo><foo>bar</foo>";
        $target = '"<\\/foo><foo>bar<\\/foo>"';

        // first test ext/json
        Json\Json::$useBuiltinEncoderDecoder = true;
        $this->assertEquals($target, Json\Json::encode($source));
    }

    /**
     * @group ZF-8918
     */
    public function testDecodingInvalidJSONShouldRaiseAnException()
    {
        $this->setExpectedException('Zend\Json\Exception');
        Json\Json::decode(' some string ');
    }

    /**
     * @group ZF-9416
     * Encoding an iterator using the internal encoder should handle undefined keys
     */
    public function testIteratorWithoutDefinedKey()
    {
        $inputValue = new \ArrayIterator(array('foo'));
        $encoded = Json\Encoder::encode($inputValue);
        $expectedDecoding = '{"__className":"ArrayIterator",0:"foo"}';
        $this->assertEquals($expectedDecoding, $encoded);
    }
}

/**
 * Zend_JSONTest_Item: test item for use with testZf461()
 */
class Item
{
}

/**
 * Zend_JSONTest_Object: test class for encoding classes
 */
class Object
{
    const FOO = 'bar';

    public $foo = 'bar';
    public $bar = 'baz';

    protected $_foo = 'fooled you';

    public function foo($bar, $baz)
    {
    }

    public function bar($baz)
    {
    }

    protected function baz()
    {
    }
}

class ToJSONClass
{
    private $_firstName = 'John';

    private $_lastName = 'Doe';

    private $_email = 'john@doe.com';

    public function toJSON()
    {
        $data = array(
            'firstName' => $this->_firstName,
            'lastName'  => $this->_lastName,
            'email'     => $this->_email
        );

        return Json\Json::encode($data);
    }
}

/**
 * ISSUE  ZF-4946
 *
 */
class ToJSONWithExpr
{
    private $_string = 'text';
    private $_int = 9;
    private $_expr = 'window.alert("Zend JSON Expr")';

    public function toJSON()
    {
        $data = array(
            'expr'   => new Json\Expr($this->_expr),
            'int'    => $this->_int,
            'string' => $this->_string
        );

        return Json\Json::encode($data, false, array('enableJsonExprFinder' => true));
    }
}


text:
namespace Google.Cloud.Compute.V1.Snippets
{
    // [START compute_v1_generated_PublicAdvertisedPrefixes_Get_async]
    using Google.Cloud.Compute.V1;
    using System.Threading.Tasks;

    public sealed partial class GeneratedPublicAdvertisedPrefixesClientSnippets
    {
        /// <summary>Snippet for GetAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated and should be regarded as a code template only.
        /// It will require modifications to work:
        /// - It may require correct/in-range values for request initialization.
        /// - It may require specifying regional endpoints when creating the service client as shown in
        ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
        /// </remarks>
        public async Task GetRequestObjectAsync()
        {
            // Create client
            PublicAdvertisedPrefixesClient publicAdvertisedPrefixesClient = await PublicAdvertisedPrefixesClient.CreateAsync();
            // Initialize request argument(s)
            GetPublicAdvertisedPrefixeRequest request = new GetPublicAdvertisedPrefixeRequest
            {
                PublicAdvertisedPrefix = "",
                Project = "",
            };
            // Make the request
            PublicAdvertisedPrefix response = await publicAdvertisedPrefixesClient.GetAsync(request);
        }
    }
    // [END compute_v1_generated_PublicAdvertisedPrefixes_Get_async]
}


text:
package org.motechproject.scheduletracking.service;

import org.joda.time.DateTime;
import org.motechproject.commons.date.model.Time;

import java.util.Map;

/**
 * \ingroup sts
 *
 * This is the record which will be returned when schedule tracking service is queried for enrollments
 * It holds the details of an enrollment
 *
 */
public class EnrollmentRecord {
    private String externalId;
    private String scheduleName;
    private String currentMilestoneName;
    private DateTime referenceDateTime;
    private DateTime enrollmentDateTime;
    private Time preferredAlertTime;
    private DateTime earliestStart;
    private DateTime dueStart;
    private DateTime lateStart;
    private DateTime maxStart;
    private String status;
    private Map<String, String> metadata;

    public EnrollmentRecord() {
    }

    /**
     * This returns the External Id of an EnrollmentRecord
     * @return String
     */
    public String getExternalId() {
        return externalId;
    }

    /**
     * This returns the Schedule Name of an EnrollmentRecord
     * @return String
     */
    public String getScheduleName() {
        return scheduleName;
    }

    /**
     * This returns the preferred alert time of an EnrollmentRecord
     * @return Time
     */
    public Time getPreferredAlertTime() {
        return preferredAlertTime;
    }

    /**
     * This returns the reference datetime of an EnrollmentRecord
     * @return DateTime
     */
    public DateTime getReferenceDateTime() {
        return referenceDateTime;
    }

    /**
     * This returns the enrollment datetime of an EnrollmentRecord
     * @return DateTime
     */
    public DateTime getEnrollmentDateTime() {
        return enrollmentDateTime;
    }

    /**
     * This returns the earliest window start datetime of current milestone of an EnrollmentRecord
     * @return DateTime
     */
    public DateTime getStartOfEarliestWindow() {
        return earliestStart;
    }

    /**
     * This returns the due window start datetime of current milestone of an EnrollmentRecord
     * @return DateTime
     */
    public DateTime getStartOfDueWindow() {
        return dueStart;
    }

    /**
     * This returns the late window start datetime of current milestone of an EnrollmentRecord
     * @return DateTime
     */
    public DateTime getStartOfLateWindow() {
        return lateStart;
    }

    /**
     * This returns the max window start datetime of current milestone of an EnrollmentRecord
     * @return DateTime
     */
    public DateTime getStartOfMaxWindow() {
        return maxStart;
    }

    /**
     * This returns the current milestone name of an EnrollmentRecord
     * @return String
     */
    public String getCurrentMilestoneName() {
        return currentMilestoneName;
    }

    /**
     * This returns the status of the enrollment
     * @return String
     */
    public String getStatus() {
        return status;
    }

    /**
     * This returns the metadata associated with the enrollment
     * @return String
     */
    public Map<String, String> getMetadata() {
        return metadata;
    }

    public EnrollmentRecord setExternalId(String externalId) {
        this.externalId = externalId;
        return this;
    }

    public EnrollmentRecord setScheduleName(String scheduleName) {
        this.scheduleName = scheduleName;
        return this;
    }

    public EnrollmentRecord setPreferredAlertTime(Time preferredAlertTime) {
        this.preferredAlertTime = preferredAlertTime;
        return this;
    }

    public EnrollmentRecord setReferenceDateTime(DateTime referenceDateTime) {
        this.referenceDateTime = referenceDateTime;
        return this;
    }

    public EnrollmentRecord setEnrollmentDateTime(DateTime enrollmentDateTime) {
        this.enrollmentDateTime = enrollmentDateTime;
        return this;
    }

    public EnrollmentRecord setEarliestStart(DateTime earliestStart) {
        this.earliestStart = earliestStart;
        return this;
    }

    public EnrollmentRecord setDueStart(DateTime dueStart) {
        this.dueStart = dueStart;
        return this;
    }

    public EnrollmentRecord setLateStart(DateTime lateStart) {
        this.lateStart = lateStart;
        return this;
    }

    public EnrollmentRecord setMaxStart(DateTime maxStart) {
        this.maxStart = maxStart;
        return this;
    }

    public EnrollmentRecord setCurrentMilestoneName(String currentMilestoneName) {
        this.currentMilestoneName = currentMilestoneName;
        return this;
    }

    public EnrollmentRecord setStatus(String status) {
        this.status = status;
        return this;
    }

    public EnrollmentRecord setMetadata(Map<String, String> metadata) {
        this.metadata = metadata;
        return this;
    }
}


text:
"""warcextract - dump warc record context to standard out"""

from __future__ import print_function

import os
import sys

import sys
import os.path

from optparse import OptionParser
from contextlib import closing

from .warctools import WarcRecord

parser = OptionParser(usage="%prog [options] warc offset")

#parser.add_option("-l", "--limit", dest="limit")
parser.add_option("-I", "--input", dest="input_format")
parser.add_option("-L", "--log-level", dest="log_level")

parser.set_defaults(output_directory=None, limit=None, log_level="info")

def main(argv):
    (options, args) = parser.parse_args(args=argv[1:])

    try: # python3
        out = sys.stdout.buffer
    except AttributeError: # python2
        out = sys.stdout

    if len(args) < 1:
        # dump the first record on stdin
        with closing(WarcRecord.open_archive(file_handle=sys.stdin, gzip=None)) as fh:
            dump_record(fh, out)

    else:
        # dump a record from the filename, with optional offset
        filename = args[0]
        if len(args) > 1:
            offset = int(args[1])
        else:
            offset = 0

        with closing(WarcRecord.open_archive(filename=filename, gzip="auto")) as fh:
            fh.seek(offset)
            dump_record(fh, out)

    return 0

def dump_record(fh, out):
    for (offset, record, errors) in fh.read_records(limit=1, offsets=False):
        if record:
            out.write(record.content[1])
        elif errors:
            print("warc errors at %s:%d"%(name, offset if offset else 0), file=sys.stderr)
            for e in errors:
                print('\t', e)
        break # only use one (I'm terrible)

def run():
    sys.exit(main(sys.argv))

if __name__ == '__main__':
    run()


text:
import { createContext } from 'react'
import { DEFAULT_OPTIONS } from '../options'

const OptionsContext = createContext(DEFAULT_OPTIONS)

export default OptionsContext


text:
<?php

namespace backend\controllers;

use common\models\Message;
use common\models\SourceMessage;
use common\models\search\MessageSearch;
use Yii;
use yii\base\InvalidParamException;
use yii\web\NotFoundHttpException;
use yii\helpers\Url;

/**
 * Class TranslationAdminController
 * @package backend\controllers
 */
class TranslationAdminController extends BaseController
{
    public function actionIndex()
    {
        $searchModel = new MessageSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }

    /**
     * Displays a single Message model.
     * @param integer $id
     * @param string $language
     * @return mixed
     * @throws InvalidParamException if the view file or the layout file does not exist.
     */
    public function actionView($id, $language)
    {
        return $this->render('view', [
            'model' => $this->findModel($id, $language),
        ]);
    }

    /**
     * Updates an existing Message model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param integer $id
     * @param string $language
     * @return mixed
     * @throws InvalidParamException if the view file or the layout file does not exist.
     */
    public function actionUpdate($id, $language)
    {
        $model = $this->findModel($id, $language);
        $sourceMessage = SourceMessage::findOne($id);

        if ($model->load(Yii::$app->request->post()) && $model->save())
        {
            Yii::$app->getSession()->setFlash('success', Yii::t('admin', 'Entry has been saved successfully'));
            return $this->redirect(Url::previous());
        }
        else
        {
            return $this->render('update', [
                'model' => $model,
                'sourceMessage' => $sourceMessage,
            ]);
        }
    }

    /**
     * Deletes an existing Message model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param integer $id
     * @param string $language
     * @return mixed
     */
    public function actionDelete($id, $language)
    {
        $this->findModel($id, $language)->delete();
        SourceMessage::findOne($id)->delete();

        return $this->redirect(Url::previous());
    }

    /**
     * Finds the Message model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param integer $id
     * @param string $language
     * @return Message the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id, $language)
    {
        if (($model = Message::findOne(['id' => $id, 'language' => $language])) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
}


text:
```
rvm install ruby-2.3.1
gem install bundler
bundle install
```

# Test commands
```
bundle exec rake app:db:test:prepare
bundle exec rspec
bundle exec rubocop
```


text:
/*
 * Este codigo pertenece a miguel.navarrovera@gmail.com
 * Su uso esta prohibido para uso comercial.
 * Si tienes interes en usarlo, ponte en contacto conmigo, Gracias. :D
 */
package org.mig.java.Entities;

import java.io.Serializable;
import java.util.Collection;

/**
 * @author miguelangel
 */
public class Tiendas implements Serializable {

    private String cif;
    private String nombre;
    private Usuarios usuarioMail;
    private String urlImagen;

    public Tiendas(String cif, String nombre, Usuarios usuarioMail, String urlImagen) {
        this.cif = cif;
        this.nombre = nombre;
        this.usuarioMail = usuarioMail;
        this.urlImagen = urlImagen;
    }

    public Tiendas() {
    }

    /**
     * @return the cif
     */
    public String getCif() {
        return cif;
    }

    /**
     * @param cif the cif to set
     */
    public void setCif(String cif) {
        this.cif = cif;
    }

    /**
     * @return the nombre
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * @param nombre the nombre to set
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    /**
     * @return the usuarioMail
     */
    public Usuarios getUsuarioMail() {
        return usuarioMail;
    }

    /**
     * @param usuarioMail the usuarioMail to set
     */
    public void setUsuarioMail(Usuarios usuarioMail) {
        this.usuarioMail = usuarioMail;
    }

    /**
     * @return the urlImagen
     */
    public String getUrlImagen() {
        return urlImagen;
    }

    /**
     * @param urlImagen the urlImagen to set
     */
    public void setUrlImagen(String urlImagen) {
        this.urlImagen = urlImagen;
    }

}


text:
package org.jacp.test.components;

import javafx.event.Event;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import org.jacp.test.main.ApplicationLauncherCallbackComponentMessaginTest1;
import org.jacp.test.perspectives.PerspectiveIds;
import org.jacpfx.api.annotations.Resource;
import org.jacpfx.api.annotations.component.Component;
import org.jacpfx.api.annotations.lifecycle.PostConstruct;
import org.jacpfx.api.annotations.lifecycle.PreDestroy;
import org.jacpfx.api.annotations.method.OnAsyncMessage;
import org.jacpfx.api.message.Message;
import org.jacpfx.rcp.component.CallbackComponent;
import org.jacpfx.rcp.componentLayout.FXComponentLayout;
import org.jacpfx.rcp.context.Context;
import org.jacpfx.rcp.util.FXUtil;

import java.util.ResourceBundle;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;

/**
 * A simple JacpFX FXML UI component
 *
 * @author  Andy Moncsek
 */

@Component(id = ComponentIds.CallbackComponentMessagingTest1Component2, active = true, resourceBundleLocation = "bundles.languageBundle", localeID = "en_US")
public class CallbackComponentMessagingTest1Component2 implements CallbackComponent {

    private final Logger log = Logger.getLogger(CallbackComponentMessagingTest1Component2.class
            .getName());

    String current = "content0";
    Button button = new Button("move to next target");
    VBox container = new VBox();
    Label label = new Label();
    public static boolean ui = false;

    @Resource
    private Context context;

    public static AtomicInteger counter = new AtomicInteger(10000);
    public static CountDownLatch wait = new CountDownLatch(1);

    public static String MESSAGE = "message";

    @Override
    /**
     * The handleAction method always runs outside the main application thread. You can create new nodes, execute long running tasks but you are not allowed to manipulate existing nodes here.
     */
    public Object handle(final Message<Event, Object> action) {
        return null;
    }

    @OnAsyncMessage(String.class)
    public Object onStringMessage(final Message<Event, Object> action) {
        if (action.messageBodyEquals(FXUtil.MessageUtil.INIT)) {
            ApplicationLauncherCallbackComponentMessaginTest1.latch.countDown();
        } else {
            if (counter.get() > 1) {
                counter.decrementAndGet();

            } else {
                System.out.println("Component id010: FINISH");
                if (wait.getCount() > 0) wait.countDown();

                return MESSAGE;
            }
        }
        context.setReturnTarget(PerspectiveIds.PerspectiveCallbackComponentMessagingTest1.concat(".").concat(ComponentIds.CallbackComponentMessagingTest1Component1));
        return MESSAGE;
    }

    @PostConstruct
    /**
     * The @OnStart annotation labels methods executed when the component switch from inactive to active state
     * @param arg0
     * @param resourceBundle
     */
    public void onStartComponent(final FXComponentLayout arg0,
                                 final ResourceBundle resourceBundle) {

    }

    @PreDestroy
    /**
     * The @OnTearDown annotations labels methods executed when the component is set to inactive
     * @param arg0
     */
    public void onTearDownComponent(final FXComponentLayout arg0) {
        this.log.info("run on tear down of ComponentRight ");

    }

}


text:
<BroadcastMonitor>
  <updated>2015-08-11T11:02:37</updated>
  <stationName>Radio 6</stationName>
  <Current>
    <startTime>2015-08-11T11:02:33</startTime>
    <itemId>1000080626:1244165</itemId>
    <titleId>216087315</titleId>
    <itemCode>04949</itemCode>
    <itemReference></itemReference>
    <titleName>The Glow Of Love</titleName>
    <artistName>Change & Luther Vandross</artistName>
    <albumName></albumName>
    <CategoryCode>736</CategoryCode>
    <CategoryName>SOUL</CategoryName>
    <itemDuration>217</itemDuration>
    <MultiMedia1></MultiMedia1>
    <MultiMedia2></MultiMedia2>
    <MultiMedia3></MultiMedia3>
    <MultiMedia4></MultiMedia4>
  </Current>
  <Next>
    <startTime>2015-08-11T11:06:11</startTime>
    <itemId>1000080626:1245809</itemId>
    <titleId>216090758</titleId>
    <itemCode></itemCode>
    <itemReference></itemReference>
    <titleName>*** JINGLE 07 SOULJAZZ SHOTGUN</titleName>
    <artistName></artistName>
    <albumName></albumName>
    <CategoryCode>965</CategoryCode>
    <CategoryName>ZWARTE LIJST</CategoryName>
    <itemDuration>7</itemDuration>
    <MultiMedia1></MultiMedia1>
    <MultiMedia2></MultiMedia2>
    <MultiMedia3></MultiMedia3>
    <MultiMedia4></MultiMedia4>
  </Next>
</BroadcastMonitor>


text:
package com.jukusoft.erp.lib.cache;

public enum CacheTypes {

    /**
    * cache entries on filesystem
    */
    FILE_CACHE,

    /**
    * cache values on local memory cache
    */
    LOCAL_MEMORY_CACHE,

    /**
    * cache values in distributed hazelcast cache
    */
    HAZELCAST_CACHE

}


text: google-site-verification: google70426bda46a8d3d6.html


text: echo 'Third level job 2-#2'; echo RES:done


text:
class QAction;
class QMenu;
class QMenuBar;
#if defined(Q_OS_MAC)
class TrayNotificationManager;
#endif

class SeafileTrayIcon : public QSystemTrayIcon {
    Q_OBJECT

public:
    explicit SeafileTrayIcon(QObject *parent=0);

    enum TrayState {
        STATE_DAEMON_UP = 0,
        STATE_DAEMON_DOWN,
        STATE_DAEMON_AUTOSYNC_DISABLED,
        STATE_TRANSFER_1,
        STATE_TRANSFER_2,
        STATE_SERVERS_NOT_CONNECTED,
        STATE_HAVE_UNREAD_MESSAGE,
    };

    void start();

    TrayState state() const { return state_; }
    void setState(TrayState state, const QString& tip=QString());
    void rotate(bool start);

    void reloadTrayIcon();

    void showMessage(const QString & title, const QString & message, MessageIcon icon = Information, int millisecondsTimeoutHint = 10000, bool is_repo_message = false);
    void showMessageWithRepo(const QString& repo_id, const QString & title, const QString & message, MessageIcon icon = Information, int millisecondsTimeoutHint = 10000);

public slots:
    void showSettingsWindow();

private slots:
    void disableAutoSync();
    void enableAutoSync();
    void quitSeafile();
    void onActivated(QSystemTrayIcon::ActivationReason);
    void prepareContextMenu();
    void showMainWindow();
    void rotateTrayIcon();
    void refreshTrayIcon();
    void refreshTrayIconToolTip();
    void openHelp();
    void openSeafileFolder();
    void openLogDirectory();
    void about();
    void onSeahubNotificationsChanged();
    void viewUnreadNotifications();

    // only used on windows
    void onMessageClicked();

private:
    Q_DISABLE_COPY(SeafileTrayIcon)

    void createActions();
    void createContextMenu();
    void createGlobalMenuBar();

    QIcon stateToIcon(TrayState state);
    QIcon getIcon(const QString& name);

    QMenu *context_menu_;
    QMenu *help_menu_;
    QMenu *global_menu_;
    QMenu *dock_menu_;
    QMenuBar *global_menubar_;

    // Actions for tray icon menu
    QAction *enable_auto_sync_action_;
    QAction *disable_auto_sync_action_;
    QAction *quit_action_;
    QAction *show_main_window_action_;
    QAction *settings_action_;
    QAction *open_seafile_folder_action_;
    QAction *open_log_directory_action_;
    QAction *view_unread_seahub_notifications_action_;

    QAction *about_action_;
    QAction *open_help_action_;

#if defined(Q_OS_MAC)
    TrayNotificationManager *tnm;
#endif

    QTimer *rotate_timer_;
    QTimer *refresh_timer_;
    int nth_trayicon_;
    int rotate_counter_;
    bool auto_sync_;

    TrayState state_;

    // only used on windows by now, so we have only one message
    QString repo_id_;

    QHash<QString, QIcon> icon_cache_;
};

#endif // SEAFILE_CLIENT_TRAY_ICON_H