text:
Roxxy-Unicorn&co est une structure de startup et de ce fait elle ne peut
posséder tout le capital compétence et outil d'une grande entreprise.
L'entreprise a donc décider d'agir en conséquence.

Roxxy-Unicorn&co priorise l'acquisition des ressources lui permettant de
garantir le bon déroulement de son activité. Les autres ressources seront donc
sujettes à de la sous-traitance jusqu'à obtention réelle ou virtuelle (projet)
d'un capital et d'une charge d'activitée nécéssaire et suffisante à son bon
développement.

### 7.1.2 Ressources humaines

La structure de Roxxy-Unicorn&co ne génère pas la charge suffisante permettant
de fournir un travail continu à un quelquonque service spécialisé dans la
gestion des Ressources Humaines.

De ce fait, et jusqu'à obtention d'une masse salariale critique, _l'ensemble
des services suivant est assuré par les membres de l'entreprise :_

- **Recrutement / entretient technique :** Assuré par les responsables / équipes
  responsable du recrutement.

- **Suivi et gestion des absences :** Assuré par les manageurs des différentes
  équipes jusqu'à obtention d'une masse salariale nécéssitant l'acquisition d'un
  service spécialisé dans les Ressources Humaines.

- **Gestion des salaires :** Assuré par le service de comptabilité / finances
  jusqu'à obtention d'une masse salariale nécéssitant l'acquisition d'un
  service spécialisé dans les Ressources Humaines.

- **Résolution des problématiques liées au travail :** Assuré par les manageurs
  des différentes équipes en collaboration avec les consultants juridiques
  jusqu'à obtention d'une masse salariale nécéssitant l'acquisition d'un
  service spécialisé dans les Ressources Humaines.

- **Syndicats et vie politique de l'entreprise :** Non assuré par l'entreprise
  jusqu'à ce que celle-ci atteigne la taille légale nécéssitant d'investir des
  ressources dans la gestion de cet aspect de la société.

_L'ensemble des services suivants sera sous-traité par l'entreprise :_

- **Recrutement / Entretient psychologique :** Cette partie du recrutement sera
  assuré par un / des consultants externes en fonction d'une présélection
  effectuée par les manageurs / équipes.

- **Recrutement / Recherche de candidats :** Cette partie devrait être gérée par
  les manageurs, en cas de besoin cependant, elle pourait être réalisée par un
  cabinet externe.

### 7.1.3 Infrastructure

- _L'entreprise offrira le matériel suivant :_

  La sociétée Roxxy-Unicorn&co mettra à disposition de ses salariés des locaux
comprenant : un espace de travail partagé (open-space) et au minimum une salle
de réunion pour les besoins de regroupement des équipes.

  La gestion des réservation de la / des salle(s) de réunion offerte(s) par
l'entreprise se fera à l'aide de calendrier présent devant les-dites salles
jusqu'à nécéssiter de déployer un outil informatique prévu à cet effet.

  La sociétée offrira de plus le nécéssaire de bureau (tables, chaises) à ses
employés. Dans la mesure du possible les ordinateurs devront être la propriété
des salariés. En cas de besoin la société pourra financer l'acquisition d'un
poste qui restera la propriété de Roxxy-Unicorn&co.

- _L'entreprise assurera les services logiciels suivant :_

  Une boite mail entreprise par employé gérée par un prestataire externe.
(Google, Microsoft ou solution open source).

  Une offre bureautique entreprise en ligne gérée par un prestataire externe.
(Google, Microsoft ou solution open source)

  Des serveurs de production comprenant un serveur gitlab (versionning et
intégration), docker (virtualisation des environnements) et une solution GED.
En fonction des prérequis de sécurité ses serveurs seront gérés en interne ou
externalisés.

  La société offrira aussi les outils nécéssaires au bon déroulement des
activités de design.

- _L'entreprise offrira les aides aux transports tels que définis par la loi_

### 7.1.4 Environnement pour la mise en oeuvre des processus

  Les locaux offerts par l'entreprise à ses employés est avant tout un espace de
travail collaboratif entretenu aux frais de l'entreprise. Par "espace de
travail" Roxxy-Unicorn&co entend que tout usage de l'espace visant à réaliser un
autre but que la réalisation des projets de l'entreprise est secondaire.

  D'une manière moins formelle : les employés ont le droit de boire, manger,
écouter de la musique dans les locaux dans la mesure où ils ne déteriorent pas
l'environnement de travail et ne gêne pas les autres employés dans leurs
travaux.

- _Locaux visant à entreposer les serveurs :_

  S'ils sont gérés en interne, les serveurs et hardware associés doivent être
entreposés dans une salle spécifique à accès limité suivant les standards de
sécurité, maintenance et consomation d'énergie de l'entreprise.

  Une salle serveur n'est pas un espace de travail collaboratif, les deux
doivent être dissociés.

### 7.1.5 Ressources pour la surveillance et la mesure

  La société mesure la qualité de ses projets sur les retours clients, chaque
projet fait l'objet, à sa fermeture d'un post-mortem afin de mesurer la marge
d'amélioration des équipe dans un contexte positif, et d'un rendez-vous avec le
client afin de mesurer sa satisfaction générale autour du projet.

  Tout au long du projet, l'entreprise favorise les remontés d'avis et de
ressentit de la part des membres des différentes équipes afin que les travaux
puissent profiter de l'expertise de tous les employés.

  Les manageurs ont un rôle d'écoute et de coaching, n'oubliez pas qu'être
inutilement directif n'est pas encouragé par la direction : ayez confiance en
vos équipes.

**TOUT DOIT FAIRE L'OBJET D'UN EMAIL DE VALIDATION OU D'UNE DOCUMENTATION,
TOUT FAIT IMPORTANT N'AYANT PAS DE DOCUMENTATION ECRITE ATTACHEE DE QUELQUE
NATURE QUE CE SOIT N'EXISTE PAS**

### 7.1.6 Connaissances organisationelles

  La gestion des connaissances internes et externes de l'entreprise est faite
par l'outil de GED. L'entreprise connait quelque chose du moment que cette
connaissance a fait l'objet d'une documentation.

  Une documentation est soit un document en GED ou un projet documentaire dans
le gestionnaire de version.

- Privilégier les documents GED pour les formats binaire, l'outil se chargera de
maintenir les différentes versions. La GED est la solution pour la plupart des
documents, surtout si ceux-ci ne font pas l'objet d'intence et constante
modifications.

- Le présent document rédigé au format markdown est un bon exemple de
projet-documentaire. Les projets documentaires doivent être rédigé dans un
format texte brut adapté au versionning et faire l'objet d'un taggage adéquat
afin de permettre aux lecteurs de naviguer entre les versions stables du
document.

  Etant donnés ses limitations, les projets-documentaires sont réservés aux
équipes techniques. Ils doivent traiter de documents utilisés par toute
l'entreprise et sujet à de nombreux changements.

  Un système d'intégration continue devrait pouvoir traduire les documents
markdown en format plus conventionnel disponible pour chaque tags.
  https://github.com/sindresorhus/gulp-markdown-pdf

  https://jekyllrb.com/ (format web statique)

  Concernant la documentation externe, et en particulier les pages webs :
prévoyez de garder une sauvegarde interne en GED ou au niveau de
l'infrastructure prévue à cet effet.

## 7.2 Compétences

  L'entreprise Roxxy-Unicorn&co s'assure que les compétences de ses employés
correspondent aux prérequis des projets et ce de diverses manières :

- Les compétences attendues de l'entreprise vis à vis de ses salariés sont
  validées au recrutement par un entretient technique et un test.

- Le travail collaboratif et la formation continue serviront à combler les
  manques et à faire évoluer les employés de l'entreprise.

- Finalement l'entreprise peut faire appel à des consultants externes pour les
  problématiques très pointues, notamment si celles-ci ne peuvent être traités par
  les équipes en interne.

L'entreprise gardera une trace pour chacun de ses recrutements comprenant :

- La fiche de recrutement avec les attentes initiales de l'entreprise vis à vis
  du collaborateur.

- Un tableau comprenant l'ensemble des formations auxquelles le collaborateur à
  assisté.

  Finalement Roxxy-Unicorn&co souhaite responsabiliser ses collaborateurs :
ceux-ci doivent de faire connaître à l'entreprise **par email** un éventuel
besoin de formation auquel celle-ci devra répondre pour la bonne conduite des
opérations futures.

## 7.3 Sensibilisation

  Chaque employé de l'entreprise Roxxy-Unicorn&co fait l'objet d'une introduction
aux attentes qualités de l'entreprise et au présent document. Le présent
document est disponible au format PDF et est transformé en site statique
accessible depuis l'intranet de l'entreprise.

  Chaque version stable du manuel qualité est accessible en tout temps, et chaque
projet ce doit de référencer la version du présent document auquel il se
réfère à un instant donné dans le Readme ou dans tout document de première
lecture disponible dans le projet.

  À la fin de chaque projet, le post-mortem est rédigé par l'équipe au complet
durant une réunion prévue à cet effet. La rédaction du post-mortem est un
moment privilégié pour discuter des attentes qualités de la société, et pour
sensibiliser les collaborateurs à son existence.

## 7.4 Communication

  Toute communication externe de l'entreprise Roxxy-Unicorn&co doit faire l'objet
d'un écrit de confirmation archivé dans la GED du projet. **TOUTES
COMMUNICATIONS EXTERNES QUI NE FAIT PAS L'OBJET D'UN ACQUITEMENT ECRIT ET D'UNE
VALIDATION DU CLIENT N'A JAMAIS EXISTEE**

  Les communications importantes (notamment les prises de décision) font l'objet
de la même politique de sécurité. Chaque acquitement doit permettre de mettre en
évidence :

- L'individu émetteur de la demande de confirmation.
- La date d'émission.
- Le sujet faisant l'objet de la demande confirmation.
- L'individu émetteur de la validation.
- La date de validation.
- Le message de validation.

  Les réunions importantes doivent faire l'objet d'un compte rendu diffusé à
l'ensemble des collaborateurs intéréssés. Les comptes-rendus doivent être
archivés dans la GED des projets.

  En bref les collaborateurs sont libres de communiquer à propos de tous les types
de sujet dans le respect du travail et d'autrui. Il est à noter que l'entreprise
ne perdra pas de temps à contrôler tous les documents rédigés par les
collaborateurs et que ceux-ci sont à la seule responsabilité de leur rédacteur.

Finalement **TOUT ÉCHANGE IMPORTANT DOIT FAIRE L'OBJET D'UNE TRACE ÉCRITE,
ARCHIVÉE EN GED. TOUT ÉCHANGE NE FAISANT PAS L'OBJET D'UNE TRACE ÉCRITE N'A
JAMAIS EXISTÉ, TOUT COMME LES ÉCHANGES AYANT UNE TRACE ÉCRITE NON ARCHIVÉE EN
GED.**

## 7.5 Informations documentées

### 7.5.1 Généralités

Chaque projet fait l'objet de deux formes de documentation :

- La documentation en GED qui comprend :

  - L'ensemble des décisions prises concernant le projet
  - L'ensemble des comptes-rendus de réunions autour du projet
  - L'ensemble de la documentation liée au design
  - Les flux de courriel (les plus importants).

- La documentation technique versionnée avec le projet rédigée dans un format
adapté à l'outil (Markdown, texte brut, html...)

  Toutes les connaissances de l'entreprises hors projets sont archivées en GED
et font l'objet d'une documentation adaptée.

  Tous les documents de suivis liés au personnel ou à l'entreprise font aussi
l'objet d'une documentation disponible dans la GED.

  Le présent document est disponible à la fois, au format PDF, et site statique pour
chacune de ses versions stables (taggées en conséquence). Autrement, il est
possible de retrouver le présent document dans le dépôt git associé dans son
format brut : markdown.

### 7.5.2 Création et mise à jour des informations documentées

La documentation, en fonction de sa nature est sujette à différents types de
traitement :

- **Documentation en GED :**

  Pour la documentation en GED, merci de suivre les préconisations de l'outil et
de permettre d'identifier de manière rapide et facile :

  - Le / les rédacteur(s) du document
  - La date de création
  - La dernière date de modification
  - La version
  - Le sujet

  Certains des éléments ci-dessus seront directement gérés par l'outil. Veillez
à placer les documents dans les dossiers appropriés afin que la GED puisse
correctement attribuer les droits.

- **Documentation du code :**

  La documentation du code doit se faire autant que possible directement dans
les fichiers sources via des commentaires type javadoc, jsdoc, etc... La
documentation du code doit pouvoir être générée via un outil en tout temps.

- **Documentation technique :**

  Toute documentation technique complémentaire (type manuel d'utilisation) doit
être versionnée avec le projet dans un dossier prévu à cet effet. Veillez à
utiliser un format adapté à l'outil de versionnement (markdown, html, texte
brut, etc...)

  La documentation technique devrait pouvoir être traduite en manuel PDF ou en
site statique via un outil en tout temps.

  Tous les projets de développement doivent comporter une documentation du code
à jour suivant les normes exposées dans le livre : https://www.amazon.fr/Coder-proprement-Robert-C-Martin/dp/2744023272

  De plus les projets de développement doivent comporter une documentation
technique (type manuel d'utilisation) à jour traitant au minimum de
l'installation, mise à jour et maintenance du produit.

  Il doit être possible de comprendre comment génerer les-dites documentations en
lisant le document de première lecture de chaque projet (type readme).

  La GED doit comporter un dossier documentaire autour de chaque projet mis à jour
en continu au regard des avancés autour de celui-ci.

### 7.5.3 Maîtrise des informations documentées

  La documentation disponible dans les dépôts de projet (code et documentation
technique complémentaire) **ne doit contenir que des informations d'ordre
publiques et non restreintes**. L'audience visée est celle de l'ingénieur
industriel lambda.

**Toutes les informations sujettes à une restriction d'accès de quelque forme que
ce soit doit être renseignée dans la GED.** L'outil offrira aux utilisateurs un
service de contrôle d'accès permettant de restreindre la diffusion des documents
en interne tout en maintenant le versionning.

  Dans l'idéal, aucune copie de document de la GED vers les postes locaux ne sera
autorisée (dans la mesure du possible) afin d'appliquer au mieux les
restrictions de confidentialitée.

  L'entreprise tient tout de même à faire savoir que tout utilisateur abusant de
la restriction d'accès seront sujet à des sanctions. Notamment pour la
restriction d'accès non-pertinente et injustifiable.

**Concernant les projets dont le code source fait l'objet d'une restriction
d'accès très stricte et justifiée, l'accès aux-dits dépôt sera contrôlé via
GitLab pour n'autoriser l'accès qu'aux collaborateurs liés au projet.** Cette
politique ne doit cependant pas devenir LA NORME.

  Pour plus d'informations concernant la politique de confidentialité de
l'entreprise, se référer aux règles internes,aux clauses du contrat de tavail
que vous avez signé et aux fichiers de première lecture de chaque projet.


text:
import React from 'react';
import PropTypes from 'prop-types';
import _groupBy from 'lodash/groupBy';
import _get from 'lodash/get';
import _has from 'lodash/has';
import _union from 'lodash/union';
import _filter from 'lodash/filter';
import nanoid from 'nanoid';
import _cloneDeep from 'lodash/cloneDeep';

class GroupedTableBody extends React.Component {
  constructor(props) {
    super(props);
  }

  renderGroupedColumns(groupedCols, row) {
    let tds = [];
    let parent = row.parent;
    while (parent !== null) {
      if (!parent.done) {
        let col = groupedCols[parent.name][0];
        let style = _has(col, 'width') ? { width: `${col.width}px` } : {};
        let rendered = col.formatter ? col.formatter({ [parent.name]: parent.value }, col.key) : parent.value;
        tds.push(

            {rendered}

        );
        parent.done = true;
      }
      parent = _has(parent, 'parent') ? parent.parent : null;
    }
    return tds.reverse();
  }

  renderNonGroupedColumns(nonGroupedColumns, row) {
    return nonGroupedColumns.map(col => {
      let style = _has(col, 'width') ? { width: `${col.width}px` } : {};
      let rendered = col.formatter ? col.formatter(row, col.key) : _get(row, col.key);
      return (

          {rendered}

      );
    });
  }

  renderRow(nonGroupedColumns, groupedCols, row) {
    if (_has(row, 'nested')) {
      return row.nested.map(nestedRow => {
        return this.renderRow(nonGroupedColumns, groupedCols, nestedRow);
      });
    } else {
      let groupedTds = this.renderGroupedColumns(groupedCols, row);
      let nonGroupedTds = this.renderNonGroupedColumns(nonGroupedColumns, row);
      let tds = _union(groupedTds, nonGroupedTds);

      return
{tds}
;
    }
  }

  render() {
    let nonGroupedColumns = _filter(this.props.columns, { groupBy: false });
    let groupedCols = _filter(this.props.columns, { groupBy: true });

    let data = _cloneDeep(this.props.data);

    let trs = data.nested.map(nestedRow => {
      return this.renderRow(nonGroupedColumns, _groupBy(groupedCols, 'key'), nestedRow);
    });

    return
{trs}
;
  }
}

GroupedTableBody.displayName = 'GroupedTableBody';

GroupedTableBody.propTypes = {
  columns: PropTypes.array.isRequired,
  data: PropTypes.object.isRequired,
};

export default GroupedTableBody;

redpajama_set_name: RedPajamaGithub


text:
//$Id: JoinFetchTest.java 9914 2006-05-09 09:37:18Z max.andersen@jboss.com $
package org.hibernate.test.joinfetch;

import java.util.List;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.hibernate.FetchMode;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.test.TestCase;

/**
 * @author Gavin King
 */
public class JoinFetchTest extends TestCase {

	public JoinFetchTest(String str) {
		super(str);
	}

	public void testProjection() {
		Session s = openSession();
		Transaction t = s.beginTransaction();
		s.createCriteria(Item.class).setProjection( Projections.rowCount() ).uniqueResult();
		s.createCriteria(Item.class).uniqueResult();
		t.commit();
		s.close();
	}

	public void testJoinFetch() {
		Session s = openSession();
		Transaction t = s.beginTransaction();
		s.createQuery( "delete from Bid" ).executeUpdate();
		s.createQuery( "delete from Comment" ).executeUpdate();
		s.createQuery( "delete from Item" ).executeUpdate();
		t.commit();
		s.close();

		Category cat = new Category("Photography");
		Item i = new Item(cat, "Camera");
		Bid b = new Bid(i, 100.0f);
		new Bid(i, 105.0f);
		new Comment(i, "This looks like a really good deal");
		new Comment(i, "Is it the latest version?");
		new Comment(i, "<comment deleted>");
		System.out.println( b.getTimestamp() );

		s = openSession();
		t = s.beginTransaction();
		s.persist(cat);
		s.persist(i);
		t.commit();
		s.close();

		getSessions().evict(Item.class);

		s = openSession();
		t = s.beginTransaction();
		i = (Item) s.get( Item.class, i.getId() );
		assertTrue( Hibernate.isInitialized( i.getBids() ) );
		assertEquals( i.getBids().size(), 2 );
		assertTrue( Hibernate.isInitialized( i.getComments() ) );
		assertEquals( i.getComments().size(), 3 );
		t.commit();
		s.close();

		getSessions().evict(Bid.class);

		s = openSession();
		t = s.beginTransaction();
		b = (Bid) s.get( Bid.class, b.getId() );
		assertTrue( Hibernate.isInitialized( b.getItem() ) );
		assertTrue( Hibernate.isInitialized( b.getItem().getComments() ) );
		assertEquals( b.getItem().getComments().size(), 3 );
		System.out.println( b.getTimestamp() );
		t.commit();
		s.close();

		getSessions().evictCollection(Item.class.getName() + ".bids");

		s = openSession();
		t = s.beginTransaction();
		i = (Item) s.createCriteria( Item.class )
			.setFetchMode("bids", FetchMode.SELECT)
			.setFetchMode("comments", FetchMode.SELECT)
			.uniqueResult();
		assertFalse( Hibernate.isInitialized( i.getBids() ) );
		assertFalse( Hibernate.isInitialized( i.getComments() ) );
		b = (Bid) i.getBids().iterator().next();
		assertTrue( Hibernate.isInitialized( b.getItem() ) );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		i = (Item) s.createQuery("from Item i left join fetch i.bids left join fetch i.comments").uniqueResult();
		assertTrue( Hibernate.isInitialized( i.getBids() ) );
		assertTrue( Hibernate.isInitialized( i.getComments() ) );
		assertEquals( i.getComments().size(), 3 );
		assertEquals( i.getBids().size(), 2 );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		Object[] row = (Object[]) s.getNamedQuery(Item.class.getName() + ".all").list().get(0);
		i = (Item) row[0];
		assertTrue( Hibernate.isInitialized( i.getBids() ) );
		assertTrue( Hibernate.isInitialized( i.getComments() ) );
		assertEquals( i.getComments().size(), 3 );
		assertEquals( i.getBids().size(), 2 );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		i = (Item) s.createCriteria(Item.class).uniqueResult();
		assertTrue( Hibernate.isInitialized( i.getBids() ) );
		assertTrue( Hibernate.isInitialized( i.getComments() ) );
		assertEquals( i.getComments().size(), 3 );
		assertEquals( i.getBids().size(), 2 );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		List bids = s.createQuery("from Bid b left join fetch b.item i left join fetch i.category").list();
		Bid bid = (Bid) bids.get(0);
		assertTrue( Hibernate.isInitialized( bid.getItem() ) );
		assertTrue( Hibernate.isInitialized( bid.getItem().getCategory() ) );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		List pairs = s.createQuery("from Item i left join i.bids b left join fetch i.category").list();
		Item item = (Item) ( (Object[]) pairs.get(0) )[0];
		assertFalse( Hibernate.isInitialized( item.getBids() ) );
		assertTrue( Hibernate.isInitialized( item.getCategory() ) );
		s.clear();
		pairs = s.createQuery("from Item i left join i.bids b left join i.category").list();
		item = (Item) ( (Object[]) pairs.get(0) )[0];
		assertFalse( Hibernate.isInitialized( item.getBids() ) );
		assertTrue( Hibernate.isInitialized( item.getCategory() ) );
		s.clear();
		pairs = s.createQuery("from Bid b left join b.item i left join fetch i.category").list();
		bid = (Bid) ( (Object[]) pairs.get(0) )[0];
		assertTrue( Hibernate.isInitialized( bid.getItem() ) );
		assertTrue( Hibernate.isInitialized( bid.getItem().getCategory() ) );
		s.clear();
		pairs = s.createQuery("from Bid b left join b.item i left join i.category").list();
		bid = (Bid) ( (Object[]) pairs.get(0) )[0];
		assertTrue( Hibernate.isInitialized( bid.getItem() ) );
		assertTrue( Hibernate.isInitialized( bid.getItem().getCategory() ) );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		s.createQuery( "delete from Bid" ).executeUpdate();
		s.createQuery( "delete from Comment" ).executeUpdate();
		s.createQuery( "delete from Item" ).executeUpdate();
		s.createQuery( "delete from Category" ).executeUpdate();
		t.commit();
		s.close();

	}

	public void testCollectionFilter() {
		Session s = openSession();
		Transaction t = s.beginTransaction();
		Group hb = new Group("hibernate");
		User gavin = new User("gavin");
		User max = new User("max");
		hb.getUsers().put("gavin", gavin);
		hb.getUsers().put("max", max);
		gavin.getGroups().put("hibernate", hb);
		max.getGroups().put("hibernate", hb);
		s.persist(hb);
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		hb = (Group) s.createCriteria(Group.class)
				.setFetchMode("users", FetchMode.SELECT)
				.add( Restrictions.idEq("hibernate") )
				.uniqueResult();
		assertFalse( Hibernate.isInitialized( hb.getUsers() ) );
		//gavin = (User) s.createFilter( hb.getUsers(), "where index(this) = 'gavin'" ).uniqueResult();
		Long size = (Long) s.createFilter( hb.getUsers(), "select count(*)" ).uniqueResult();
		assertEquals( new Long(2), size );
		assertFalse( Hibernate.isInitialized( hb.getUsers() ) );
		s.delete(hb);
		t.commit();
		s.close();

	}

	public void testJoinFetchManyToMany() {
		Session s = openSession();
		Transaction t = s.beginTransaction();
		Group hb = new Group("hibernate");
		User gavin = new User("gavin");
		User max = new User("max");
		hb.getUsers().put("gavin", gavin);
		hb.getUsers().put("max", max);
		gavin.getGroups().put("hibernate", hb);
		max.getGroups().put("hibernate", hb);
		s.persist(hb);
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		hb = (Group) s.get(Group.class, "hibernate");
		assertTrue( Hibernate.isInitialized( hb.getUsers() ) );
		gavin = (User) hb.getUsers().get("gavin");
		assertFalse( Hibernate.isInitialized( gavin.getGroups() ) );
		max = (User) s.get(User.class, "max");
		assertFalse( Hibernate.isInitialized( max.getGroups() ) );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		hb = (Group) s.createCriteria(Group.class)
			.setFetchMode("users", FetchMode.JOIN)
			.setFetchMode("users.groups", FetchMode.JOIN)
			.uniqueResult();
		assertTrue( Hibernate.isInitialized( hb.getUsers() ) );
		gavin = (User) hb.getUsers().get("gavin");
		assertTrue( Hibernate.isInitialized( gavin.getGroups() ) );
		max = (User) s.get(User.class, "max");
		assertTrue( Hibernate.isInitialized( max.getGroups() ) );
		t.commit();
		s.close();

		s = openSession();
		t = s.beginTransaction();
		s.delete(hb);
		t.commit();
		s.close();
	}

	protected String[] getMappings() {
		return new String[] { "joinfetch/ItemBid.hbm.xml", "joinfetch/UserGroup.hbm.xml" };
	}

	protected void configure(Configuration cfg) {
		cfg.setProperty(Environment.MAX_FETCH_DEPTH, "10");
		cfg.setProperty(Environment.USE_SECOND_LEVEL_CACHE, "false");
	}

	public static Test suite() {
		return new TestSuite(JoinFetchTest.class);
	}

}


text:
LOG4J2_VERSION=2.4.1
MVN_REPO=`mvn help:evaluate -Dexpression=settings.localRepository | grep -v '\[INFO\]' | tail -n 1`
LOG4J_API_PATH=${MVN_REPO}/org/apache/logging/log4j/log4j-api/${LOG4J2_VERSION}/log4j-api-${LOG4J2_VERSION}.jar
LOG4J_CORE_PATH=${MVN_REPO}/org/apache/logging/log4j/log4j-core/${LOG4J2_VERSION}/log4j-core-${LOG4J2_VERSION}.jar
LOG4J_GUI_PATH=${MVN_REPO}/org/apache/logging/log4j/log4j-jmx-gui/${LOG4J2_VERSION}/log4j-jmx-gui-${LOG4J2_VERSION}.jar
APACHE_REPO='https://repository.apache.org/content/groups/public'

if [ ! -e ${LOG4J_API_PATH} ]; then
	echo "Downloading missing jars for Log4j api version ${LOG4J2_VERSION} to ${LOG4J_API_PATH}"
	mvn dependency:get -DrepoUrl=${APACHE_REPO} -Dartifact=org.apache.logging.log4j:log4j-api:${LOG4J2_VERSION} > /dev/null 2>&1 &
fi
if [ ! -e ${LOG4J_CORE_PATH} ]; then
	echo "Downloading missing jars for Log4j core version ${LOG4J2_VERSION} to ${LOG4J_CORE_PATH}"
	mvn dependency:get -DrepoUrl=${APACHE_REPO} -Dartifact=org.apache.logging.log4j:log4j-core:${LOG4J2_VERSION} > /dev/null 2>&1 &
fi
if [ ! -e ${LOG4J_GUI_PATH} ]; then
	echo "Downloading missing jars for Log4j gui version ${LOG4J2_VERSION} to ${LOG4J_GUI_PATH}"
	mvn dependency:get -DrepoUrl=${APACHE_REPO} -Dartifact=org.apache.logging.log4j:log4j-jmx-gui:${LOG4J2_VERSION} > /dev/null 2>&1 &
fi
wait

jconsole -pluginpath ${LOG4J_API_PATH}:${LOG4J_CORE_PATH}:${LOG4J_GUI_PATH} $@


text:
package org.elasticsearch.common.joda;

import org.elasticsearch.common.Strings;
import org.joda.time.*;
import org.joda.time.field.DividedDateTimeField;
import org.joda.time.field.OffsetDateTimeField;
import org.joda.time.field.ScaledDurationField;
import org.joda.time.format.*;

import java.util.Locale;
import java.util.regex.Pattern;

/**
 *
 */
public class Joda {

    public static FormatDateTimeFormatter forPattern(String input) {
        return forPattern(input, Locale.ROOT);
    }

    /**
     * Parses a joda based pattern, including some named ones (similar to the built in Joda ISO ones).
     */
    public static FormatDateTimeFormatter forPattern(String input, Locale locale) {
        if (Strings.hasLength(input)) {
            input = input.trim();
        }
        if (input == null || input.length() == 0) {
            throw new IllegalArgumentException("No date pattern provided");
        }

        DateTimeFormatter formatter;
        if ("basicDate".equals(input) || "basic_date".equals(input)) {
            formatter = ISODateTimeFormat.basicDate();
        } else if ("basicDateTime".equals(input) || "basic_date_time".equals(input)) {
            formatter = ISODateTimeFormat.basicDateTime();
        } else if ("basicDateTimeNoMillis".equals(input) || "basic_date_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.basicDateTimeNoMillis();
        } else if ("basicOrdinalDate".equals(input) || "basic_ordinal_date".equals(input)) {
            formatter = ISODateTimeFormat.basicOrdinalDate();
        } else if ("basicOrdinalDateTime".equals(input) || "basic_ordinal_date_time".equals(input)) {
            formatter = ISODateTimeFormat.basicOrdinalDateTime();
        } else if ("basicOrdinalDateTimeNoMillis".equals(input) || "basic_ordinal_date_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.basicOrdinalDateTimeNoMillis();
        } else if ("basicTime".equals(input) || "basic_time".equals(input)) {
            formatter = ISODateTimeFormat.basicTime();
        } else if ("basicTimeNoMillis".equals(input) || "basic_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.basicTimeNoMillis();
        } else if ("basicTTime".equals(input) || "basic_t_Time".equals(input)) {
            formatter = ISODateTimeFormat.basicTTime();
        } else if ("basicTTimeNoMillis".equals(input) || "basic_t_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.basicTTimeNoMillis();
        } else if ("basicWeekDate".equals(input) || "basic_week_date".equals(input)) {
            formatter = ISODateTimeFormat.basicWeekDate();
        } else if ("basicWeekDateTime".equals(input) || "basic_week_date_time".equals(input)) {
            formatter = ISODateTimeFormat.basicWeekDateTime();
        } else if ("basicWeekDateTimeNoMillis".equals(input) || "basic_week_date_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.basicWeekDateTimeNoMillis();
        } else if ("date".equals(input)) {
            formatter = ISODateTimeFormat.date();
        } else if ("dateHour".equals(input) || "date_hour".equals(input)) {
            formatter = ISODateTimeFormat.dateHour();
        } else if ("dateHourMinute".equals(input) || "date_hour_minute".equals(input)) {
            formatter = ISODateTimeFormat.dateHourMinute();
        } else if ("dateHourMinuteSecond".equals(input) || "date_hour_minute_second".equals(input)) {
            formatter = ISODateTimeFormat.dateHourMinuteSecond();
        } else if ("dateHourMinuteSecondFraction".equals(input) || "date_hour_minute_second_fraction".equals(input)) {
            formatter = ISODateTimeFormat.dateHourMinuteSecondFraction();
        } else if ("dateHourMinuteSecondMillis".equals(input) || "date_hour_minute_second_millis".equals(input)) {
            formatter = ISODateTimeFormat.dateHourMinuteSecondMillis();
        } else if ("dateOptionalTime".equals(input) || "date_optional_time".equals(input)) {
            // in this case, we have a separate parser and printer since the dataOptionalTimeParser can't print
            // this sucks we should use the root local by default and not be dependent on the node
            return new FormatDateTimeFormatter(input,
                    ISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC),
                    ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC), locale);
        } else if ("dateTime".equals(input) || "date_time".equals(input)) {
            formatter = ISODateTimeFormat.dateTime();
        } else if ("dateTimeNoMillis".equals(input) || "date_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.dateTimeNoMillis();
        } else if ("hour".equals(input)) {
            formatter = ISODateTimeFormat.hour();
        } else if ("hourMinute".equals(input) || "hour_minute".equals(input)) {
            formatter = ISODateTimeFormat.hourMinute();
        } else if ("hourMinuteSecond".equals(input) || "hour_minute_second".equals(input)) {
            formatter = ISODateTimeFormat.hourMinuteSecond();
        } else if ("hourMinuteSecondFraction".equals(input) || "hour_minute_second_fraction".equals(input)) {
            formatter = ISODateTimeFormat.hourMinuteSecondFraction();
        } else if ("hourMinuteSecondMillis".equals(input) || "hour_minute_second_millis".equals(input)) {
            formatter = ISODateTimeFormat.hourMinuteSecondMillis();
        } else if ("ordinalDate".equals(input) || "ordinal_date".equals(input)) {
            formatter = ISODateTimeFormat.ordinalDate();
        } else if ("ordinalDateTime".equals(input) || "ordinal_date_time".equals(input)) {
            formatter = ISODateTimeFormat.ordinalDateTime();
        } else if ("ordinalDateTimeNoMillis".equals(input) || "ordinal_date_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.ordinalDateTimeNoMillis();
        } else if ("time".equals(input)) {
            formatter = ISODateTimeFormat.time();
        } else if ("tTime".equals(input) || "t_time".equals(input)) {
            formatter = ISODateTimeFormat.tTime();
        } else if ("tTimeNoMillis".equals(input) || "t_time_no_millis".equals(input)) {
            formatter = ISODateTimeFormat.tTimeNoMillis();
        } else if ("weekDate".equals(input) || "week_date".equals(input)) {
            formatter = ISODateTimeFormat.weekDate();
        } else if ("weekDateTime".equals(input) || "week_date_time".equals(input)) {
            formatter = ISODateTimeFormat.weekDateTime();
        } else if ("weekyear".equals(input) || "week_year".equals(input)) {
            formatter = ISODateTimeFormat.weekyear();
        } else if ("weekyearWeek".equals(input)) {
            formatter = ISODateTimeFormat.weekyearWeek();
        } else if ("year".equals(input)) {
            formatter = ISODateTimeFormat.year();
        } else if ("yearMonth".equals(input) || "year_month".equals(input)) {
            formatter = ISODateTimeFormat.yearMonth();
        } else if ("yearMonthDay".equals(input) || "year_month_day".equals(input)) {
            formatter = ISODateTimeFormat.yearMonthDay();
        } else if ("epoch_second".equals(input)) {
            formatter = new DateTimeFormatterBuilder().append(new EpochTimeParser(false)).toFormatter();
        } else if ("epoch_millis".equals(input)) {
            formatter = new DateTimeFormatterBuilder().append(new EpochTimeParser(true)).toFormatter();
        } else if (Strings.hasLength(input) && input.contains("||")) {
                String[] formats = Strings.delimitedListToStringArray(input, "||");
                DateTimeParser[] parsers = new DateTimeParser[formats.length];

                if (formats.length == 1) {
                    formatter = forPattern(input, locale).parser();
                } else {
                    DateTimeFormatter dateTimeFormatter = null;
                    for (int i = 0; i < formats.length; i++) {
                        FormatDateTimeFormatter currentFormatter = forPattern(formats[i], locale);
                        DateTimeFormatter currentParser = currentFormatter.parser();
                        if (dateTimeFormatter == null) {
                            dateTimeFormatter = currentFormatter.printer();
                        }
                        parsers[i] = currentParser.getParser();
                    }

                    DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder().append(dateTimeFormatter.withZone(DateTimeZone.UTC).getPrinter(), parsers);
                    formatter = builder.toFormatter();
                }
        } else {
            try {
                formatter = DateTimeFormat.forPattern(input);
            } catch (IllegalArgumentException e) {
                throw new IllegalArgumentException("Invalid format: [" + input + "]: " + e.getMessage(), e);
            }
        }

        return new FormatDateTimeFormatter(input, formatter.withZone(DateTimeZone.UTC), locale);
    }

    public static final DurationFieldType Quarters = new DurationFieldType("quarters") {
        private static final long serialVersionUID = -8167713675442491871L;

        @Override
        public DurationField getField(Chronology chronology) {
            return new ScaledDurationField(chronology.months(), Quarters, 3);
        }
    };

    public static final DateTimeFieldType QuarterOfYear = new DateTimeFieldType("quarterOfYear") {
        private static final long serialVersionUID = -5677872459807379123L;

        @Override
        public DurationFieldType getDurationType() {
            return Quarters;
        }

        @Override
        public DurationFieldType getRangeDurationType() {
            return DurationFieldType.years();
        }

        @Override
        public DateTimeField getField(Chronology chronology) {
            return new OffsetDateTimeField(new DividedDateTimeField(new OffsetDateTimeField(chronology.monthOfYear(), -1), QuarterOfYear, 3), 1);
        }
    };

    public static class EpochTimeParser implements DateTimeParser {

        private static final Pattern MILLI_SECOND_PRECISION_PATTERN = Pattern.compile("^\\d{1,13}$");
        private static final Pattern SECOND_PRECISION_PATTERN = Pattern.compile("^\\d{1,10}$");

        private final boolean hasMilliSecondPrecision;
        private final Pattern pattern;

        public EpochTimeParser(boolean hasMilliSecondPrecision) {
            this.hasMilliSecondPrecision = hasMilliSecondPrecision;
            this.pattern = hasMilliSecondPrecision ? MILLI_SECOND_PRECISION_PATTERN : SECOND_PRECISION_PATTERN;
        }

        @Override
        public int estimateParsedLength() {
            return hasMilliSecondPrecision ? 13 : 10;
        }

        @Override
        public int parseInto(DateTimeParserBucket bucket, String text, int position) {
            if (text.length() > estimateParsedLength() ||
                // timestamps have to have UTC timezone
                bucket.getZone() != DateTimeZone.UTC ||
                pattern.matcher(text).matches() == false) {
                return -1;
            }

            int factor = hasMilliSecondPrecision ? 1 : 1000;
            try {
                long millis = Long.valueOf(text) * factor;
                DateTime dt = new DateTime(millis, DateTimeZone.UTC);
                bucket.saveField(DateTimeFieldType.year(), dt.getYear());
                bucket.saveField(DateTimeFieldType.monthOfYear(), dt.getMonthOfYear());
                bucket.saveField(DateTimeFieldType.dayOfMonth(), dt.getDayOfMonth());
                bucket.saveField(DateTimeFieldType.hourOfDay(), dt.getHourOfDay());
                bucket.saveField(DateTimeFieldType.minuteOfHour(), dt.getMinuteOfHour());
                bucket.saveField(DateTimeFieldType.secondOfMinute(), dt.getSecondOfMinute());
                bucket.saveField(DateTimeFieldType.millisOfSecond(), dt.getMillisOfSecond());
                bucket.setZone(DateTimeZone.UTC);
            } catch (Exception e) {
                return -1;
            }
            return text.length();
        }
    };
}


text:
import {
  createFixtureIframe,
  expectBodyToBecomeVisible,
} from '../../testing/iframe';
import {getStyle} from '../../src/style';
import {isAnimationNone} from '../../testing/test-helper';

const timeout = window.ampTestRuntimeConfig.mochaTimeout;

describe.configure().retryOnSaucelabs().run('Old Opacity Boilerplate', () => {
  let fixture;
  beforeEach(() => {
    return createFixtureIframe(
        'test/fixtures/boilerplate-old-opacity.html', 1000).then(f => {
      fixture = f;
    });
  });

  it('should show the body when opacity boilerplate is used', () => {
    return expectBodyToBecomeVisible(fixture.win, timeout).then(() => {
      expect(getStyle(fixture.win.document.body, 'opacity')).to.equal('1');
    });
  });
});

describe.configure().run('New Visibility Boilerplate', () => {

  let fixture;
  beforeEach(() => {
    return createFixtureIframe(
        'test/fixtures/boilerplate-new-visibility.html', 10000).then(f => {
      fixture = f;
    });
  });

  it('should show the body in boilerplate test', () => {
    return expectBodyToBecomeVisible(fixture.win, timeout).then(() => {
      expect(getStyle(
          fixture.win.document.body, 'visibility')).to.equal('visible');
      expect(isAnimationNone(fixture.win.document.body)).to.be.true;
    });
  });
});


text:
function isa = sensorDeleteFilter(isa,whichFilter)
% Delete a color filter.
%
%   isa = sensorDeleteFilter(isa,[whichFilter])
%
%  The filterspectra, filternames and pattern
%  fields are adjusted in the isa structure.  If whichFilter is omitted,
%  the user is queried for a filter name.  The name can be seen on the
%  sensorDesignCFA plot window.
%
% Examples:
%    [val,isa] = vcGetSelectedObject('ISA');
%    isa = sensorDeleteFilter(isa,4);
%
% Copyright ImagEval Consultants, LLC, 2005.

if ieNotDefined('isa'), [val,isa] = vcGetSelectedObject('ISA'); end

if ieNotDefined('whichFilter')
    filterNames = sensorGet(isa,'filterNames');
    deleteName = ieReadString('Enter filter name to replace:',filterNames{1});
    if isempty(deleteName), return; end;
    whichFilter = strmatch(deleteName,filterNames);
    if isempty(whichFilter), return; end;
end

filterSpectra = sensorGet(isa,'filterspectra');
nFilters = sensorGet(isa,'nfilters');

keepList = ones(1,nFilters);
keepList(whichFilter) = 0;
keepList = logical(keepList);
isa = sensorSet(isa,'filterspectra',filterSpectra(:,keepList));

% The pattern terms bigger than or equal to whichFilter all move down one.
% The ones lower than whichFilter stay the same.
pattern = sensorGet(isa,'pattern');
l = find(pattern >= whichFilter);
pattern(l) = max(1,pattern(l)-1);
isa = sensorSet(isa,'pattern',pattern);

filterNames = sensorGet(isa,'filternames');
filterNames = filterNames(keepList);
isa = sensorSet(isa,'filternames',filterNames);

return;


text:
require 'abstract_unit'
require 'fileutils'
require 'action_view/dependency_tracker'

class FixtureTemplate
  attr_reader :source, :handler

  def initialize(template_path)
    @source = File.read(template_path)
    @handler = ActionView::Template.handler_for_extension(:erb)
  rescue Errno::ENOENT
    raise ActionView::MissingTemplate.new([], "", [], true, [])
  end
end

class FixtureFinder < ActionView::LookupContext
  FIXTURES_DIR = "#{File.dirname(__FILE__)}/../fixtures/digestor"

  def initialize(details = {})
    super(ActionView::PathSet.new(['digestor']), details, [])
  end
end

class TemplateDigestorTest < ActionView::TestCase
  def setup
    @cwd     = Dir.pwd
    @tmp_dir = Dir.mktmpdir

    ActionView::LookupContext::DetailsKey.clear
    FileUtils.cp_r FixtureFinder::FIXTURES_DIR, @tmp_dir
    Dir.chdir @tmp_dir
  end

  def teardown
    Dir.chdir @cwd
    FileUtils.rm_r @tmp_dir
  end

  def test_top_level_change_reflected
    assert_digest_difference("messages/show") do
      change_template("messages/show")
    end
  end

  def test_explicit_dependency
    assert_digest_difference("messages/show") do
      change_template("messages/_message")
    end
  end

  def test_explicit_dependency_in_multiline_erb_tag
    assert_digest_difference("messages/show") do
      change_template("messages/_form")
    end
  end

  def test_explicit_dependency_wildcard
    assert_digest_difference("events/index") do
      change_template("events/_completed")
    end
  end

  def test_explicit_dependency_wildcard_picks_up_added_file
    old_caching, ActionView::Resolver.caching = ActionView::Resolver.caching, false

    assert_digest_difference("events/index") do
      add_template("events/_uncompleted")
    end
  ensure
    remove_template("events/_uncompleted")
    ActionView::Resolver.caching = old_caching
  end

  def test_explicit_dependency_wildcard_picks_up_removed_file
    old_caching, ActionView::Resolver.caching = ActionView::Resolver.caching, false
    add_template("events/_subscribers_changed")

    assert_digest_difference("events/index") do
      remove_template("events/_subscribers_changed")
    end
  ensure
    ActionView::Resolver.caching = old_caching
  end

  def test_second_level_dependency
    assert_digest_difference("messages/show") do
      change_template("comments/_comments")
    end
  end

  def test_second_level_dependency_within_same_directory
    assert_digest_difference("messages/show") do
      change_template("messages/_header")
    end
  end

  def test_third_level_dependency
    assert_digest_difference("messages/show") do
      change_template("comments/_comment")
    end
  end

  def test_directory_depth_dependency
    assert_digest_difference("level/below/index") do
      change_template("level/below/_header")
    end
  end

  def test_logging_of_missing_template
    assert_logged "Couldn't find template for digesting: messages/something_missing" do
      digest("messages/show")
    end
  end

  def test_logging_of_missing_template_ending_with_number
    assert_logged "Couldn't find template for digesting: messages/something_missing_1" do
      digest("messages/show")
    end
  end

  def test_logging_of_missing_template_for_dependencies
    assert_logged "'messages/something_missing' file doesn't exist, so no dependencies" do
      dependencies("messages/something_missing")
    end
  end

  def test_logging_of_missing_template_for_nested_dependencies
    assert_logged "'messages/something_missing' file doesn't exist, so no dependencies" do
      nested_dependencies("messages/something_missing")
    end
  end

  def test_getting_of_singly_nested_dependencies
    singly_nested_dependencies = ["messages/header", "messages/form", "messages/message", "events/event", "comments/comment"]
    assert_equal singly_nested_dependencies, nested_dependencies('messages/edit')
  end

  def test_getting_of_doubly_nested_dependencies
    doubly_nested = [{"comments/comments"=>["comments/comment"]}, "messages/message"]
    assert_equal doubly_nested, nested_dependencies('messages/peek')
  end

  def test_nested_template_directory
    assert_digest_difference("messages/show") do
      change_template("messages/actions/_move")
    end
  end

  def test_nested_template_deps
    nested_deps = ["messages/header", {"comments/comments"=>["comments/comment"]}, "messages/actions/move", "events/event", "messages/something_missing", "messages/something_missing_1", "messages/message", "messages/form"]
    assert_equal nested_deps, nested_dependencies("messages/show")
  end

  def test_recursion_in_renders
    assert digest("level/recursion") # assert recursion is possible
    assert_not_nil digest("level/recursion") # assert digest is stored
  end

  def test_chaining_the_top_template_on_recursion
    assert digest("level/recursion") # assert recursion is possible

    assert_digest_difference("level/recursion") do
      change_template("level/recursion")
    end

    assert_not_nil digest("level/recursion") # assert digest is stored
  end

  def test_chaining_the_partial_template_on_recursion
    assert digest("level/recursion") # assert recursion is possible

    assert_digest_difference("level/recursion") do
      change_template("level/_recursion")
    end

    assert_not_nil digest("level/recursion") # assert digest is stored
  end

  def test_dont_generate_a_digest_for_missing_templates
    assert_equal '', digest("nothing/there")
  end

  def test_collection_dependency
    assert_digest_difference("messages/index") do
      change_template("messages/_message")
    end

    assert_digest_difference("messages/index") do
      change_template("events/_event")
    end
  end

  def test_collection_derived_from_record_dependency
    assert_digest_difference("messages/show") do
      change_template("events/_event")
    end
  end

  def test_details_are_included_in_cache_key
    # Cache the template digest.
    @finder = FixtureFinder.new({:formats => [:html]})
    old_digest = digest("events/_event")

    # Change the template; the cached digest remains unchanged.
    change_template("events/_event")

    # The details are changed, so a new cache key is generated.
    @finder = FixtureFinder.new

    # The cache is busted.
    assert_not_equal old_digest, digest("events/_event")
  end

  def test_extra_whitespace_in_render_partial
    assert_digest_difference("messages/edit") do
      change_template("messages/_form")
    end
  end

  def test_extra_whitespace_in_render_named_partial
    assert_digest_difference("messages/edit") do
      change_template("messages/_header")
    end
  end

  def test_extra_whitespace_in_render_record
    assert_digest_difference("messages/edit") do
      change_template("messages/_message")
    end
  end

  def test_extra_whitespace_in_render_with_parenthesis
    assert_digest_difference("messages/edit") do
      change_template("events/_event")
    end
  end

  def test_old_style_hash_in_render_invocation
    assert_digest_difference("messages/edit") do
      change_template("comments/_comment")
    end
  end

  def test_variants
    assert_digest_difference("messages/new", variants: [:iphone]) do
      change_template("messages/new",     :iphone)
      change_template("messages/_header", :iphone)
    end
  end

  def test_dependencies_via_options_results_in_different_digest
    digest_plain        = digest("comments/_comment")
    digest_fridge       = digest("comments/_comment", dependencies: ["fridge"])
    digest_phone        = digest("comments/_comment", dependencies: ["phone"])
    digest_fridge_phone = digest("comments/_comment", dependencies: ["fridge", "phone"])

    assert_not_equal digest_plain, digest_fridge
    assert_not_equal digest_plain, digest_phone
    assert_not_equal digest_plain, digest_fridge_phone
    assert_not_equal digest_fridge, digest_phone
    assert_not_equal digest_fridge, digest_fridge_phone
    assert_not_equal digest_phone, digest_fridge_phone
  end

  def test_digest_cache_cleanup_with_recursion
    first_digest = digest("level/_recursion")
    second_digest = digest("level/_recursion")

    assert first_digest

    # If the cache is cleaned up correctly, subsequent digests should return the same
    assert_equal first_digest, second_digest
  end

  def test_digest_cache_cleanup_with_recursion_and_template_caching_off
    resolver_before = ActionView::Resolver.caching
    ActionView::Resolver.caching = false

    first_digest = digest("level/_recursion")
    second_digest = digest("level/_recursion")

    assert first_digest

    # If the cache is cleaned up correctly, subsequent digests should return the same
    assert_equal first_digest, second_digest
  ensure
    ActionView::Resolver.caching = resolver_before
  end

  private
    def assert_logged(message)
      old_logger = ActionView::Base.logger
      log = StringIO.new
      ActionView::Base.logger = Logger.new(log)

      begin
        yield

        log.rewind
        assert_match message, log.read
      ensure
        ActionView::Base.logger = old_logger
      end
    end

    def assert_digest_difference(template_name, options = {})
      previous_digest = digest(template_name, options)
      finder.digest_cache.clear

      yield

      assert_not_equal previous_digest, digest(template_name, options), "digest didn't change"
      finder.digest_cache.clear
    end

    def digest(template_name, options = {})
      options = options.dup

      finder.variants = options.delete(:variants) || []
      ActionView::Digestor.digest(name: template_name, finder: finder, dependencies: (options[:dependencies] || []))
    end

    def dependencies(template_name)
      tree = ActionView::Digestor.tree(template_name, finder)
      tree.children.map(&:name)
    end

    def nested_dependencies(template_name)
      tree = ActionView::Digestor.tree(template_name, finder)
      tree.children.map(&:to_dep_map)
    end

    def finder
      @finder ||= FixtureFinder.new
    end

    def change_template(template_name, variant = nil)
      variant = "+#{variant}" if variant.present?

      File.open("digestor/#{template_name}.html#{variant}.erb", "w") do |f|
        f.write "\nTHIS WAS CHANGED!"
      end
    end
    alias_method :add_template, :change_template

    def remove_template(template_name)
      File.delete("digestor/#{template_name}.html.erb")
    end
end


text:
layout: post
title: ISRO Centralised Recruitment Scientist Engineer posts last date 24th Aug-2015
date: 2015-08-06 20:38
comments: true
tags:  Architect  Engineer  ISRO  Latest  Online  Scientist  Space
archive: false
---
Centralised Recruitment of Scientists/Engineers 'SC' with BE/B.Tech. OR Equivalent Degree in  Civil, Electrical, Refrigeration & AC and Architecture

ISRO offers the position of Scientist/Engineer `SC' in the pay band of Rs. 15600 - 39100/- + Grade Pay Rs. 5400 to the to young engineering graduates in the following specialized fields :

- Scientist/Engineer SC - Civil (Code : BE004) : 08 posts
- Scientist/Engineer SC - Electrical (Code : BE005) : 02 posts
- Scientist/Engineer SC - AC & Refrigeration (Code : BE006) : 02 posts
- Scientist/Engineer SC - Architecture (Code : BE007) : 01 post

 For Semi Conductor Laboratory, Chandigarh

- Scientist/Engineer SC - Civil (Code : BE008) : 02 posts
- Scientist/Engineer SC - Electrical (Code : BE009) : 02 posts

Eligibility: BE/B.Tech in First Class or equivalent with an aggregate minimum of 65% (average of all semesters for which results are available).

Age Limit: 35 years as on 24/08/2015. Ex-serviceman and Persons with Disabilities [PWD] are eligible for age relaxation as per Govt. of India orders).

Application Fee :  100/-  for each application in the form  to be pais in any branch of SBI through a payment challan voucher.  No fee from SC/ST/PH/Women candidates are exempted from the fee.

**How to apply** : The application for on-line registration is hosted in the ISRO web-site between 04/08/2015 and 24/08/2015.

A written test for selection will be conducted 0n 29/11/2015.

Please visit  <http://isro.gov.in/careers>  for further information and complete details.


text:
export default function jsonToMarkdown(json) {
	// reset title level between files processing
	// (this title level management has to be rewriten when possible)
	this._titleLevel(-100);
	// template
	const template = this._config.templates[this._config.language] || this._config.templates.default;
	const tpl = template(json);
	// return markdown
	return tpl.trim();
}


text:
C $Header$
C $Name$

#ifdef ALLOW_SALT_PLUME

C--   SALT_PLUME parameters
C     Find surface where the potential density (ref.lev=surface) is
C     larger than surface density plus SaltPlumeCriterion.

C     SaltPlumeSouthernOcean: TRUE  = apply salt plume globally
C                             FALSE = apply salt plume in Arctic Ocean only
      LOGICAL SaltPlumeSouthernOcean
#ifdef SALT_PLUME_SPLIT_BASIN
      LOGICAL SaltPlumeSplitBasin
#endif
      COMMON /SALT_PLUME_PARAMS_L/ SaltPlumeSouthernOcean
#ifdef SALT_PLUME_SPLIT_BASIN
     &      , SaltPlumeSplitBasin
#endif

C     CriterionType: 1=delta_rho, 2=drhodz, default is 1
C     PlumeMethod: method of distributing salt plume vertically
C       1=power, 2=exp, 3=overshoot, 5=dump_at_top, 6=reverse of 1
C       default is 1
C     Npower: choices of distributing salt uniformly (0), linear (1),
C       or higher power (Npower>1); default is 0 when PlumeMethod = 1
      INTEGER CriterionType, PlumeMethod
#ifdef SALT_PLUME_SPLIT_BASIN
     & , Npower(2)
#else
     & , Npower
#endif
      COMMON /SALT_PLUME_PARAMS_I/ CriterionType, PlumeMethod, Npower

C     SaltPlumeCriterion
C       for CriterionType=1, default is 0.4 kg/m^3 of Duffy et al 1999
C       for CriterionType=2, default is 0.005 kg/m^3/m
C     SPovershoot: overshooting depth of penetrating salt plume,
C       so that 1.0 = no-overshoot, 1.2 = 20% overshoot.
C       default is 1.0
C     SPsalFRAC: fraction of the salt by-product of seaice growth (not melt) that
C       will be re-distributed vertically according to the salt_plume_frac.F
C       Its default is 1. (for 100% effect), and its range is [0. 1.]
C     SPinflectionPoint: the inflection point of a nonlinear function
C       f(AREA) controlling saltPlumeFlux. f(AREA) is a logistic curve
C       (sigmoid) with range [0. 1.] and f(SPinflectionPoint) == 0.5.
C       Usage: pkg/salt_plume activates when AREA>=SPinflectionPoint.
C       To assure only narrow leads generate plumes:
C       set SPinflectionPoint >= 0.8.
C     SPalpha :: fraction of grid volume designated to be brine, [0. 1.]
C       If grid cell 18km x 18km x 10m, take SPalpha=0.001 gives
C       volume of 0.001*drF(1)*[dx*dy] of brine. Thus SPbrineSalt
C       can be calc as adding SaltPlumeFlux into this fractional vol.
C       Default: 0.008 -> SPbrineSalt ~37 if SSS is ~32.
C     SPbrineSconst :: salinity of brine pocket [psu]

      _RL SaltPlumeCriterion, SPovershoot
#ifdef SALT_PLUME_SPLIT_BASIN
     &   , SPsalFRAC(2)
#else /* SALT_PLUME_SPLIT_BASIN */
     &   , SPsalFRAC
#endif /* SALT_PLUME_SPLIT_BASIN */
#ifdef SALT_PLUME_VOLUME
     &   , SPbrineSconst, SPbrineSaltmax
#endif /* SALT_PLUME_VOLUME */
#ifdef SALT_PLUME_IN_LEADS
     &   , SPinflectionPoint
#endif /* SALT_PLUME_IN_LEADS */
      COMMON /SALT_PLUME_PARAMS_R/
     &   SPsalFRAC, SaltPlumeCriterion, SPovershoot
#ifdef SALT_PLUME_VOLUME
     &   , SPbrineSconst, SPbrineSaltmax
#endif /* SALT_PLUME_VOLUME */
#ifdef SALT_PLUME_IN_LEADS
     &   , SPinflectionPoint
#endif
C--   SALT_PLUME 2-dim. fields
C     SaltPlumeDepth :: depth of penetration of salt plumes
C                       rejected during sea ice growth
C     saltPlumeFlux :: Net downward salt flux in psu.kg/m^2/s
C              Note: a) only used when salty sea-ice forms.
C                    b) units: when salinity (unit= psu) is expressed
C                       in g/kg, saltPlumeFlux unit becomes g/m^2/s.
C              > 0 for increasing in SSS.
C              Southwest C-grid tracer point
C     dSPvolSurf2kLev :: downward volume frac from klev=1 associated w/ saltPlumeFlux
C     dSPvolBelow2kLev:: upward volume frac from grid below (RETIRED)
C     dSPvolkLev2Above:: upward volume frac to grid above
C     SPbrineVolFlux  :: brine Vol associated w/ SPbrineSconst & saltPlumeFlux
C     SPforcingS      :: 3D forcingS associated w/ saltPlumeFlux [g/m2/s]
C     SPforcingT      :: 3D forcingT associated w/ saltPlumeFlux [W/m2]
C     SPkBottom       :: bottom kLev associated with SaltPlumeDepth

      _RL SaltPlumeDepth (1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
      _RL  saltPlumeFlux (1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
#ifdef SALT_PLUME_VOLUME
      _RL SPbrineVolFlux (1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
      _RL SPforcS1       (1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
      _RL SPforcT1       (1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
      _RL dSPvolSurf2kLev (1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr,nSx,nSy)
     &   ,dSPvolkLev2Above(1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr+1,nSx,nSy)
     &   ,SPforcingS      (1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr,nSx,nSy)
     &   ,SPforcingT      (1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr,nSx,nSy)
     &   ,SPplumek        (1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr+1,nSx,nSy)
#endif
      COMMON /DYNVARS_SALT_PLUME/ SaltPlumeDepth
#ifdef SALT_PLUME_VOLUME
     &    ,SPbrineVolFlux,SPforcS1,SPforcT1
      COMMON /FFIELDS_SaltPlumeVol/
     &     dSPvolSurf2kLev,dSPvolkLev2Above
     &     ,SPforcingS,SPforcingT
     &     ,SPplumek
#endif
      COMMON /FFIELDS_saltPlumeFlux/ saltPlumeFlux
#endif /* ALLOW_SALT_PLUME */


text:
import {
  MEETINGS,
  _IN_LOBBY_,
  _NOT_IN_MEETING_,
  _IN_MEETING_
} from '../constants';

import MemberUtil from './util.js';

/**
 * @class Member
 */
export default class Member {
  namespace = MEETINGS;

  /**
   * @param {Object} participant - the locus participant
   * @param {Object} options - optional constructor params
   * @returns {Member}
   * @memberof Member
   */
  constructor(participant, options = {}) {
    this.participant = null;
    this.id = null;
    this.name = null;
    this.email = null;
    this.isAudioMuted = null;
    this.isVideoMuted = null;
    this.isSelf = null;
    this.isHost = null;
    this.isGuest = null;
    this.isInLobby = null;
    this.isInMeeting = null;
    this.isNotAdmitted = null;
    this.isContentSharing = null;
    this.status = null;
    this.isDevice = null;
    this.isUser = null;
    this.associatedUser = null;
    this.isRecording = null;
    this.isMutable = null;
    this.isRemovable = null;
    this.type = null;
    // TODO: more participant types
    // such as native client, web client, is a device, what type of phone, etc
    this.processParticipant(participant);
    this.processParticipantOptions(participant, options);
    this.processMember();
  }

  /**
   * set all the participant values extracted directly from locus participant
   * @param {Object} participant the locus participant object
   * @returns {undefined}
   * @memberof Member
   */
  processParticipant(participant) {
    this.participant = participant;
    if (participant) {
      this.id = MemberUtil.extractId(participant);
      this.name = MemberUtil.extractName(participant);
      this.email = MemberUtil.extractEmail(participant);
      this.isAudioMuted = MemberUtil.isAudioMuted(participant);
      this.isVideoMuted = MemberUtil.isVideoMuted(participant);
      this.isRecording = MemberUtil.isRecording(participant);
      this.isGuest = MemberUtil.isGuest(participant);
      this.isUser = MemberUtil.isUser(participant);
      this.isDevice = MemberUtil.isDevice(participant);
      this.processStatus(participant);
      // must be done last
      this.isNotAdmitted = MemberUtil.isNotAdmitted(participant, this.isGuest, this.status);
    }
  }

  /**
   * Use the members options and participant values to set on the member
   * @param {Object} participant the locus participant object
   * @param {Object} options the passed in options, what was set on members
   * @returns {undefined}
   * @memberof Member
   */
  processParticipantOptions(participant, options) {
    if (participant && options) {
      this.processIsSelf(participant, options.selfId);
      this.processIsHost(participant, options.hostId);
      this.processIsContentSharing(participant, options.contentSharingId);
      this.processType(options.type);
    }
  }

  processMember() {
    // must occur after self, guest, meeting, and type properties are calculated
    this.isRemovable = MemberUtil.isRemovable(this.isSelf, this.isGuest, this.isInMeeting, this.type);
    // must occur after self, device, meeting, mute status, and type properties are calculated
    this.isMutable = MemberUtil.isMutable(this.isSelf, this.isDevice, this.isInMeeting, this.isAudioMuted, this.type);
  }

  /**
   * set the status on member object
   * @param {Object} participant the locus participant object
   * @returns {undefined}
   * @memberof Member
   */
  processStatus(participant) {
    this.status = MemberUtil.extractStatus(participant);
    switch (this.status) {
      case _IN_LOBBY_:
        this.isInLobby = true;
        this.isInMeeting = false;
        break;
      case _IN_MEETING_:
        this.isInLobby = false;
        this.isInMeeting = true;
        break;
      case _NOT_IN_MEETING_:
        this.isInLobby = false;
        this.isInMeeting = false;
        break;
      default:
        this.isInLobby = false;
        this.isInMeeting = false;
    }
  }

  /**
   * set the isContentSharing on member
   * @param {Boolean} flag
   * @returns {undefined}
   * @memberof Member
   */
  setIsContentSharing(flag) {
    this.isContentSharing = flag;
  }

  /**
   * set the isHost on member
   * @param {Boolean} flag
   * @returns {undefined}
   * @memberof Member
   */
  setIsHost(flag) {
    this.isHost = flag;
  }

  /**
   * set the isSelf on member
   * @param {Boolean} flag
   * @returns {undefined}
   * @memberof Member
   */
  setIsSelf(flag) {
    this.isSelf = flag;
  }

  /**
   * determine if this member is content sharing
   * @param {Object} participant
   * @param {String} sharingId
   * @returns {undefined}
   * @memberof Member
   */
  processIsContentSharing(participant, sharingId) {
    if (MemberUtil.isUser(participant)) {
      this.isContentSharing = MemberUtil.isSame(participant, sharingId);
    }
    else if (MemberUtil.isDevice(participant)) {
      this.isContentSharing = MemberUtil.isAssociatedSame(participant, sharingId);
    }
  }

  /**
   * determine if this member is the self
   * @param {Object} participant
   * @param {String} selfId
   * @returns {undefined}
   * @memberof Member
   */
  processIsSelf(participant, selfId) {
    if (MemberUtil.isUser(participant)) {
      this.isSelf = MemberUtil.isSame(participant, selfId);
    }
    else if (MemberUtil.isDevice(participant)) {
      this.isSelf = MemberUtil.isAssociatedSame(participant, selfId);
      this.associatedUser = selfId;
    }
  }

  /**
   * determine if this member is the host
   * @param {Object} participant
   * @param {String} hostId
   * @returns {undefined}
   * @memberof Member
   */
  processIsHost(participant, hostId) {
    if (MemberUtil.isUser(participant)) {
      this.isHost = MemberUtil.isSame(participant, hostId);
    }
    else if (MemberUtil.isDevice(participant)) {
      this.isHost = MemberUtil.isAssociatedSame(participant, hostId);
    }
  }

  processType(type) {
    this.type = type;
  }
}


text:
//dojo.require("dojo.has");

require([
	"dijit/_base/manager",  // dijit.byId
	"doh/runner"	//doh functions
]);

function fireOnClick(obj){
	var anchorNode;
	if(typeof obj === "string"){
		var demoWidget = dijit.byId(obj);
		anchorNode = demoWidget.domNode;
	}else{
		anchorNode = obj;
	}
	if(dojo.isIE<9){
		anchorNode.fireEvent( "onclick" );
	}else{
		var e = document.createEvent('Events');
		e.initEvent('click', true, true);
		anchorNode.dispatchEvent(e);
	}
}

function fireOnMouseDown(obj){
	var anchorNode;
	if(typeof obj === "string"){
		var demoWidget = dijit.byId(obj);
		anchorNode = demoWidget.domNode;
	}else{
		anchorNode = obj;
	}
	if(dojo.isIE<9){
		anchorNode.fireEvent( "onmousedown" );
	}else{
		var eventName = "mousedown";
		if (dojo.isIE >= 10){
			eventName = "MSPointerDown";
		}
		var e = document.createEvent('Events');
		e.initEvent(eventName, true, true);
		anchorNode.dispatchEvent(e);
	}
}
function fireOnMouseUp(obj){
	var anchorNode;
	if(typeof obj === "string"){
		var demoWidget = dijit.byId(obj);
		anchorNode = demoWidget.domNode;
	}else{
		anchorNode = obj;
	}
	if(dojo.isIE<9){
		anchorNode.fireEvent( "onmouseup" );
	}else{
		var eventName = "mouseup";
		if (dojo.isIE >= 10){
			eventName = "MSPointerUp";
		}
		var e = document.createEvent('Events');
		e.initEvent(eventName, true, true);
		anchorNode.dispatchEvent(e);
	}
}

function fireTouchEvent(eventtype, node, x, y){
	var e;
	if(dojo.isIE<9){
		e = document.createEventObject(window.event);
		e.button = 1;
		e.pageX = x;
		e.pageY = y;
		node.fireEvent( "on" + eventtype[1], e );
	}else{
		e = document.createEvent('Events');
		e.initEvent( dojo.has('touch') ? eventtype[0] : eventtype[1], true, true);
		e.touches = [ { pageX: x, pageY: y } ];
		e.pageX = x;
		e.pageY = y;
		e.changedTouches = e.touches;
		node.dispatchEvent(e);
	}
}

/*
function fireTouchStart(node, x, y){
	fireTouchEvent(["touchstart", "mousedown"], node, x, y);
}

function fireTouchEnd(node, x, y){
	fireTouchEvent(["touchend", "mouseup"], node, x, y);
}

function fireTouchMove(node, x, y){
	fireTouchEvent(["touchmove", "mousemove"], node, x, y);
}
*/

function verifyListItem(id, text, rightText, domButtonType, hasIcon, hasRightIcon, hasIcon2, hasVariableHeight, regExp, hasSelected, isSprite){
	var demoWidget = dijit.byId(id);
	doh.assertNotEqual(null, demoWidget, "ListItem: Did not instantiate. id=" + id);
	doh.assertEqual('mblListItem' + (hasVariableHeight ?" mblVariableHeight":"") + (hasSelected ?" mblListItemSelected":""), demoWidget.domNode.className, "id=" + id);
	var childNodes = demoWidget.domNode.children;
//	doh.assertEqual('mblListItemAnchor' + (hasIcon?'':' mblListItemAnchorNoIcon'), childNodes[0].className);

//	doh.assertEqual('A', childNodes[0].tagName);

//	childNodes = childNodes[0].childNodes;

	var i=0;
	if(hasIcon){
		if(!dojo.isIE && regExp){
			if(isSprite){
				doh.assertTrue(childNodes[i].childNodes[0].src.search(regExp) != -1, "search " + regExp.toString());
			}else{
				doh.assertTrue(childNodes[i].src.search(regExp) != -1, "search " + regExp.toString());
			}
		}
		doh.assertTrue(dojo.hasClass(childNodes[i], 'mblListItemIcon'), 'mblListItemIcon id=' + id + " got: " + childNodes[i].className);
		i++;
	}

	if(hasRightIcon){
		if(domButtonType){
			doh.assertEqual(domButtonType + ' mblDomButton', childNodes[i].childNodes[0].className, "id=" + id);
		}
		doh.assertTrue(dojo.hasClass(childNodes[i], 'mblListItemRightIcon'), 'mblListItemRightIcon id=' + id + " got: " + childNodes[i].className);
		i++;
	}

	if(hasIcon2){
		doh.assertTrue(dojo.hasClass(childNodes[i], 'mblListItemRightIcon2'), 'mblListItemRightIcon2 id=' + id + " got: " + childNodes[i].className);
		i++;
	}

	if(rightText){
		doh.assertEqual(rightText, dojo.isFF ==3.6 ? childNodes[i].childNodes[0].innerHTML : childNodes[i].innerHTML, "id=" + id); //2 0r 3
		doh.assertEqual('mblListItemRightText', childNodes[i++].className, "id=" + id);
	}
	if(!hasVariableHeight){
		doh.assertEqual('mblListItemLabel', childNodes[i].className, "id=" + id);
		doh.assertEqual('DIV', childNodes[i].tagName, "id=" + id);
	}else{
		doh.assertEqual('mblListItemLabel', childNodes[i+1].className, "id=" + id);
		doh.assertEqual('DIV', childNodes[i+1].tagName, "id=" + id);
	}

	try{
		doh.assertEqual(text, dojo.trim(childNodes[i].innerHTML.replace(/\r\n|\n|\t/g,"")), "id=" + id);
	} catch (e) {
		if(dojo.isFF ==3.6){
			doh.assertEqual(text, dojo.trim(childNodes[i].childNodes[0].innerHTML.replace(/\r\n|\n|\t/g,"")), "id=" + id);
		}else{
			throw e;
		}
	}

}

function verifyListItemPos(id, rTop, rRight, rBottom, rLeft, sTop, sLeft, isSprite) {
	var demoWidget = dijit.byId(id);
	var node;
	if(isSprite){
		node = demoWidget.domNode.childNodes[0].childNodes[0];
	}else{
		node = demoWidget.domNode.childNodes[0].childNodes[0].childNodes[0];
	}
	verifyRect(node, rTop, rRight, rBottom, rLeft);

	doh.assertEqual(sTop, node.style.top);
	doh.assertEqual(sLeft, node.style.left);
}

function verifyRect(node, rTop, rRight, rBottom, rLeft) {
	var rectArray = node.style.clip.split(/[, ]+/);
	doh.assertEqual("rect("+rTop, rectArray[0]);
	doh.assertEqual(rRight, rectArray[1]);
	doh.assertEqual(rBottom, rectArray[2]);
	doh.assertEqual(rLeft+")", rectArray[3]);
}

function verifyIconItem(id, text, display, regExp, isSprite){
	var demoWidget = dijit.byId(id);
	if(!dojo.isIE && !dojo.isFF) {
		if(isSprite){
			doh.assertTrue(demoWidget.domNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0].src.search(regExp) != -1, "search " + regExp.toString() + " id=" +id);
		}else{
			doh.assertTrue(demoWidget.domNode.childNodes[0].childNodes[0].childNodes[0].src.search(regExp) != -1, "search " + regExp.toString() + " id=" +id);
		}
	}
	doh.assertEqual(text, demoWidget.domNode.childNodes[0].childNodes[1].childNodes[0].nodeValue, "id=" +id);
	doh.assertEqual(display, demoWidget.paneWidget.domNode.style.display, "id=" +id);
	doh.assertEqual('mblIconItemPaneHeading', demoWidget.paneWidget.domNode.childNodes[0].className, "id=" +id);
	doh.assertEqual('mblDomButtonBlueMinus mblDomButton', demoWidget.paneWidget.domNode.childNodes[0].childNodes[0].childNodes[0].className, "id=" +id);
	doh.assertEqual(text, demoWidget.paneWidget.domNode.childNodes[0].childNodes[1].childNodes[0].nodeValue, "id=" +id);
}

function verifyTabBarButton(id, text, classNames, visibility1, visibility2, regExp1, regExp2, isSprite){
	var demoWidget = dijit.byId(id);
	for(var i = 0; i < classNames.length;i++){
		doh.assertTrue(dojo.hasClass(demoWidget.domNode, classNames[i]), classNames[i] + " id=" +id + " className:"+demoWidget.domNode.className);
	}
	doh.assertEqual('mblTabBarButtonIconArea', demoWidget.domNode.childNodes[0].className, "id=" +id);
	doh.assertEqual('mblTabBarButtonLabel', demoWidget.domNode.childNodes[1].className, "id=" +id);
	if(demoWidget.iconNode1){
		if(!dojo.isIE) {
			if(isSprite){
				doh.assertTrue(demoWidget.iconNode1.childNodes[0].src.search(regExp1) != -1, "search " + regExp1.toString() + " id=" +id);
			}else{
				doh.assertTrue(demoWidget.iconNode1.src.search(regExp1) != -1, "search " + regExp1.toString() + " id=" +id);
			}
		}
//		doh.assertEqual(visibility1, demoWidget.iconNode1.style.visibility, "id=" +id);
	}else{
		console.log("There is no iconNode1. id=" + id);
	}
	if(demoWidget.iconNode2){
		if(!dojo.isIE){
			if(isSprite){
				doh.assertTrue(demoWidget.iconNode2.childNodes[0].src.search(regExp2) != -1, "search " + regExp2.toString() + " id=" +id);
			}else{
				doh.assertTrue(demoWidget.iconNode2.src.search(regExp2) != -1, "search " + regExp2.toString() + " id=" +id);
			}
		}
		doh.assertEqual(visibility2, demoWidget.iconNode2.style.visibility, "id=" +id);
	}else{
		console.log("There is no iconNode2. id=" + id);
	}
	doh.assertEqual(text, dojo.trim(demoWidget.labelNode.innerHTML), "id=" +id);
}


text:
#if !defined(FUSION_FUSION_ITERATOR_10012005_1551)
#define FUSION_FUSION_ITERATOR_10012005_1551

#include <boost/fusion/iterator/value_of.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/prior.hpp>
#include <boost/fusion/iterator/advance.hpp>
#include <boost/fusion/iterator/distance.hpp>
#include <boost/fusion/support/category_of.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/advance_fwd.hpp>
#include <boost/mpl/distance_fwd.hpp>

namespace boost { namespace mpl
{
    template <typename Iterator>
    struct fusion_iterator
    {
        typedef typename fusion::result_of::value_of<Iterator>::type type;
        typedef typename fusion::traits::category_of<Iterator>::type category;
        typedef Iterator iterator;
    };

    template <typename Iterator>
    struct next<fusion_iterator<Iterator> >
    {
        typedef fusion_iterator<typename fusion::result_of::next<Iterator>::type> type;
    };

    template <typename Iterator>
    struct prior<fusion_iterator<Iterator> >
    {
        typedef fusion_iterator<typename fusion::result_of::prior<Iterator>::type> type;
    };

    template <typename Iterator, typename N>
    struct advance<fusion_iterator<Iterator>, N>
    {
        typedef fusion_iterator<typename fusion::result_of::advance<Iterator, N>::type> type;
    };

    template <typename First, typename Last>
    struct distance<fusion_iterator<First>, fusion_iterator<Last> >
        : fusion::result_of::distance<First, Last>
    {};

}}

#endif


text:
using base::Passed;
using remoting::protocol::ChannelConfig;
using remoting::protocol::SessionConfig;

namespace remoting {

RectangleUpdateDecoder::RectangleUpdateDecoder(
    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
    scoped_refptr<FrameConsumerProxy> consumer)
    : task_runner_(task_runner),
      consumer_(consumer),
      source_size_(SkISize::Make(0, 0)),
      source_dpi_(SkIPoint::Make(0, 0)),
      view_size_(SkISize::Make(0, 0)),
      clip_area_(SkIRect::MakeEmpty()),
      paint_scheduled_(false) {
}

RectangleUpdateDecoder::~RectangleUpdateDecoder() {
}

void RectangleUpdateDecoder::Initialize(const SessionConfig& config) {
  // Initialize decoder based on the selected codec.
  ChannelConfig::Codec codec = config.video_config().codec;
  if (codec == ChannelConfig::CODEC_VERBATIM) {
    decoder_.reset(DecoderRowBased::CreateVerbatimDecoder());
  } else if (codec == ChannelConfig::CODEC_ZIP) {
    decoder_.reset(DecoderRowBased::CreateZlibDecoder());
  } else if (codec == ChannelConfig::CODEC_VP8) {
    decoder_.reset(new DecoderVp8());
  } else {
    NOTREACHED() << "Invalid Encoding found: " << codec;
  }
}

void RectangleUpdateDecoder::DecodePacket(scoped_ptr<VideoPacket> packet,
                                          const base::Closure& done) {
  if (!task_runner_->BelongsToCurrentThread()) {
    task_runner_->PostTask(
        FROM_HERE, base::Bind(&RectangleUpdateDecoder::DecodePacket,
                              this, base::Passed(&packet), done));
    return;
  }

  base::ScopedClosureRunner done_runner(done);
  bool decoder_needs_reset = false;
  bool notify_size_or_dpi_change = false;

  // If the packet includes screen size or DPI information, store them.
  if (packet->format().has_screen_width() &&
      packet->format().has_screen_height()) {
    SkISize source_size = SkISize::Make(packet->format().screen_width(),
                                        packet->format().screen_height());
    if (source_size_ != source_size) {
      source_size_ = source_size;
      decoder_needs_reset = true;
      notify_size_or_dpi_change = true;
    }
  }
  if (packet->format().has_x_dpi() && packet->format().has_y_dpi()) {
    SkIPoint source_dpi(SkIPoint::Make(packet->format().x_dpi(),
                                       packet->format().y_dpi()));
    if (source_dpi != source_dpi_) {
      source_dpi_ = source_dpi;
      notify_size_or_dpi_change = true;
    }
  }

  // If we've never seen a screen size, ignore the packet.
  if (source_size_.isZero())
    return;

  if (decoder_needs_reset)
    decoder_->Initialize(source_size_);
  if (notify_size_or_dpi_change)
    consumer_->SetSourceSize(source_size_, source_dpi_);

  if (!decoder_->IsReadyForData()) {
    // TODO(ajwong): This whole thing should move into an invalid state.
    LOG(ERROR) << "Decoder is unable to process data. Dropping packet.";
    return;
  }

  if (decoder_->DecodePacket(packet.get()) == Decoder::DECODE_DONE)
    SchedulePaint();
}

void RectangleUpdateDecoder::SchedulePaint() {
  if (paint_scheduled_)
    return;
  paint_scheduled_ = true;
  task_runner_->PostTask(
      FROM_HERE, base::Bind(&RectangleUpdateDecoder::DoPaint, this));
}

void RectangleUpdateDecoder::DoPaint() {
  DCHECK(paint_scheduled_);
  paint_scheduled_ = false;

  // If the view size is empty or we have no output buffers ready, return.
  if (buffers_.empty() || view_size_.isEmpty())
    return;

  // If no Decoder is initialized, or the host dimensions are empty, return.
  if (!decoder_.get() || source_size_.isEmpty())
    return;

  // Draw the invalidated region to the buffer.
  pp::ImageData* buffer = buffers_.front();
  SkRegion output_region;
  decoder_->RenderFrame(view_size_, clip_area_,
                        reinterpret_cast<uint8*>(buffer->data()),
                        buffer->stride(),
                        &output_region);

  // Notify the consumer that painting is done.
  if (!output_region.isEmpty()) {
    buffers_.pop_front();
    consumer_->ApplyBuffer(view_size_, clip_area_, buffer, output_region);
  }
}

void RectangleUpdateDecoder::RequestReturnBuffers(const base::Closure& done) {
  if (!task_runner_->BelongsToCurrentThread()) {
    task_runner_->PostTask(
        FROM_HERE, base::Bind(&RectangleUpdateDecoder::RequestReturnBuffers,
        this, done));
    return;
  }

  while (!buffers_.empty()) {
    consumer_->ReturnBuffer(buffers_.front());
    buffers_.pop_front();
  }

  if (!done.is_null())
    done.Run();
}

void RectangleUpdateDecoder::DrawBuffer(pp::ImageData* buffer) {
  if (!task_runner_->BelongsToCurrentThread()) {
    task_runner_->PostTask(
        FROM_HERE, base::Bind(&RectangleUpdateDecoder::DrawBuffer,
                              this, buffer));
    return;
  }

  DCHECK(clip_area_.width() <= buffer->size().width() &&
         clip_area_.height() <= buffer->size().height());

  buffers_.push_back(buffer);
  SchedulePaint();
}

void RectangleUpdateDecoder::InvalidateRegion(const SkRegion& region) {
  if (!task_runner_->BelongsToCurrentThread()) {
    task_runner_->PostTask(
        FROM_HERE, base::Bind(&RectangleUpdateDecoder::InvalidateRegion,
                              this, region));
    return;
  }

  if (decoder_.get()) {
    decoder_->Invalidate(view_size_, region);
    SchedulePaint();
  }
}

void RectangleUpdateDecoder::SetOutputSizeAndClip(const SkISize& view_size,
                                                  const SkIRect& clip_area) {
  if (!task_runner_->BelongsToCurrentThread()) {
    task_runner_->PostTask(
        FROM_HERE, base::Bind(&RectangleUpdateDecoder::SetOutputSizeAndClip,
                              this, view_size, clip_area));
    return;
  }

  // The whole frame needs to be repainted if the scaling factor has changed.
  if (view_size_ != view_size && decoder_.get()) {
    SkRegion region;
    region.op(SkIRect::MakeSize(view_size), SkRegion::kUnion_Op);
    decoder_->Invalidate(view_size, region);
  }

  if (view_size_ != view_size ||
      clip_area_ != clip_area) {
    view_size_ = view_size;
    clip_area_ = clip_area;

    // Return buffers that are smaller than needed to the consumer for
    // reuse/reallocation.
    std::list<pp::ImageData*>::iterator i = buffers_.begin();
    while (i != buffers_.end()) {
      pp::Size buffer_size = (*i)->size();
      if (buffer_size.width() < clip_area_.width() ||
          buffer_size.height() < clip_area_.height()) {
        consumer_->ReturnBuffer(*i);
        i = buffers_.erase(i);
      } else {
        ++i;
      }
    }

    SchedulePaint();
  }
}

}  // namespace remoting


text:
package v1

import (
	v1 "github.com/openshift/origin/pkg/template/api/v1"
	api "k8s.io/kubernetes/pkg/api"
	watch "k8s.io/kubernetes/pkg/watch"
)

// TemplatesGetter has a method to return a TemplateInterface.
// A group's client should implement this interface.
type TemplatesGetter interface {
	Templates(namespace string) TemplateInterface
}

// TemplateInterface has methods to work with Template resources.
type TemplateInterface interface {
	Create(*v1.Template) (*v1.Template, error)
	Update(*v1.Template) (*v1.Template, error)
	Delete(name string, options *api.DeleteOptions) error
	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
	Get(name string) (*v1.Template, error)
	List(opts api.ListOptions) (*v1.TemplateList, error)
	Watch(opts api.ListOptions) (watch.Interface, error)
	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Template, err error)
	TemplateExpansion
}

// templates implements TemplateInterface
type templates struct {
	client *CoreClient
	ns     string
}

// newTemplates returns a Templates
func newTemplates(c *CoreClient, namespace string) *templates {
	return &templates{
		client: c,
		ns:     namespace,
	}
}

// Create takes the representation of a template and creates it.  Returns the server's representation of the template, and an error, if there is any.
func (c *templates) Create(template *v1.Template) (result *v1.Template, err error) {
	result = &v1.Template{}
	err = c.client.Post().
		Namespace(c.ns).
		Resource("templates").
		Body(template).
		Do().
		Into(result)
	return
}

// Update takes the representation of a template and updates it. Returns the server's representation of the template, and an error, if there is any.
func (c *templates) Update(template *v1.Template) (result *v1.Template, err error) {
	result = &v1.Template{}
	err = c.client.Put().
		Namespace(c.ns).
		Resource("templates").
		Name(template.Name).
		Body(template).
		Do().
		Into(result)
	return
}

// Delete takes name of the template and deletes it. Returns an error if one occurs.
func (c *templates) Delete(name string, options *api.DeleteOptions) error {
	return c.client.Delete().
		Namespace(c.ns).
		Resource("templates").
		Name(name).
		Body(options).
		Do().
		Error()
}

// DeleteCollection deletes a collection of objects.
func (c *templates) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
	return c.client.Delete().
		Namespace(c.ns).
		Resource("templates").
		VersionedParams(&listOptions, api.ParameterCodec).
		Body(options).
		Do().
		Error()
}

// Get takes name of the template, and returns the corresponding template object, and an error if there is any.
func (c *templates) Get(name string) (result *v1.Template, err error) {
	result = &v1.Template{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("templates").
		Name(name).
		Do().
		Into(result)
	return
}

// List takes label and field selectors, and returns the list of Templates that match those selectors.
func (c *templates) List(opts api.ListOptions) (result *v1.TemplateList, err error) {
	result = &v1.TemplateList{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("templates").
		VersionedParams(&opts, api.ParameterCodec).
		Do().
		Into(result)
	return
}

// Watch returns a watch.Interface that watches the requested templates.
func (c *templates) Watch(opts api.ListOptions) (watch.Interface, error) {
	return c.client.Get().
		Prefix("watch").
		Namespace(c.ns).
		Resource("templates").
		VersionedParams(&opts, api.ParameterCodec).
		Watch()
}

// Patch applies the patch and returns the patched template.
func (c *templates) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Template, err error) {
	result = &v1.Template{}
	err = c.client.Patch(pt).
		Namespace(c.ns).
		Resource("templates").
		SubResource(subresources...).
		Name(name).
		Body(data).
		Do().
		Into(result)
	return
}


text:
class NewsController < ApplicationController

  skip_filter :store_location, :only => [:index, :delete_icon]
  before_filter :login_required, :only => [:delete_icon]

  def index
    respond_to do |format|
      format.html { render }
    end
  end

  def delete_icon
    respond_to do |format|
      news = NewsItem.find_by_url_key(params[:id])
      news.update_attribute :icon, nil
      format.js { render(:update){|page| page.visual_effect :fade, 'avatar_edit'}}
    end
  end

end


text:
int main(int argc, const char* argv[])
{
    std::cout << "Solid v" << NEDOKTEC_SOLID_VERSION << std::endl;
    return 0;
}


text:
/** Helpers + Messaging for background page */

/**
 * Save the domain to the given list
 * Save flag can be;
 * domain - run on entire domain
 * nohome - run on all pages in domain except homepage
 * deleted - do not run on domain
 */
async function saveChangeToList(listName, siteUrl, saveFlag = 'domain') {
  var domain = getDomain(siteUrl);
  if (['deleted', 'domain', 'nohome'].indexOf(saveFlag) < 0) throw 'Invalid save flag';

  // Update local cache (in window, not chrome.sync)
  var list = window.gmState[listName];
  list[domain] = saveFlag;

  //Update persistent storage
  const items = await browser.storage.local.get({ [listName]: {} });
  let currList = items[listName];
  currList[domain] = saveFlag;
  await browser.storage.local.set({ [listName]: currList });
}

async function isOnList(listName, url) {
  const domain = getDomain(url);
  const items = await browser.storage.local.get({ [listName]: {} });
  return isActiveDomain(items[listName][domain]);
}

function updateGMState(updateData) {
  Object.keys(updateData).forEach(key => window.gmState[key] = updateData[key]);
}

/*-------------- Messaging ----------------*/

browser.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  // console.log('at runtime message', msg, sender);
  switch (msg.action) {
  case 'getGMState': {
    sendResponse(window.gmState);  // sendResponse tells browser to return promise
    break;
  }
  case 'updateGMState': {
    updateGMState(msg.data);
    sendResponse();
    break;
  }
  case 'runGMInternal': {
    runGMInternal().then(() => {
      sendResponse();
    });
    break;
  }
  case 'saveChangeToList': {
    const {listName, siteUrl, saveFlag = 'domain'} = msg.data;
    saveChangeToList(listName, siteUrl, saveFlag).then(() => {
      sendResponse();
    });
    break;
  }
  case 'isOnList': {
    const {listName, url} = msg.data;
    // For async function calls, return a promise
    return isOnList(listName, url).then(r => {
      return r;
    });
  }
  }

});