text:
<eml xmlns:ns0="eml://ecoinformatics.org/eml-2.1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" packageId="knb-lter-europe-deims.13170.13464" system="knb-lter-europe-deims" xsi:schemaLocation="eml://ecoinformatics.org/eml-2.1.1 https://code.ecoinformatics.org/code/eml/tags/RELEASE_EML_2_1_1/eml.xsd">

<access authSystem="knb" order="allowFirst" scope="document">
  <allow>
  <principal>uid=Hungary,o=LTER-Europe,dc=ecoinformatics,dc=org</principal>
  <permission>all</permission>
</allow>
  <allow>
    <principal>public</principal>
    <permission>read</permission>
  </allow>
</access>
<dataset id="knb-lter-europe-deims.13170.13464" system="knb-lter-europe-deims">
<alternateIdentifier>008fcfa6-9300-11e2-b534-005056ab003f</alternateIdentifier>
<title>Sikfokut LTER (Hungary) - precipitation chemistry 2012 - EnvEurope A5</title>
<creator>
<individualName>
<givenName>Ilona</givenName>
<surName>Meszaros</surName>
</individualName>
<organizationName>aaa LTER</organizationName>
<electronicMailAddress>immeszaros@unideb.hu</electronicMailAddress>
</creator>
<creator>
<individualName>
<givenName>Viktor</givenName>
<surName>Oláh</surName>
</individualName>
<organizationName>University of Debrecen, Faculty of Science and Technology, Dpt. Botany</organizationName>
<address>
<deliveryPoint>Egyetem tér 1.</deliveryPoint>
<city>Debrecen</city>
<country>Hungary</country>
</address>
<electronicMailAddress>olahviktor@gmail.com</electronicMailAddress>
</creator>
<metadataProvider>
<individualName>
<givenName>Ilona</givenName>
<surName>Meszaros</surName>
</individualName>
<organizationName>aaa LTER</organizationName>
<electronicMailAddress>immeszaros@unideb.hu</electronicMailAddress>
</metadataProvider>
<metadataProvider>
<individualName>
<givenName>Viktor</givenName>
<surName>Oláh</surName>
</individualName>
<organizationName>University of Debrecen, Faculty of Science and Technology, Dpt. Botany</organizationName>
<address>
<deliveryPoint>Egyetem tér 1.</deliveryPoint>
<city>Debrecen</city>
<country>Hungary</country>
</address>
<electronicMailAddress>olahviktor@gmail.com</electronicMailAddress>
</metadataProvider>
<pubDate>2013-03-12</pubDate>
<language>eng</language><abstract>

<para>This dataset provides information on above canopy and throughfall precipitation chemistry in SIkfokut LTER site in 2012.</para>

</abstract>
<keywordSet>
<keyword>LTER Site</keyword>
<keyword>ph</keyword>
<keyword>chemical  characteristics</keyword>
<keyword>throughfall</keyword>
<keyword>rain</keyword>
<keyword>rainfall chemical analysis</keyword>
<keywordThesaurus>EnvEurope Thesaurus;2012-08-13;version 3.0;http://vocabs.lter-europe.net/EnvThes3.html</keywordThesaurus>
</keywordSet>
<additionalInfo>

<title>Metadata date</title>
<para>2013-03-24 00:00:00</para>

<title>Dataset access and use constraints</title>
<para>Principal:EnvEurope (LTER-Europe) has granted a permission of type:Other restrictions according to rules defined in itellectual rights</para>

</additionalInfo>
<intellectualRights>

<para>Co-authorship on publications resulting from use of the dataset</para>

<para>The opportunity to collaborate on the project using the dataset</para>

</intellectualRights>
<distribution>
<online>
<url function="information">ftp://ftp.umweltbundesamt.at/KnownUsers/2253_2/EnvEurope_DataCollection/2012/</url>
</online>
</distribution>
<coverage>
<geographicCoverage>
<geographicDescription>
Sikfokut LTER</geographicDescription>
<boundingCoordinates>
<westBoundingCoordinate>20.44041</westBoundingCoordinate>
<eastBoundingCoordinate>20.45191</eastBoundingCoordinate>
<northBoundingCoordinate>47.93130</northBoundingCoordinate>
<southBoundingCoordinate>47.92445</southBoundingCoordinate>
<boundingAltitudes>
<altitudeMinimum>275</altitudeMinimum>
<altitudeMaximum>330</altitudeMaximum>
<altitudeUnits>meter</altitudeUnits>
</boundingAltitudes>
</boundingCoordinates>
</geographicCoverage>
<temporalCoverage>
<rangeOfDates>
<beginDate>
<calendarDate>2012-05-01</calendarDate>
</beginDate>
<endDate>
<calendarDate>2012-11-30</calendarDate>
</endDate>
</rangeOfDates>
</temporalCoverage>
</coverage>
<contact>
<individualName>
<givenName>Ilona</givenName>
<surName>Meszaros</surName>
</individualName>
<organizationName>aaa LTER</organizationName>
<electronicMailAddress>immeszaros@unideb.hu</electronicMailAddress>
</contact>
<contact>
<individualName>
<givenName>Viktor</givenName>
<surName>Oláh</surName>
</individualName>
<organizationName>University of Debrecen, Faculty of Science and Technology, Dpt. Botany</organizationName>
<address>
<deliveryPoint>Egyetem tér 1.</deliveryPoint>
<city>Debrecen</city>
<country>Hungary</country>
</address>
<electronicMailAddress>olahviktor@gmail.com</electronicMailAddress>
</contact>
<methods>
<methodStep>
<description>

<para>
<literalLayout>Precipitation was collected over longer periods (~monthly) using rainfall collectors and bulk samplers. Chemistry (pH, EC, chemical composition) of samples was analyzed in laboratory with standard methods (Analab Kft. www.analab.hu)
</literalLayout>
</para>

</description>
<instrumentation>Precipitation collectors: 1 above-canopy (25m) and 7 throughfall collector (1.2 m) with 0.2 m2 collecting area. Bulk samplers (25 l). Standard water chemistry analysis methods.</instrumentation>
</methodStep>
<sampling>
<studyExtent>
<description>

<para>Bulk samples were collected 6 times during 2012, covering the vegetation period from May to November. The over-canopy collector was set on the top of the site's own meteorological tower. Below-canopy collectors were randomly distributed in the 'B' subplot (50x50m) of the permanent 1 ha plot of the site. Results of all sampling dates were averaged on the basis of collectors' position (over- or below-canopy).</para>

</description>
</studyExtent>
<samplingDescription>monthly</samplingDescription>
</sampling>
</methods>
</dataset>
</eml>


text:
<?php

namespace app\modules\admin\controllers\vip;

use Yii;
use app\models\b2b2c\VipExtend;
use app\models\b2b2c\search\VipExtendSearch;
use app\modules\admin\common\controllers\BaseAuthController;
use yii\web\NotFoundHttpException;
use yii\filters\VerbFilter;
use app\common\utils\MsgUtils;

/**
 * VipExtendController implements the CRUD actions for VipExtend model.
 */
class VipExtendController extends BaseAuthController
{
    /**
     * @inheritdoc
     */
     /*
    public function behaviors()
    {
        return [
            'verbs' => [
                'class' => VerbFilter::className(),
                'actions' => [
                    'delete' => ['POST'],
                ],
            ],
        ];
    }
    */

    /**
     * Lists all VipExtend models.
     * @return mixed
     */
    public function actionIndex()
    {
        $searchModel = new VipExtendSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);

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

    /**
     * Displays a single VipExtend model.
     * @param string $id
     * @return mixed
     */
    public function actionView($id)
    {
        return $this->render('view', [
            'model' => $this->findModel($id),
        ]);
    }

    /**
     * Creates a new VipExtend model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreate()
    {
        $model = new VipExtend();

        if ($model->load(Yii::$app->request->post()) && $model->save()) {
            MsgUtils::success();
            return $this->redirect(['view', 'id' => $model->id]);
        } else {
            return $this->render('create', [
                'model' => $model,
            ]);
        }
    }

    /**
     * Updates an existing VipExtend model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param string $id
     * @return mixed
     */
    public function actionUpdate($id)
    {
        $model = $this->findModel($id);

        if ($model->load(Yii::$app->request->post()) && $model->save()) {
        	MsgUtils::success();
            return $this->redirect(['view', 'id' => $model->id]);
        } else {
            return $this->render('update', [
                'model' => $model,
            ]);
        }
    }

    /**
     * Deletes an existing VipExtend model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param string $id
     * @return mixed
     */
    public function actionDelete($id)
    {
        $this->findModel($id)->delete();
		MsgUtils::success();
        return $this->redirect(['index']);
    }

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

redpajama_set_name: RedPajamaGithub


text:
<?php

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 * Description of user_model
 *
 * @author montolio
 */
class User_model extends CI_Model {

    //put your code here
    public function __construct() {
        parent::__construct();
    }

    /* Esta funcion ses utilizada para validar
      la existencia del usuario introducido en el
     * formulario user y es usada desde JS ajax */

    public function verifyUsername($username) {
        $this->db->where('username', $username);
        $consulta = $this->db->get('user');
        if ($consulta->num_rows() == 0):
            return 0;
        else:
            return 1;
        endif;
    }

    /* Esta funcion ses utilizada para validar
      la existencia del email introducido en el
      formulario user y es usada desde JS ajax */

    public function verifyUserEmail($userEmail) {
        $this->db->where('email', $userEmail);
        $consulta = $this->db->get('user');
        if ($consulta->num_rows() == 0):
            return 0;
        else:
            return 1;
        endif;
    }

    public function createUserModel($id_userSum,$name, $lastname, $username, $password, $email,$creation_date,$fec_actu) {
        $this->id_username =  $id_userSum;
        $this->username = $username;
        $this->password = $password;
        $this->name = $name;
        $this->last_name = $lastname;
        $this->email = $email;
        $this->creation_date = $creation_date;
        $this->fec_actu = $fec_actu;
        $this->mca_inh = 'N';
//        echo 'model '.$name.' '.$lastname.' '.$username.' '.$password.' '.$email;
        $this->db->insert('user', $this);
    }

    public function updateUserModel() {

    }

    public function deleteUserModel() {

    }

    public function consultUserModel() {

    }

}


text:
import { ITerminalAddon, IDisposable, Terminal } from 'xterm';

export interface ILoadedAddon {
  instance: ITerminalAddon;
  dispose: () => void;
  isDisposed: boolean;
}

export class AddonManager implements IDisposable {
  protected _addons: ILoadedAddon[] = [];

  constructor() {
  }

  public dispose(): void {
    for (let i = this._addons.length - 1; i >= 0; i--) {
      this._addons[i].instance.dispose();
    }
  }

  public loadAddon(terminal: Terminal, instance: ITerminalAddon): void {
    const loadedAddon: ILoadedAddon = {
      instance,
      dispose: instance.dispose,
      isDisposed: false
    };
    this._addons.push(loadedAddon);
    instance.dispose = () => this._wrappedAddonDispose(loadedAddon);
    instance.activate(terminal as any);
  }

  private _wrappedAddonDispose(loadedAddon: ILoadedAddon): void {
    if (loadedAddon.isDisposed) {
      // Do nothing if already disposed
      return;
    }
    let index = -1;
    for (let i = 0; i < this._addons.length; i++) {
      if (this._addons[i] === loadedAddon) {
        index = i;
        break;
      }
    }
    if (index === -1) {
      throw new Error('Could not dispose an addon that has not been loaded');
    }
    loadedAddon.isDisposed = true;
    loadedAddon.dispose.apply(loadedAddon.instance);
    this._addons.splice(index, 1);
  }
}


text:
"use strict";

var assert = require('chai').assert,
	nemo = require('nemo'),
	setup;

describe('Nemo ', function() {

	before(function(done) {
		(new nemo()).setup({}).
		then(function(result) {
			//console.log(result)
			setup = result;
			done();
		})
	});

	after(function(done) {
		setup.driver.quit().then(function() {
			done();
		});
	});

	it('should complete setup and load the base URL', function(done) {
		var driver = setup.driver;
			driver.get(setup.targetBaseUrl + '/login').
			then(function() {
				done()
			}, function(err) {
				done(err);
			});

	});

});


text:
package com.twitter.finatra

package object modules {
  @deprecated("Use com.twitter.finatra.http.modules.AccessLogModule", "")
  val AccessLogModule = com.twitter.finatra.http.modules.AccessLogModule

  @deprecated("Use com.twitter.finatra.http.modules.MustacheModule", "")
  val MustacheModule = com.twitter.finatra.http.modules.MustacheModule
}


text:
using System.Text.RegularExpressions;

namespace FluentDisplayProperties
{
    public static class StringExtensions
    {
        public static string ToSeparatedWords(this string value)
        {
            return value != null ? Regex.Replace(value, "([a-z](?=[A-Z0-9])|[A-Z](?=[A-Z][a-z]))", "$1 ").Trim() : null;
        }
    }
}


text:
#region Copyright © 2009 Stateside Technology Limited
//===============================================================================
// Location Based Services View
// Framework Services
//===============================================================================
// Copyright © Stateside Technology Limited.  All rights reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE.
//===============================================================================
#endregion

using System;
using System.Configuration;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LBSView.Framework.Common.Util.Notification
{
    public class NotificationSection : ConfigurationSection
    {
        [ConfigurationProperty("NotificationPages", IsDefaultCollection = false)]
        public NotificationPagesCollection Pages
        {
            get
            {
                NotificationPagesCollection pagesCollection = (NotificationPagesCollection)base["NotificationPages"];
                return pagesCollection;
            }
        }

        [ConfigurationProperty("NotificationLists", IsDefaultCollection = false)]
        public NotificationListCollection Lists
        {
            get
            {
                NotificationListCollection listCollection = (NotificationListCollection)base["NotificationLists"];
                return listCollection;
            }
        }

    }

}

#region Revision History
//
//******************************************************************************
//
// Revision Details
// ================
//
// $Author: Admin $
// $Header: /Release 1/Hydra/Core/Source/Framework/Common/Util/Notification/NotificationSection.cs 1     10/05/10 15:30 Admin $
// $Workfile: NotificationSection.cs $
// $Revision: 1 $
//
// $History: NotificationSection.cs $
//
//*****************  Version 1  *****************
//User: Admin        Date: 10/05/10   Time: 15:30
//Created in $/Release 1/Hydra/Core/Source/Framework/Common/Util/Notification
//
//*****************  Version 1  *****************
//User: Admin        Date: 23/03/10   Time: 22:25
//Created in $/Release 1/LBS/LBS/Framework/Common/Util/Notification
//
//*****************  Version 1  *****************
//User: Admin        Date: 31/12/09   Time: 0:09
//Created in $/Phase1/LBS/Framework/Common/Util/Notification
//
// $Log: /Release 1/Hydra/Core/Source/Framework/Common/Util/Notification/NotificationSection.cs $
//
//1     10/05/10 15:30 Admin
//
//1     23/03/10 22:25 Admin
//
//1     31/12/09 0:09 Admin
//
//******************************************************************************
//
#endregion


text: Changes the declaration visibility modifier to protected.


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Micromyc. Slavon. no. 31 (1884)

#### Original name
Diplodia grossulariae Sacc. & Schulzer

### Remarks
null


text:
package com.rtg.reader;

import java.io.File;
import java.util.zip.CRC32;

import com.rtg.mode.SequenceType;
import com.rtg.util.array.ExtensibleIndex;
import com.rtg.util.array.longindex.LongCreate;
import com.rtg.util.bytecompression.BitwiseByteArray;
import com.rtg.util.bytecompression.ByteBaseCompression;
import com.rtg.util.bytecompression.ByteCompression;
import com.rtg.util.bytecompression.CompressedByteArray;
import com.rtg.util.bytecompression.MultiByteArray;
import com.rtg.util.intervals.LongRange;

/**
 *
 */
public class CompressedMemorySequencesWriter extends AbstractSdfWriter {

  private Label mCurrentLabel;
  private final BitwiseByteArray mSeqData;
  private ByteCompression mQualData;
  //MultiByteArray is used here because it supports extending
  private final CRC32 mChecksumSeq;
  private CRC32 mChecksumQual;
  private final MultiByteArray mSeqChecksums;
  private MultiByteArray mQualChecksums;
  private final ExtensibleIndex mPositions;

  private int mCurrentLength;
  private long mCurrentPosition;

  private final SimpleNames mNames;
  private final SimpleNames mNameSuffixes;
  private boolean mHasData;
  private final boolean mWriteFullNames;

  private long mCurrentId;

  private CompressedMemorySequencesReader mReader;

  private final LongRange mOriginalRegion;
  private final LongRange mRestriction;
  private final File mOriginPath;

  /**
   *
   * @param originPath file/directory that is the source of this data
   * @param prereadType type of the data that is being written
   * @param hasQuality type of the data that is being written
   * @param names holder of names
   * @param suffixes holder of name suffixes
   * @param compressed whether SDF should be compressed
   * @param type preread type
   * @param restriction restrict reader to given range of reads
   */
  public CompressedMemorySequencesWriter(File originPath, PrereadType prereadType, boolean hasQuality, SimpleNames names, SimpleNames suffixes, boolean compressed, SequenceType type, LongRange restriction) {
    super(prereadType, hasQuality, names != null, compressed, type);
    setSdfId(new SdfId(0)); //we don't know the provenance of the reads
    final int range = type.numberKnownCodes() + type.firstValid();
    mOriginPath = originPath;
    mSeqData = new BitwiseByteArray(CompressedByteArray.minBits(range));
    mSeqChecksums = new MultiByteArray(0, 20);
    mChecksumSeq = new CRC32();
    mWriteFullNames = suffixes != null;
    if (mHasQuality) {
//      if (Boolean.getBoolean(System.getProperty("com.rtg.qual_compression", "false"))) {
//        mQualData = new ArithByteCompression(CompressedMemorySequencesReader.MAX_QUAL_VALUE, 10000, new Order0ModelBuilder(CompressedMemorySequencesReader.MAX_QUAL_VALUE));
//      } else {
      mQualData = new ByteBaseCompression(CompressedMemorySequencesReader.MAX_QUAL_VALUE);
//      }
      mQualChecksums = new MultiByteArray(0, 20);
      mChecksumQual = new CRC32();
    }
    mNames = names;
    mNameSuffixes = suffixes;

    mPositions = LongCreate.createExtensibleIndex();
    setPosition(0, 0);
    mReader = null;
    final long start;
    final long end;
    if (restriction.getStart() == -1) {
      start = 0;
    } else {
      start = restriction.getStart();
    }
    if (restriction.getEnd() == -1) {
      end = Long.MAX_VALUE;
    } else {
      end = restriction.getEnd();
    }
    mRestriction = new LongRange(start, end);
    mOriginalRegion = restriction;
  }

  @Override
  long getNumberOfSequences() {
    return mCurrentId;
  }

  /**
   * Get the in memory reader after processing is complete
   * @return the reader
   */
  public CompressedMemorySequencesReader getReader() {
    if (mReader == null) {
      throw new IllegalStateException("Close has not been called");
    }
    return mReader;
  }

  @Override
  public void close() {
    final IndexFile index = super.finish(0, mCurrentId);
    // create a new region to avoid IAE in CompressedMemorySequencesReader when total number of sequences is not known up front (ie fastq input).
    final LongRange region = SequencesReaderFactory.resolveRange(index, mOriginalRegion);
    mReader = new CompressedMemorySequencesReader(mOriginPath, index, mSeqData, mQualData, mSeqChecksums, mQualChecksums, mPositions, mNames, mNameSuffixes, region);
  }

  private void setPosition(long index, long position) {
    if (index >= mPositions.length()) {
      final long pos = mPositions.extendBy(1);
      assert  pos == index : "pos: " + pos + " index: " + index;
    }
    mPositions.set(index, position);
  }

  @Override
  public void startSequence(String label) {
    initSequenceStatistics();
    if (mHasNames && mRestriction.contains(mCurrentId)) {
      mCurrentLabel = handleSequenceName(label);
    }
    mHasData = false;
    mCurrentLength = 0;
    mChecksumSeq.reset();
    if (mHasQuality) {
      mChecksumQual.reset();
    }
  }

  @Override
  public void write(byte[] rs, byte[] qs, int length) {
    mHasData = true;
    if (length == 0) {
      noSequenceWarning(mCurrentLabel);
    }
    if (mRestriction.contains(mCurrentId)) {
      mSeqData.set(mCurrentPosition, rs, length);
      mDataHashFunction.irvineHash(rs, length);
      mChecksumSeq.update(rs, 0, length);
      if (mHasQuality) {
        clipQuality(qs, length);
        mQualData.add(qs, 0, length); // This only works if this method gets one sequence at a time
        mQualityHashFunction.irvineHash(qs, length);
        mChecksumQual.update(qs, 0, length);
      }
      mCurrentPosition += length;
    }
    mCurrentLength += length;
    updateCountStatistics(rs, qs, length);
  }

  @Override
  public boolean endSequence() {
    endSequenceStatistics();
    if (mHasData) {
      if (mRestriction.contains(mCurrentId)) {
        if (mHasNames) {
          mNames.setName(mCurrentId - mRestriction.getStart(), mCurrentLabel.label());
          if (mWriteFullNames) {
            mNameSuffixes.setName(mCurrentId - mRestriction.getStart(), mCurrentLabel.suffix());
          }
        }
        setPosition(mCurrentId - mRestriction.getStart() + 1, mCurrentPosition);
        if (mCurrentLength > 0) {
          mDataHashFunction.irvineHash(mCurrentLength);
          if (mHasQuality) {
            mQualityHashFunction.irvineHash(mCurrentLength);
          }
        }
        updateChecksums();
      }
      updateStatistics(mCurrentLength);
      ++mCurrentId;
      return true;
    } else {
      return false;
    }
  }

  private void updateChecksums() {
    mSeqChecksums.extendTo(mCurrentId - mRestriction.getStart() + 1);
    mSeqChecksums.set(mCurrentId - mRestriction.getStart(), (byte) mChecksumSeq.getValue());
    if (mHasQuality) {
      mQualChecksums.extendTo(mCurrentId - mRestriction.getStart() + 1);
      mQualChecksums.set(mCurrentId - mRestriction.getStart(), (byte) mChecksumQual.getValue());
    }
  }
}


text:
package org.apache.giraph.graph;

/**
 * A dumb implementation of {@link WorkerContext}. This is the default
 * implementation when no WorkerContext is defined by the user. It does
 * nothing.
 */
public class DefaultWorkerContext extends WorkerContext {

  @Override
  public void preApplication()
    throws InstantiationException, IllegalAccessException {
  }

  @Override
  public void postApplication() { }

  @Override
  public void preSuperstep() { }

  @Override
  public void postSuperstep() { }
}


text:
package org.apache.axis2.wsdl.codegen;

import java.util.ArrayList;
import java.util.List;

import org.apache.axis2.description.AxisService;
import org.apache.axis2.wsdl.codegen.XMLSchemaTest;
import org.apache.ws.commons.schema.XmlSchema;
import org.junit.Test;

public class CodeGenConfigurationTest extends XMLSchemaTest{

    protected AxisService service;
    private ArrayList<XmlSchema> schemas;

    @Override
    protected void setUp() throws Exception {
        service = new AxisService();
        schemas = new ArrayList<XmlSchema>();
        loadSampleSchemaFile(schemas);
        service.addSchema(schemas);
        super.setUp();
    }

    @Override
    protected void tearDown() throws Exception {
        service=null;
        schemas=null;

        super.tearDown();
    }

    @Test
    public void testGetSchemaListForAllServices(){
        CodeGenConfiguration configuration = new CodeGenConfiguration();
        configuration.addAxisService(service);
        List<XmlSchema> list=configuration.getSchemaListForAllServices();
        assertEquals(schemas.get(0), list.get(0));
    }

}


text:
import { expect } from 'chai';

import { numberIsFinite, getTickDecimals, getFractionDigits, round, getDevelopmentPercentage } from '../src/utils';

describe('utils', () => {
  describe('numberIsFinite', () => {
    it('should be a function', () => {
      expect(numberIsFinite).to.be.a('function');
    });

    it('should return false for Infinity', () => {
      expect(numberIsFinite(Infinity)).to.equal(false);
    });

    it('should return false for NaN', () => {
      expect(numberIsFinite(NaN)).to.equal(false);
    });

    it('should return false for -Infinity', () => {
      expect(numberIsFinite(-Infinity)).to.equal(false);
    });

    it('should return false for "0"', () => {
      expect(numberIsFinite('0')).to.equal(false);
    });

    it('should return false for null', () => {
      expect(numberIsFinite(null)).to.equal(false);
    });

    it('should return true for 0', () => {
      expect(numberIsFinite(0)).to.equal(true);
    });

    it('should return true for 2e64', () => {
      expect(numberIsFinite(2e64)).to.equal(true);
    });
  });

  describe('getTickDecimals', () => {
    const ticks = [
      {
        decimals: 1,
        tick: 0.5,
        to_price: 999.5,
        from_price: 500,
      },
      {
        decimals: 3,
        tick: 0.001,
        to_price: 1.999,
        from_price: 1,
      },
      {
        decimals: 3,
        tick: 0.002,
        to_price: 4.998,
        from_price: 2,
      },
      {
        decimals: 4,
        tick: 0.0001,
        to_price: 0.4999,
        from_price: 0,
      },
    ];

    it('should be a function', () => {
      expect(getTickDecimals).to.be.a('function');
    });

    it('should return undefined when value is not defined', () => {
      expect(getTickDecimals(null, ticks)).to.equal(undefined);
    });

    it('should return undefined when ticks is not defined', () => {
      expect(getTickDecimals(1)).to.equal(undefined);
    });

    it('should return undefined when there is matching tick for value', () => {
      expect(getTickDecimals(50, ticks)).to.equal(undefined);
    });

    it('should return 1 when value is between 500 and 1000', () => {
      expect(getTickDecimals(750, ticks)).to.equal(1);
    });

    it('should return 3 when value is between 1 and 2', () => {
      expect(getTickDecimals(1.4, ticks)).to.equal(3);
    });

    it('should return 4 when value is between 0 and 0.5', () => {
      expect(getTickDecimals(0.4, ticks)).to.equal(4);
    });

    it('should work even though `tick` is not defined', () => {
      const modifiedTicks = [...ticks].map(t => ({
        decimals: t.decimals,
        to_price: t.to_price,
        from_price: t.from_price,
      }));
      expect(getTickDecimals(1.4, modifiedTicks)).to.equal(3);
    });
  });

  describe('getFractionDigits', () => {
    it('should be a function', () => {
      expect(getFractionDigits).to.be.a('function');
    });

    it('should return first argument if it is a number', () => {
      const args = [1, '4', null, NaN];
      expect(getFractionDigits(...args)).to.equal(args[0]);
    });

    it('should return undefined when nothing matches', () => {
      const args = ['4', null, NaN];
      expect(getFractionDigits(...args)).to.equal(undefined);
    });

    it('should return second argument when first argument is not a number', () => {
      const args = [null, 2];
      expect(getFractionDigits(...args)).to.equal(args[1]);
    });
  });

  describe('round', () => {
    it('should be a function', () => {
      expect(round).to.be.a('function');
    });
    it('should return value if decimals is not a number', () => {
      expect(round(1.01)).to.equal(1.01);
      expect(round(1.01, '')).to.equal(1.01);
      expect(round(1.01, '1')).to.equal(1.01);
    });
    it('should correctly round to `decimals` number of decimals', () => {
      expect(round(1.01)).to.equal(1.01);
      expect(round(1.01, 2)).to.equal(1.01);
      expect(round(1.01, 1)).to.equal(1.0);
      expect(round(1.09, 1)).to.equal(1.1);
      expect(round(1.005, 2)).to.equal(1.01);
    });
  });

  describe('getDevelopmentPercentage', () => {
    it('should be a function', () => {
      expect(getDevelopmentPercentage).to.be.a('function');
    });
    it('should return 0 if one of the arguments is not a number', () => {
      expect(getDevelopmentPercentage()).to.equal(0);
      expect(getDevelopmentPercentage(0)).to.equal(0);
      expect(getDevelopmentPercentage(0, '0')).to.equal(0);
    });
    it('should return the percentual development between the parameters', () => {
      expect(getDevelopmentPercentage(1, 1)).to.equal(0);
      expect(getDevelopmentPercentage(1, 2)).to.equal(100);
      expect(getDevelopmentPercentage(2, 1)).to.equal(-50);
    });
  });
});


text:
package org.knowm.xchange.empoex;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.knowm.xchange.currency.Currency;
import org.knowm.xchange.currency.CurrencyPair;
import org.knowm.xchange.dto.Order.OrderType;
import org.knowm.xchange.dto.account.Balance;
import org.knowm.xchange.dto.account.Wallet;
import org.knowm.xchange.dto.marketdata.OrderBook;
import org.knowm.xchange.dto.marketdata.Ticker;
import org.knowm.xchange.dto.marketdata.Trade;
import org.knowm.xchange.dto.marketdata.Trades;
import org.knowm.xchange.dto.marketdata.Trades.TradeSortType;
import org.knowm.xchange.dto.trade.LimitOrder;
import org.knowm.xchange.dto.trade.OpenOrders;
import org.knowm.xchange.empoex.dto.account.EmpoExBalance;
import org.knowm.xchange.empoex.dto.marketdata.EmpoExLevel;
import org.knowm.xchange.empoex.dto.marketdata.EmpoExTicker;
import org.knowm.xchange.empoex.dto.marketdata.EmpoExTrade;
import org.knowm.xchange.empoex.dto.trade.EmpoExOpenOrder;

public final class EmpoExAdapters {

  public static Ticker adaptEmpoExTicker(EmpoExTicker raw) {

    CurrencyPair currencyPair = EmpoExUtils.toCurrencyPair(raw.getPairname());
    BigDecimal last = new BigDecimal(raw.getLast().replace(",", ""));
    BigDecimal high = new BigDecimal(raw.getHigh().replace(",", ""));
    BigDecimal low = new BigDecimal(raw.getLow().replace(",", ""));
    BigDecimal bid = new BigDecimal(raw.getBid().replace(",", ""));
    BigDecimal ask = new BigDecimal(raw.getAsk().replace(",", ""));
    BigDecimal counterVolume = new BigDecimal(raw.getBaseVolume24hr().replace(",", ""));
    BigDecimal volume = counterVolume.divide(last, new MathContext(8, RoundingMode.HALF_UP));

    return new Ticker.Builder().currencyPair(currencyPair).last(last).high(high).low(low).bid(bid).ask(ask).volume(volume).build();
  }

  public static Trades adaptEmpoExTrades(List<EmpoExTrade> raw, CurrencyPair currencyPair) {

    List<Trade> trades = new ArrayList<Trade>();

    for (EmpoExTrade trade : raw) {

      OrderType type = trade.getType().equalsIgnoreCase("buy") ? OrderType.BID : OrderType.ASK;
      Date date = EmpoExUtils.toDate(trade.getDate());
      BigDecimal amount = new BigDecimal(trade.getAmount().replace(",", ""));
      BigDecimal price = new BigDecimal(trade.getPrice().replace(",", ""));

      trades.add(new Trade.Builder().currencyPair(currencyPair).price(price).tradableAmount(amount).timestamp(date).type(type).build());
    }

    return new Trades(trades, TradeSortType.SortByTimestamp);
  }

  public static OrderBook adaptEmpoExDepth(Map<String, List<EmpoExLevel>> raw, CurrencyPair currencyPair) {

    List<EmpoExLevel> rawAsks = raw.get("sell");
    List<EmpoExLevel> rawBids = raw.get("buy");

    List<LimitOrder> asks = new ArrayList<LimitOrder>();
    List<LimitOrder> bids = new ArrayList<LimitOrder>();

    for (EmpoExLevel ask : rawAsks) {

      BigDecimal amount = new BigDecimal(ask.getAmount().replace(",", ""));
      BigDecimal price = new BigDecimal(ask.getPrice().replace(",", ""));
      asks.add(new LimitOrder.Builder(OrderType.ASK, currencyPair).tradableAmount(amount).limitPrice(price).build());
    }

    for (EmpoExLevel bid : rawBids) {

      BigDecimal amount = new BigDecimal(bid.getAmount().replace(",", ""));
      BigDecimal price = new BigDecimal(bid.getPrice().replace(",", ""));
      bids.add(new LimitOrder.Builder(OrderType.BID, currencyPair).tradableAmount(amount).limitPrice(price).build());
    }

    return new OrderBook(null, asks, bids);
  }

  public static Wallet adaptBalances(List<EmpoExBalance> raw) {

    List<Balance> balances = new ArrayList<Balance>();

    for (EmpoExBalance empoExBalance : raw) {

      BigDecimal balance = new BigDecimal(empoExBalance.getAmount().replace(",", ""));
      balances.add(new Balance(Currency.getInstance(empoExBalance.getCoin().toUpperCase()), balance));
    }

    return new Wallet(null, balances);
  }

  public static OpenOrders adaptOpenOrders(Map<String, List<EmpoExOpenOrder>> raw) {

    List<LimitOrder> openOrders = new ArrayList<LimitOrder>();

    for (String pairString : raw.keySet()) {

      CurrencyPair currencyPair = EmpoExUtils.toCurrencyPair(pairString);
      List<EmpoExOpenOrder> pairOrders = raw.get(pairString);

      for (EmpoExOpenOrder order : pairOrders) {

        openOrders.add(adaptOpenOrder(order, currencyPair));
      }
    }

    return new OpenOrders(openOrders);
  }

  public static LimitOrder adaptOpenOrder(EmpoExOpenOrder raw, CurrencyPair currencyPair) {

    String orderId = raw.getOrderId();
    BigDecimal amount = new BigDecimal(raw.getAmountRemaining().replace(",", ""));
    BigDecimal price = new BigDecimal(raw.getValue().replace(",", ""));
    OrderType type = raw.getType().equalsIgnoreCase("buy") ? OrderType.BID : OrderType.ASK;

    return new LimitOrder.Builder(type, currencyPair).id(orderId).tradableAmount(amount).limitPrice(price).build();
  }

}


text:
from django.db import models
from django.db.models import F

from qmpy.materials.element import Element
from qmpy.data import elements
from qmpy.utils import *
import qmpy.analysis.thermodynamics as thermo

class Composition(models.Model):
    """
    Base class for a composition.

    Relationships:
        | :mod:`~qmpy.Calculation` via calculation_set
        | :mod:`~qmpy.Element` via element_set
        | :mod:`~qmpy.Entry` via entry_set
        | :mod:`~qmpy.ExptFormationEnergy` via exptformationenergy_set
        | :mod:`~qmpy.FormationEnergy` via formationenergy_set
        | :mod:`~qmpy.MetaData` via meta_data
        | :mod:`~qmpy.Structure` via structure_set
        | :mod:`~qmpy.Prototype` via prototype_set

    Attributes:
        | formula: Electronegativity sorted and normalized composition string.
        |   e.g. Fe2O3, LiFeO2
        | generic: Genericized composition string. e.g. A2B3, ABC2.
        | mass: Mass per atom in AMUs
        | meidema: Meidema model energy for the composition
        | ntypes: Number of elements.

    """

    formula = models.CharField(primary_key=True, max_length=255)
    generic = models.CharField(max_length=255, blank=True, null=True)
    element_list = models.CharField(max_length=255, blank=True, null=True)
    meta_data = models.ManyToManyField("MetaData")

    element_set = models.ManyToManyField("Element", blank=True)
    ntypes = models.IntegerField(null=True)

    ### other stuff
    mass = models.FloatField(blank=True, null=True)

    ### thermodyanamic stuff
    meidema = models.FloatField(blank=True, null=True)
    structure = models.ForeignKey(
        "Structure", blank=True, on_delete=models.SET_NULL, null=True, related_name="+"
    )

    _unique = None
    _duplicates = None

    class Meta:
        app_label = "qmpy"
        db_table = "compositions"

    def __str__(self):
        return self.name

    def __eq__(self, other):
        return self.compare(other)

    def compare(self, other, tol=1e-3):
        if self.space != other.space:
            return False
        for k in self.space:
            if abs(self.unit_comp[k] - other.unit_comp[k]) > tol:
                return False
        return True

    @classmethod
    def get(cls, composition):
        """
        Classmethod for getting Composition objects - if the Composition
        existsin the database, it is returned. If not, a new Composition is
        created.

        Examples::

            >>> Composition.get('Fe2O3')
            <Composition: Fe2O3>

        """
        if isinstance(composition, str):
            composition = parse_comp(composition)
        comp = reduce_comp(composition)
        f = " ".join(["%s%g" % (k, comp[k]) for k in sorted(comp.keys())])
        comps = cls.objects.filter(formula=f)
        if comps.exists():
            return comps[0]
        else:
            comp = Composition(formula=f)
            comp.ntypes = len(comp.comp)
            comp.generic = format_generic_comp(comp.comp)
            comp.element_list = "_".join(list(comp.comp.keys())) + "_"
            comp.save()
            comp.element_set.set(list(comp.comp.keys()))
            return comp

    @classmethod
    def get_list(cls, bounds, calculated=False, uncalculated=False):
        """
        Classmethod for finding all compositions within the space bounded by a
        sequence of compositions.

        Examples::

            >>> from pprint import pprint
            >>> comps = Composition.get_list(['Fe','O'], calculated=True)
            >>> pprint(list(comps))
            [<Composition: Fe>,
             <Composition: FeO>,
             <Composition: FeO3>,
             <Composition: Fe2O3>,
             <Composition: Fe3O4>,
             <Composition: Fe4O5>,
             <Composition: O>]

        """
        space = set()
        if isinstance(bounds, str):
            bounds = bounds.split("-")
        if len(bounds) == 1:
            return [Composition.get(bounds[0])]
        for b in bounds:
            bound = parse_comp(b)
            space |= set(bound.keys())
        in_elts = Element.objects.filter(symbol__in=space)
        out_elts = Element.objects.exclude(symbol__in=space)
        comps = Composition.objects.filter(
            element_set__in=in_elts, ntypes__lte=len(space)
        )
        comps = Composition.objects.exclude(element_set__in=out_elts)
        comps = comps.exclude(entry=None)
        if calculated:
            comps = comps.exclude(formationenergy=None)
        if uncalculated:
            comps = comps.filter(formationenergy=None)
        return comps.distinct()

    @property
    def entries(self):
        entries = self.entry_set.filter(id=F("duplicate_of__id"))
        if not entries.exists():
            return []
        return sorted(entries, key=lambda x: 100 if x.energy is None else x.energy)

    @property
    def ground_state(self):
        """Return the most stable entry at the composition."""
        e = self.entries
        if not e:
            return None
        return self.entries[0]

    _elements = None

    @property
    def elements(self):
        if self._elements is None:
            self._elements = list(self.element_set.all())
        return self._elements

    @elements.setter
    def elements(self, elements):
        self.element_set.set(elements)
        self._elements = None

    @property
    def total_energy(self):
        calcs = self.calculation_set.filter(converged=True, label="static")
        if not calcs.exists():
            calcs = self.calculation_set.filter(converged=True, label="standard")
            if not calcs.exists():
                return
        return min(c.energy_pa for c in calcs)

    @property
    def energy(self):
        calcs = self.calculation_set.filter(
            converged=True, label__in=["standard", "static"]
        )
        if not calcs.exists():
            return
        return min(c.formation_energy() for c in calcs)

    @property
    def delta_e(self):
        """Return the lowest formation energy."""
        formations = self.formationenergy_set.exclude(delta_e=None)
        formations = formations.filter(fit="standard")
        if not formations.exists():
            return
        return min(formations.values_list("delta_e", flat=True))

    @property
    def icsd_delta_e(self):
        """
        Return the lowest formation energy calculated from experimentally
        measured structures - i.e. excluding prototypes.
        """
        calcs = self.calculation_set.exclude(delta_e=None)
        calcs = calcs.filter(path__contains="icsd")
        if not calcs.exists():
            return
        return min(calcs.values_list("delta_e", flat=True))

    @property
    def ndistinct(self):
        """Return the number of distinct entries."""
        return len(self.entries)

    @property
    def comp(self):
        """Return an element:amount composition dictionary."""
        return parse_comp(self.formula)

    @property
    def unit_comp(self):
        """
        Return an element:amoutn composition dictionary normalized to a unit
        composition.
        """
        return unit_comp(self.comp)

    @property
    def name(self):
        return format_comp(reduce_comp(self.comp))

    @property
    def name_unreduced(self):
        return format_comp(self.comp)

    @property
    def latex(self):
        return format_latex(reduce_comp(self.comp))

    @property
    def html(self):
        return format_html(reduce_comp(self.comp))

    @property
    def space(self):
        """Return the set of element symbols"""
        return set(self.comp.keys())

    @property
    def experiment(self):
        """Return the lowest experimantally measured formation energy at the
        compositoin.
        """
        expts = self.exptformationenergy_set.filter(dft=False)
        if not expts.exists():
            return
        return min(expts.values_list("delta_e", flat=True))

    def relative_stability_plot(self, data=data):
        if not self.energy:
            return Renderer()

        if data:
            ps = thermo.PhaseSpace(self.name, data=data)
        else:
            ps = thermo.PhaseSpace(self.name)
        return ps.phase_diagram

    def get_mass(self):
        return sum([elements[k]["mass"] * v for k, v in list(self.unit_comp.items())])

    def get_similar(self):
        return Composition.objects.filter(generic=self.generic)

    def find_unique(self):
        unique = []
        # vih
        for e1 in self.entry_set.all():
            for i, e2 in enumerate(unique):
                if e1.structure == e2.structure:
                    ind = i
            else:
                unique.append(e1)
                continue

            exist = unique[ind]
            if e1.energy is None and e2.energy is None:
                e1.duplicate_of = exist.entry
            elif e2 is None:
                s1.entry.duplicate_of = exist.entry
            elif e1 is None:
                exist.entry.duplicate_of = s1.entry
                s1.entry.duplicate_of = None
                unique[ind] = s1
            elif e1 <= e2:
                s1.entry.duplicate_of = exist.entry
            else:
                exist.entry.duplicate_of = s1.entry
                s1.entry.duplicate_of = None
                unique[ind] = s1

        self.unique = dict([(s.entry, []) for s in unique])
        for s in inputs:
            if not s.entry.duplicate_of is None:
                self.unique[s.entry.duplicate_of].append(s.entry)


text:
package com.egangotri.menu;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;

import com.egangotri.transliteration.otherTransformations.RTFDocsSwingDisplayer;
import com.egangotri.util.CommonActions;
import com.egangotri.util.Project;

public class HelpMenu extends JMenu implements ActionListener
{
    JMenuItem        itransItem, aboutItem, notesItem, slpItem, hkItem, iastItem;

    Project project;

    public String aboutPro = "";

    public String jarFile;

    public HelpMenu(){
        this("", Project.SANDHI);
    }

    public HelpMenu(String aboutPro, Project proj){
        super("Help");
        this.aboutPro = aboutPro;
        this.project = proj;
        if(project.equals(Project.SANDHI)){
            jarFile = "sandhi.jar";
        }

        if(project.equals(Project.TRANSLITERATOR)){
            jarFile = "transliterator.jar";
        }

        aboutItem = new JMenuItem("About " + aboutPro);
        aboutItem.setActionCommand("about_item");
        aboutItem.addActionListener(this);

        itransItem = new JMenuItem("ITRANS Encoding Scheme");
        itransItem.setActionCommand("itrans_encoding");
        itransItem.addActionListener(this);

        slpItem = new JMenuItem("SLP Encoding Scheme");
        slpItem.setActionCommand("slp_encoding");
        slpItem.addActionListener(this);

        hkItem = new JMenuItem("HK Encoding Scheme");
        hkItem.setActionCommand("hk_encoding");
        hkItem.addActionListener(this);

        iastItem = new JMenuItem("IAST Encoding Scheme");
        iastItem.setActionCommand("iast_encoding");
        iastItem.addActionListener(this);

        notesItem = new JMenuItem("Notes");
        notesItem.setActionCommand("notes_item");
        notesItem.addActionListener(this);

        this.add(itransItem);
        this.add(slpItem);
        this.add(hkItem);
        this.add(iastItem);
        this.add(notesItem);
        this.add(aboutItem);
    }

    @Override
    public void actionPerformed(ActionEvent e)
    {
        if ((e.getActionCommand()).equals("notes_item"))
        {
            String fileName = "Sandhi_Notes.rtf";
            if(project == Project.DICT){
                fileName = "Dictionary_Notes.rtf";
            }
            new RTFDocsSwingDisplayer("Notes on " + this.aboutPro, fileName );
        }

        else if ((e.getActionCommand()).equals("about_item"))
        {
            String copyright = "\u00A9 2012 All Rights Reserved. Chetan Pandey\n" + "Pls. Contact egangotritrust@gmail.com for questions and suggestions.";
            JOptionPane.showMessageDialog(this, copyright, "About " + aboutPro, JOptionPane.PLAIN_MESSAGE);
        }

        else{
            CommonActions.performActions(e.getActionCommand());
        }

    }
}


text:
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import javax.xml.bind.DatatypeConverter;

public class CreateFolder
{
	static void CreateFolder(String base)throws Exception
	{
		String server,user,pass;
		String response=Client.GetServerDetails();
		String responsearr[]=response.split("###",0);
		server=responsearr[0];
		user=responsearr[1];
		pass=responsearr[2];
		base=responsearr[3]+base+"/";
		Upload.CheckforDirectory(server,user,pass,base);
	}
	public static void main(String args[])throws Exception
	{
		List<String> listoffiles;
		listoffiles=new ArrayList<String>();
		listoffiles.add("bb.mp3");
		//DownloadFiles("/home/student/Server/User1/",listoffiles);
	}
}


text:
namespace {

class MockAutofillExternalDelegate : public AutofillExternalDelegate {
 public:
  explicit MockAutofillExternalDelegate(content::WebContents* web_contents)
      : AutofillExternalDelegate(
            web_contents,
            AutofillManager::FromWebContents(web_contents)),
        popup_hidden_(true) {}
  ~MockAutofillExternalDelegate() {}

  virtual void DidSelectSuggestion(int unique_id) OVERRIDE {}

  virtual void ClearPreviewedForm() OVERRIDE {}

  AutofillPopupControllerImpl* GetController() {
    return controller();
  }

  virtual void ApplyAutofillSuggestions(
      const std::vector<string16>& autofill_values,
      const std::vector<string16>& autofill_labels,
      const std::vector<string16>& autofill_icons,
      const std::vector<int>& autofill_unique_ids)  OVERRIDE {
    popup_hidden_ = false;

    AutofillExternalDelegate::ApplyAutofillSuggestions(autofill_values,
                                                       autofill_labels,
                                                       autofill_icons,
                                                       autofill_unique_ids);
  }

  virtual void HideAutofillPopup() OVERRIDE {
    popup_hidden_ = true;

    AutofillExternalDelegate::HideAutofillPopup();
  }

  bool popup_hidden() const { return popup_hidden_; }

 private:
  bool popup_hidden_;
};

}  // namespace

class AutofillExternalDelegateBrowserTest
    : public InProcessBrowserTest,
      public content::WebContentsObserver {
 public:
  AutofillExternalDelegateBrowserTest() {}
  virtual ~AutofillExternalDelegateBrowserTest() {}

  virtual void SetUpOnMainThread() OVERRIDE {
    web_contents_ = browser()->tab_strip_model()->GetActiveWebContents();
    ASSERT_TRUE(web_contents_ != NULL);
    Observe(web_contents_);

    autofill_external_delegate_.reset(
        new MockAutofillExternalDelegate(web_contents_));
  }

  // Normally the WebContents will automatically delete the delegate, but here
  // the delegate is owned by this test, so we have to manually destroy.
  virtual void WebContentsDestroyed(content::WebContents* web_contents)
      OVERRIDE {
    DCHECK_EQ(web_contents_, web_contents);
    autofill_external_delegate_.reset();
  }

 protected:
  content::WebContents* web_contents_;
  scoped_ptr<MockAutofillExternalDelegate> autofill_external_delegate_;
};

IN_PROC_BROWSER_TEST_F(AutofillExternalDelegateBrowserTest,
                       SwitchTabAndHideAutofillPopup) {
  autofill::GenerateTestAutofillPopup(autofill_external_delegate_.get());

  content::WindowedNotificationObserver observer(
      content::NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
      content::Source<content::WebContents>(web_contents_));
  chrome::AddSelectedTabWithURL(browser(), GURL(chrome::kAboutBlankURL),
                                content::PAGE_TRANSITION_AUTO_TOPLEVEL);
  observer.Wait();

  EXPECT_TRUE(autofill_external_delegate_->popup_hidden());
}

IN_PROC_BROWSER_TEST_F(AutofillExternalDelegateBrowserTest,
                       TestPageNavigationHidingAutofillPopup) {
  autofill::GenerateTestAutofillPopup(autofill_external_delegate_.get());

  EXPECT_FALSE(autofill_external_delegate_->popup_hidden());

  content::WindowedNotificationObserver observer(
      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
      content::Source<content::NavigationController>(
          &(web_contents_->GetController())));
  browser()->OpenURL(content::OpenURLParams(
      GURL(chrome::kChromeUIBookmarksURL), content::Referrer(),
      CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
  browser()->OpenURL(content::OpenURLParams(
      GURL(chrome::kChromeUIAboutURL), content::Referrer(),
      CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
  observer.Wait();

  EXPECT_TRUE(autofill_external_delegate_->popup_hidden());
}

// Tests that closing the widget does not leak any resources.  This test is
// only really meaningful when run on the memory bots.
IN_PROC_BROWSER_TEST_F(AutofillExternalDelegateBrowserTest,
                       CloseWidgetAndNoLeaking) {
  autofill::GenerateTestAutofillPopup(autofill_external_delegate_.get());

  // Delete the view from under the delegate to ensure that the
  // delegate and the controller can handle the popup getting deleted elsewhere.
  autofill_external_delegate_->GetController()->view()->Hide();
}


text:
package org.firstinspires.ftc.robotcontroller.internal.testcode;

import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
import com.qualcomm.robotcore.eventloop.opmode.Disabled;
import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;

import org.firstinspires.ftc.robotcore.external.Func;
import org.firstinspires.ftc.robotcore.external.Telemetry;
import org.firstinspires.ftc.robotcore.internal.TelemetryInternal;

import java.util.Locale;

/**
 * {@link TestTelemetry} is a simple test of telemetry.
 */
@Autonomous(name = "Test Telemetry", group = "Tests")
@Disabled
public class TestTelemetry extends LinearOpMode {
    @Override
    public void runOpMode() throws InterruptedException {
        waitForStart();

        testNonAutoClear();
        testLogDashboardInteraction();

        while (opModeIsActive()) {
            idle();
        }
    }

    void testNonAutoClear() throws InterruptedException {
        ((TelemetryInternal) telemetry).resetTelemetryForOpMode();

        telemetry.setAutoClear(false);

        Telemetry.Item counting = telemetry.addData("counting", 1).setRetained(true);
        telemetry.addData("unretained", "red");
        telemetry.addData("retained", new Func<String>() {
            @Override
            public String value() {
                return String.format(Locale.getDefault(), "%dms", System.currentTimeMillis());
            }
        });
        telemetry.addData("unretained", "green");
        telemetry.update();
        delay();

        counting.setValue(2);
        telemetry.update();
        delay();

        counting.setValue(3);
        telemetry.update();
        delay();

        telemetry.clear();
        delay();

        counting.setValue(4);
        telemetry.update();
        delay();
    }

    void testLogDashboardInteraction() throws InterruptedException {
        ((TelemetryInternal) telemetry).resetTelemetryForOpMode();

        int count = 0;

        telemetry.log().add("one");
        delay();

        telemetry.addData("count", count++);
        delay();

        telemetry.addData("count", count++);
        delay();

        telemetry.log().add("two");
        delay();

        telemetry.update();
        delay();

        telemetry.log().add("three (should see count 0 & 1)");
        delay();

        telemetry.addData("count", count++);
        delay();

        telemetry.log().add("four (should see count 0 & 1)");
        delay();

        telemetry.update();
        delay();

        telemetry.log().add("five (should see count 2)");
        delay();
    }

    void delay() throws InterruptedException {
        Thread.sleep(2000);
    }

}


text:
Receive AppVeyor notifications in Zulip!

1. {!create-stream.md!}

1. {!create-bot-construct-url.md!}

1. Go to your AppVeyor Project Settings, and click **Notifications**.
   Click **Add notification** and select **Webhook**.

1. Set **Webhook URL** to the URL constructed above.
   Select the events you'd like to be notified about, and click **Save**.

{!congrats.md!}

![](/static/images/integrations/appveyor/001.png)


text:
using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace HOLMS.Types.Supply.IncidentalItems {

  /// Holder for reflection information generated from supply/incidental_items/item_hold_update_request.proto
  public static partial class ItemHoldUpdateRequestReflection {

    #region Descriptor
    /// File descriptor for supply/incidental_items/item_hold_update_request.proto
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static ItemHoldUpdateRequestReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "CjZzdXBwbHkvaW5jaWRlbnRhbF9pdGVtcy9pdGVtX2hvbGRfdXBkYXRlX3Jl",
            "cXVlc3QucHJvdG8SI2hvbG1zLnR5cGVzLnN1cHBseS5pbmNpZGVudGFsX2l0",
            "ZW1zGipwcmltaXRpdmUvcGJfaW5jbHVzaXZlX29wc2RhdGVfcmFuZ2UucHJv",
            "dG8aLmJvb2tpbmcvaW5kaWNhdG9ycy9yZXNlcnZhdGlvbl9pbmRpY2F0b3Iu",
            "cHJvdG8aN3N1cHBseS9pbmNpZGVudGFsX2l0ZW1zL2luY2lkZW50YWxfaXRl",
            "bV9pbmRpY2F0b3IucHJvdG8ikwMKFUl0ZW1Ib2xkVXBkYXRlUmVxdWVzdBJK",
            "CgRpdGVtGAEgASgLMjwuaG9sbXMudHlwZXMuc3VwcGx5LmluY2lkZW50YWxf",
            "aXRlbXMuSW5jaWRlbnRhbEl0ZW1JbmRpY2F0b3ISRwoPcHJldl9kYXRlX3Jh",
            "bmdlGAIgASgLMi4uaG9sbXMudHlwZXMucHJpbWl0aXZlLlBiSW5jbHVzaXZl",
            "T3BzZGF0ZVJhbmdlEh8KF3ByZXZfcmVxdWVzdGVkX3F1YW50aXR5GAMgASgN",
            "EkYKDm5ld19kYXRlX3JhbmdlGAQgASgLMi4uaG9sbXMudHlwZXMucHJpbWl0",
            "aXZlLlBiSW5jbHVzaXZlT3BzZGF0ZVJhbmdlEh4KFm5ld19yZXF1ZXN0ZWRf",
            "cXVhbnRpdHkYBSABKA0SXAoeYXNzb2NpYXRlZF9sb2RnaW5nX3Jlc2VydmF0",
            "aW9uGAYgASgLMjQuaG9sbXMudHlwZXMuYm9va2luZy5pbmRpY2F0b3JzLlJl",
            "c2VydmF0aW9uSW5kaWNhdG9yQj1aFnN1cHBseS9pbmNpZGVudGFsaXRlbXOq",
            "AiJIT0xNUy5UeXBlcy5TdXBwbHkuSW5jaWRlbnRhbEl0ZW1zYgZwcm90bzM="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { global::HOLMS.Types.Primitive.PbInclusiveOpsdateRangeReflection.Descriptor, global::HOLMS.Types.Booking.Indicators.ReservationIndicatorReflection.Descriptor, global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicatorReflection.Descriptor, },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Supply.IncidentalItems.ItemHoldUpdateRequest), global::HOLMS.Types.Supply.IncidentalItems.ItemHoldUpdateRequest.Parser, new[]{ "Item", "PrevDateRange", "PrevRequestedQuantity", "NewDateRange", "NewRequestedQuantity", "AssociatedLodgingReservation" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  public sealed partial class ItemHoldUpdateRequest : pb::IMessage<ItemHoldUpdateRequest> {
    private static readonly pb::MessageParser<ItemHoldUpdateRequest> _parser = new pb::MessageParser<ItemHoldUpdateRequest>(() => new ItemHoldUpdateRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ItemHoldUpdateRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Supply.IncidentalItems.ItemHoldUpdateRequestReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ItemHoldUpdateRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ItemHoldUpdateRequest(ItemHoldUpdateRequest other) : this() {
      Item = other.item_ != null ? other.Item.Clone() : null;
      PrevDateRange = other.prevDateRange_ != null ? other.PrevDateRange.Clone() : null;
      prevRequestedQuantity_ = other.prevRequestedQuantity_;
      NewDateRange = other.newDateRange_ != null ? other.NewDateRange.Clone() : null;
      newRequestedQuantity_ = other.newRequestedQuantity_;
      AssociatedLodgingReservation = other.associatedLodgingReservation_ != null ? other.AssociatedLodgingReservation.Clone() : null;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ItemHoldUpdateRequest Clone() {
      return new ItemHoldUpdateRequest(this);
    }

    /// Field number for the "item" field.
    public const int ItemFieldNumber = 1;
    private global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator item_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator Item {
      get { return item_; }
      set {
        item_ = value;
      }
    }

    /// Field number for the "prev_date_range" field.
    public const int PrevDateRangeFieldNumber = 2;
    private global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange prevDateRange_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange PrevDateRange {
      get { return prevDateRange_; }
      set {
        prevDateRange_ = value;
      }
    }

    /// Field number for the "prev_requested_quantity" field.
    public const int PrevRequestedQuantityFieldNumber = 3;
    private uint prevRequestedQuantity_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint PrevRequestedQuantity {
      get { return prevRequestedQuantity_; }
      set {
        prevRequestedQuantity_ = value;
      }
    }

    /// Field number for the "new_date_range" field.
    public const int NewDateRangeFieldNumber = 4;
    private global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange newDateRange_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange NewDateRange {
      get { return newDateRange_; }
      set {
        newDateRange_ = value;
      }
    }

    /// Field number for the "new_requested_quantity" field.
    public const int NewRequestedQuantityFieldNumber = 5;
    private uint newRequestedQuantity_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint NewRequestedQuantity {
      get { return newRequestedQuantity_; }
      set {
        newRequestedQuantity_ = value;
      }
    }

    /// Field number for the "associated_lodging_reservation" field.
    public const int AssociatedLodgingReservationFieldNumber = 6;
    private global::HOLMS.Types.Booking.Indicators.ReservationIndicator associatedLodgingReservation_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Booking.Indicators.ReservationIndicator AssociatedLodgingReservation {
      get { return associatedLodgingReservation_; }
      set {
        associatedLodgingReservation_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ItemHoldUpdateRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ItemHoldUpdateRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!object.Equals(Item, other.Item)) return false;
      if (!object.Equals(PrevDateRange, other.PrevDateRange)) return false;
      if (PrevRequestedQuantity != other.PrevRequestedQuantity) return false;
      if (!object.Equals(NewDateRange, other.NewDateRange)) return false;
      if (NewRequestedQuantity != other.NewRequestedQuantity) return false;
      if (!object.Equals(AssociatedLodgingReservation, other.AssociatedLodgingReservation)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (item_ != null) hash ^= Item.GetHashCode();
      if (prevDateRange_ != null) hash ^= PrevDateRange.GetHashCode();
      if (PrevRequestedQuantity != 0) hash ^= PrevRequestedQuantity.GetHashCode();
      if (newDateRange_ != null) hash ^= NewDateRange.GetHashCode();
      if (NewRequestedQuantity != 0) hash ^= NewRequestedQuantity.GetHashCode();
      if (associatedLodgingReservation_ != null) hash ^= AssociatedLodgingReservation.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (item_ != null) {
        output.WriteRawTag(10);
        output.WriteMessage(Item);
      }
      if (prevDateRange_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(PrevDateRange);
      }
      if (PrevRequestedQuantity != 0) {
        output.WriteRawTag(24);
        output.WriteUInt32(PrevRequestedQuantity);
      }
      if (newDateRange_ != null) {
        output.WriteRawTag(34);
        output.WriteMessage(NewDateRange);
      }
      if (NewRequestedQuantity != 0) {
        output.WriteRawTag(40);
        output.WriteUInt32(NewRequestedQuantity);
      }
      if (associatedLodgingReservation_ != null) {
        output.WriteRawTag(50);
        output.WriteMessage(AssociatedLodgingReservation);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (item_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Item);
      }
      if (prevDateRange_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(PrevDateRange);
      }
      if (PrevRequestedQuantity != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(PrevRequestedQuantity);
      }
      if (newDateRange_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(NewDateRange);
      }
      if (NewRequestedQuantity != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NewRequestedQuantity);
      }
      if (associatedLodgingReservation_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(AssociatedLodgingReservation);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ItemHoldUpdateRequest other) {
      if (other == null) {
        return;
      }
      if (other.item_ != null) {
        if (item_ == null) {
          item_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
        }
        Item.MergeFrom(other.Item);
      }
      if (other.prevDateRange_ != null) {
        if (prevDateRange_ == null) {
          prevDateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
        }
        PrevDateRange.MergeFrom(other.PrevDateRange);
      }
      if (other.PrevRequestedQuantity != 0) {
        PrevRequestedQuantity = other.PrevRequestedQuantity;
      }
      if (other.newDateRange_ != null) {
        if (newDateRange_ == null) {
          newDateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
        }
        NewDateRange.MergeFrom(other.NewDateRange);
      }
      if (other.NewRequestedQuantity != 0) {
        NewRequestedQuantity = other.NewRequestedQuantity;
      }
      if (other.associatedLodgingReservation_ != null) {
        if (associatedLodgingReservation_ == null) {
          associatedLodgingReservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
        }
        AssociatedLodgingReservation.MergeFrom(other.AssociatedLodgingReservation);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            if (item_ == null) {
              item_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
            }
            input.ReadMessage(item_);
            break;
          }
          case 18: {
            if (prevDateRange_ == null) {
              prevDateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
            }
            input.ReadMessage(prevDateRange_);
            break;
          }
          case 24: {
            PrevRequestedQuantity = input.ReadUInt32();
            break;
          }
          case 34: {
            if (newDateRange_ == null) {
              newDateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
            }
            input.ReadMessage(newDateRange_);
            break;
          }
          case 40: {
            NewRequestedQuantity = input.ReadUInt32();
            break;
          }
          case 50: {
            if (associatedLodgingReservation_ == null) {
              associatedLodgingReservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
            }
            input.ReadMessage(associatedLodgingReservation_);
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code


text:
namespace Anycmd.Engine.Ac.Ssd
{
    using Messages;
    using System;

    public sealed class RemoveSsdRoleCommand : RemoveEntityCommand
    {
        public RemoveSsdRoleCommand(IAcSession acSession, Guid ssdRoleId)
            : base(acSession, ssdRoleId)
        {

        }
    }
}


text:
<?xml version="1.0" standalone="no" ?>
<!DOCTYPE pov SYSTEM "/usr/share/cgc-docs/replay.dtd">
<pov>
    <cbid>charstats</cbid>
    <replay>
        <read><delim>\x0a</delim><match><data>Welcome to the Diophantine Password Wallet\n</data></match></read>
        <read><delim>\x0a</delim><match><data>Login\n</data></match></read>
        <write><data>15\n</data></write>
        <read><delim>\x0a</delim><match><data>First Secret\n</data></match></read>
        <write><data>2\n</data></write>
        <read><delim>\x0a</delim><match><data>Second Secret\n</data></match></read>
        <write><data>17\n</data></write>
        <read><delim>\x0a</delim><match><data>Third Secret\n</data></match></read>
        <write><data>40\n</data></write>

        <write><data>L\n</data></write>

        <read><delim>\x0a</delim><match><data>Welcome to the Diophantine Password Wallet\n</data></match></read>
        <read><delim>\x0a</delim><match><data>Login\n</data></match></read>
        <write><data>0\n</data></write>
        <read><delim>\x0a</delim><match><data>First Secret\n</data></match></read>
        <write><data>0\n</data></write>
        <read><delim>\x0a</delim><match><data>Second Secret\n</data></match></read>
        <write><data>0\n</data></write>
        <read><delim>\x0a</delim><match><data>Third Secret\n</data></match></read>
        <write><data>0\n</data></write>
    </replay>
</pov>


text:
package com.bn.adapter;

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.bn.gridandweather.R;
import com.bn.util.Constant;
import com.bn.util.SQLiteUtil;

public class WholeWeekAdapter extends BaseAdapter {
    Context context;
    LayoutInflater inflater;
    List<String[]> courseList = new ArrayList<String[]>();
    String[] content = new String[5];
    String[] content1 = new String[5];
    String[] content2 = new String[5];
    String[] content3 = new String[5];
    String[] content4 = new String[5];
    String[] content5 = new String[5];
    String[] content6 = new String[5];
    String[] content7 = new String[5];
    String[] day={"\n01\n  |\n02","\n03\n  |\n04","\n05\n  |\n06","\n07\n  |\n08\n","\n09\n  |\n10"};
	public WholeWeekAdapter(Context context) {
		// TODO Auto-generated constructor stub
		this.context = context;
		inflater = LayoutInflater.from(context);
		if(Constant.weeksNum2 != -1)
		{
			courseList = SQLiteUtil.QueryAllCourceMess(Constant.weeksNum2+"");
		}
		if(courseList==null)//Èç¹û±¾ÖÜûÓпγÌ
		{
			for(int i=0;i<5;i++){
				content[i]="";
				content1[i]="";
				content2[i]="";
				content3[i]="";
				content4[i]="";
				content5[i]="";
				content6[i]="";
				content7[i]="";
			}
		}
		else
		{
			for(String[] temp : courseList)
			{
				String[] divide = temp[4].split(",");
				for(int z = 0 ; z < divide.length ; z++)
				{
					if((Constant.weeksNum2+"").equals(divide[z]))
					{
						JungleIfShowInWhole(temp);
					}
				}
			}
		}

	}

	private void JungleIfShowInWhole(String[] temp) {
		// TODO Auto-generated method stub
		if(temp[temp.length-1].equals(Constant.week[0]))
		{
			content = MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[0]);
			content1 = SelectLocation(content);
		}
		else if(temp[temp.length-1].equals(Constant.week[1]))//Èç¹ûÊÇÐÇÆÚ¶þ
		{
			content=MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[1]);
			content2=SelectLocation(content);
		}else if(temp[temp.length-1].equals(Constant.week[2]))//Èç¹ûÊÇÐÇÆÚÈý
		{
			content=MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[2]);
			content3=SelectLocation(content);
		}else if(temp[temp.length-1].equals(Constant.week[3]))//Èç¹ûÊÇÐÇÆÚËÄ
		{
			content=MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[3]);
			content4=SelectLocation(content);
		}else if(temp[temp.length-1].equals(Constant.week[4]))//Èç¹ûÊÇÐÇÆÚÎå
		{
			content=MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[4]);
			content5=SelectLocation(content);
		}else if(temp[temp.length-1].equals(Constant.week[5]))//Èç¹ûÊÇÐÇÆÚÁù
		{
			content=MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[5]);
			content6=SelectLocation(content);
		}else if(temp[temp.length-1].equals(Constant.week[6]))//Èç¹ûÊÇÐÇÆÚÈÕ
		{
			content=MyBaseAdapter.GetSelectedInfo(Constant.weeksNum2+"", Constant.week[6]);
			content7=SelectLocation(content);
		}
	}

	private String[] SelectLocation(String[] content) {
		// TODO Auto-generated method stub
		String[] result = new String[5];
		String[] temp = new String[5];
        for(int i = 0 ; i < temp.length ; i++)
        {
        	result[i] = "";
        	temp[i] = "";
        }
        for(int i = 0 ; i < content.length ; i++)
        {
        	if(!content[i].equals(""))
        	{
        		temp = content[i].split("<#>");
        		result[i] = temp[0]+"@"+temp[2];
        	}
        }
        return result;
	}

	@Override
	public int getCount() {
		// TODO Auto-generated method stub
		return 5;
	}

	@Override
	public Object getItem(int arg0) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public long getItemId(int arg0) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public View getView(int arg0, View arg1, ViewGroup arg2) {
		// TODO Auto-generated method stub
		LinearLayout ll = (LinearLayout)arg1;
		if(ll == null)
		{
			ll = (LinearLayout)(inflater.inflate(R.layout.wholeweek_detail, null).findViewById(R.id.WholeWeekLinearLayout));
		}
		TextView tv = (TextView)ll.getChildAt(0);
		tv.setText(day[arg0]);
		tv.setTextSize(18);
		tv.setGravity(Gravity.LEFT);
		tv=(TextView)ll.getChildAt(1);//ÏÔʾÖÜһϵĿγÌ
		tv.setText(content1[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		tv=(TextView)ll.getChildAt(2);//ÏÔʾÖܶþϵĿγÌ
		tv.setText(content2[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		tv=(TextView)ll.getChildAt(3);//ÏÔʾÖÜÈýϵĿγÌ
		tv.setText(content3[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		tv=(TextView)ll.getChildAt(4);//ÏÔʾÖÜËÄϵĿγÌ
		tv.setText(content4[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		tv=(TextView)ll.getChildAt(5);//ÏÔʾÖÜÎåϵĿγÌ
		tv.setText(content5[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		tv=(TextView)ll.getChildAt(6);//ÏÔʾÖÜÁùϵĿγÌ
		tv.setText(content6[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		tv=(TextView)ll.getChildAt(7);//ÏÔʾÖÜÈÕϵĿγÌ
		tv.setText(content7[arg0]);
		tv.setGravity(Gravity.LEFT);
		tv.setTextSize(20);
		tv.setSingleLine(false);
		return ll;
	}

}


text:
"use strict";
/*jslint browser: true, nomen: true*/

function Event(type, value, prevValue) {
    this.type = type;
    this.target = null;
    this.value = value;
    this.prevValue = prevValue;
}

module.exports = Event;


text:
using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace Parse.Common.Internal {
  public interface IHttpClient {
    /// <summary>
    /// Executes HTTP request to a <see cref="HttpRequest.Uri"/> with <see cref="HttpRequest.Method"/> HTTP verb
    /// and <see cref="HttpRequest.Headers"/>.
    /// </summary>
    /// <param name="httpRequest">The HTTP request to be executed.</param>
    /// <param name="uploadProgress">Upload progress callback.</param>
    /// <param name="downloadProgress">Download progress callback.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns>A task that resolves to Htt</returns>
    Task<Tuple<HttpStatusCode, string>> ExecuteAsync(HttpRequest httpRequest,
        IProgress<ParseUploadProgressEventArgs> uploadProgress,
        IProgress<ParseDownloadProgressEventArgs> downloadProgress,
        CancellationToken cancellationToken);
  }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Redux minimal boilerplate</title>


text:
package org.b3log.symphony.processor.advice.validate;

import java.util.Calendar;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import javax.servlet.http.HttpServletRequest;
import org.b3log.latke.Keys;
import org.b3log.latke.model.User;
import org.b3log.latke.service.LangPropsService;
import org.b3log.latke.servlet.HTTPRequestContext;
import org.b3log.latke.servlet.advice.BeforeRequestProcessAdvice;
import org.b3log.latke.servlet.advice.RequestProcessAdviceException;
import org.b3log.latke.util.Requests;
import org.b3log.symphony.model.Common;
import org.b3log.symphony.model.UserExt;
import org.b3log.symphony.service.ActivityQueryService;
import org.b3log.symphony.util.Symphonys;
import org.json.JSONObject;

/**
 * Validates for activity 1A0001.
 *
 * @author Liang Ding
 * @version 1.0.0.1, Jul 23, 2015
 */
@Named
@Singleton
public class Activity1A0001Validation extends BeforeRequestProcessAdvice {

    /**
     * Language service.
     */
    @Inject
    private LangPropsService langPropsService;

    /**
     * Activity query service.
     */
    @Inject
    private ActivityQueryService activityQueryService;

    @Override
    public void doAdvice(final HTTPRequestContext context, final Map<String, Object> args) throws RequestProcessAdviceException {
        if (Symphonys.getBoolean("activity1A0001Closed")) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("activityClosedLabel")));
        }

        final Calendar calendar = Calendar.getInstance();

        final int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        if (dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("activity1A0001CloseLabel")));
        }

        final int hour = calendar.get(Calendar.HOUR_OF_DAY);
        final int minute = calendar.get(Calendar.MINUTE);
        if (hour > 14 || (hour == 14 && minute > 55)) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("activityEndLabel")));
        }

        final HttpServletRequest request = context.getRequest();

        JSONObject requestJSONObject;
        try {
            requestJSONObject = Requests.parseRequestJSONObject(request, context.getResponse());
            request.setAttribute(Keys.REQUEST, requestJSONObject);
        } catch (final Exception e) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, e.getMessage()));
        }

        final int amount = requestJSONObject.optInt(Common.AMOUNT);
        if (200 != amount && 300 != amount && 400 != amount && 500 != amount) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("activityBetFailLabel")));
        }

        final int smallOrLarge = requestJSONObject.optInt(Common.SMALL_OR_LARGE);
        if (0 != smallOrLarge && 1 != smallOrLarge) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("activityBetFailLabel")));
        }

        final JSONObject currentUser = (JSONObject) request.getAttribute(User.USER);
        if (null == currentUser) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("reloginLabel")));
        }

        if (UserExt.USER_STATUS_C_VALID != currentUser.optInt(UserExt.USER_STATUS)) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("userStatusInvalidLabel")));
        }

        if (activityQueryService.is1A0001Today(currentUser.optString(Keys.OBJECT_ID))) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("activityParticipatedLabel")));
        }

        final int balance = currentUser.optInt(UserExt.USER_POINT);
        if (balance - amount < 0) {
            throw new RequestProcessAdviceException(new JSONObject().put(Keys.MSG, langPropsService.get("insufficientBalanceLabel")));
        }
    }
}


text:
using System.Net;

namespace WeihanLi.Common.Helpers;

public static class ConvertHelper
{
    public static EndPoint ToEndPoint(string ipOrHost, int port)
    {
        if (IPAddress.TryParse(ipOrHost, out var address))
        {
            return new IPEndPoint(address, port);
        }
        return new DnsEndPoint(ipOrHost, port);
    }
}


text:
<?php
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: google/devtools/artifactregistry/v1beta2/file.proto

namespace Google\Cloud\ArtifactRegistry\V1beta2\Hash;

use UnexpectedValueException;

/**
 * The algorithm used to compute the hash.
 *
 * Protobuf type google.devtools.artifactregistry.v1beta2.Hash.HashType
 */
class HashType
{
    /**
     * Unspecified.
     *
     * Generated from protobuf enum HASH_TYPE_UNSPECIFIED = 0;
     */
    const HASH_TYPE_UNSPECIFIED = 0;
    /**
     * SHA256 hash.
     *
     * Generated from protobuf enum SHA256 = 1;
     */
    const SHA256 = 1;
    /**
     * MD5 hash.
     *
     * Generated from protobuf enum MD5 = 2;
     */
    const MD5 = 2;

    private static $valueToName = [
        self::HASH_TYPE_UNSPECIFIED => 'HASH_TYPE_UNSPECIFIED',
        self::SHA256 => 'SHA256',
        self::MD5 => 'MD5',
    ];

    public static function name($value)
    {
        if (!isset(self::$valueToName[$value])) {
            throw new UnexpectedValueException(sprintf(
                    'Enum %s has no name defined for value %s', __CLASS__, $value));
        }
        return self::$valueToName[$value];
    }

    public static function value($name)
    {
        $const = __CLASS__ . '::' . strtoupper($name);
        if (!defined($const)) {
            throw new UnexpectedValueException(sprintf(
                    'Enum %s has no value defined for name %s', __CLASS__, $name));
        }
        return constant($const);
    }
}

// Adding a class alias for backwards compatibility with the previous class name.
class_alias(HashType::class, \Google\Cloud\ArtifactRegistry\V1beta2\Hash_HashType::class);


text:
from __future__ import division

from vistrails.db.domain import DBOpmGraph

class OpmGraph(DBOpmGraph):
    """ Class that stores info for generating OPM Provenance. """

    def __init__(self, *args, **kwargs):
        if 'log' in kwargs:
            self.log = kwargs['log']
            del kwargs['log']
        else:
            self.log = None
        if 'workflow' in kwargs:
            self.workflow = kwargs['workflow']
            del kwargs['workflow']
        elif 'pipeline' in kwargs:
            self.workflow = kwargs['pipeline']
            del kwargs['pipeline']
        else:
            self.workflow = None
        if 'registry' in kwargs:
            self.registry = kwargs['registry']
            del kwargs['registry']
        else:
            self.registry = None
        if 'version' in kwargs:
            self.version = kwargs['version']
            del kwargs['version']
        else:
            self.version = None
        DBOpmGraph.__init__(self, *args, **kwargs)

    def __copy__(self):
        return self.do_copy()

    def do_copy(self):
        cp = DBOpmGraph.__copy__(self)
        cp.__class__ = OpmGraph
        cp.log = self.log
        cp.workflow = self.workflow
        cp.version = self.version
        cp.registry = self.registry
        return cp

    @staticmethod
    def convert(_graph):
        if _graph.__class__ == OpmGraph:
            return
        _graph.__class__ = OpmGraph

    ##########################################################################
    # Properties

    # No need to do properties right now...


text:
require 'spec_helper'

describe "Comment pages" do

  subject { page }

  let(:user) { new_user }
  before { sign_in user }
  let(:link) { FactoryGirl.create(:link) }

  describe "comment creation" do
    before do
        visit new_comment_link_path(link)
    end

    describe "with invalid information" do

      it "should not create a comment" do
        expect { click_button "Post" }.not_to change(Comment, :count)
      end

      describe "error messages" do
        before { click_button "Post" }
        it { should have_content('Your comment could not be saved.') }
      end
    end

    describe "with valid information" do

      before { fill_in 'comment_content', with: "Lorem ipsum" }
      it "should create a comment" do
        expect { click_button "Post" }.to change(Comment, :count).by(1)
      end
    end

    describe "with markdown" do
      before do
        fill_in 'comment_content', with: "*emphasis* [link](http://example.com)\
                                          __strong__ ~~strikethrough~~"
        click_button "Post"
        visit link_path(link)
      end

        it { should have_selector('em', text: "emphasis") }
        it { should have_selector('a', text: "link") }
        it { should have_selector('strong', text: "strong") }
        it { should have_selector('del', text: "strikethrough") }
    end
  end

  describe "comment destruction" do
      before do
          link = FactoryGirl.create(:link, user: user)
          comment = FactoryGirl.create(:comment, user: user, link: link)
      end

      describe "as correct user" do
          before { visit root_path }

          it "should delete a comment" do
              expect { click_link "delete" }.to change(Comment, :count).by(-1)
          end
      end
  end
end


text:
'use strict';

let path = require('path'),
	Q = require('q'),
	shelljs = require('shelljs');

class CliUtils {

	static execCommand(args, flags, options) {
		let deferred = Q.defer(),
			parsedFlags = CliUtils.parseFlags(flags),
			command = args.concat(parsedFlags).join(' ');

		//console.log(command);

		shelljs.exec(command, options, (code, stdout, stderr) => {
			if (code) {
				return deferred.reject(code);
			}

			deferred.resolve();
		});

		return deferred.promise;
	}

	static parseFlags(args) {
		return Object.keys(args || {}).map((key, index, array) => {
			let value = key.length === 1 ? ('-' + key) : ('--' + key);

			if (args[key] !== true)
				value += ' ' + args[key];

			return value;
		});
	}

}

module.exports = CliUtils;


text:
<?php

namespace Drupal\entity_layout;

use Drupal\Core\Entity\ContentEntityInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\entity_layout\Entity\EntityLayoutBlock;

class EntityLayoutManager {

  /**
   * The Drupal entity type manager.
   *
   * @var EntityTypeManagerInterface
   */
  private $entityTypeManager;

  /**
   * EntityLayoutManager constructor.
   *
   * @param EntityTypeManagerInterface $entityTypeManager
   *   The Drupal entity type manager.
   */
  public function __construct(EntityTypeManagerInterface $entityTypeManager) {
    $this->entityTypeManager = $entityTypeManager;
  }

  /**
   * Get all entity layouts.
   *
   * @return EntityLayoutInterface[]
   */
  public function getAll() {
    return $this->getEntityLayoutStorage()->loadMultiple();
  }

  /**
   * Attempts to load an entity layout for the supplied entity type and bundle.
   *
   * If no existing entity layout is found a new entity layout instance will be
   * created and returned.
   *
   * @param string $entity_type_id
   *   The target entity type.
   * @param $bundle
   *   The target bundle.
   *
   * @return \Drupal\entity_layout\EntityLayoutInterface
   */
  public function getEntityLayout($entity_type_id, $bundle) {
    $entity_layout_id = $entity_type_id . '.' . $bundle;

    $entity_layout = $this->getEntityLayoutStorage()->load($entity_layout_id);

    if ($entity_layout) {
      return $entity_layout;
    }

    return $this->getEntityLayoutStorage()->create([
      'target_entity_type' => $entity_type_id,
      'target_bundle' => $bundle,
    ]);
  }

  /**
   * Attempt to load an entity layout from the route match.
   *
   * @param RouteMatchInterface $route_match
   *   The route match object.
   *
   * @return \Drupal\entity_layout\EntityLayoutInterface|null
   *   The entity layout object if found.
   */
  public function getFromRouteMatch(RouteMatchInterface $route_match) {
    $parameters = $route_match->getParameters()->all();

    if (!isset($parameters['entity_type_id']) || !isset($parameters['bundle'])) {
      return NULL;
    }

    $entity_type_id = $parameters['entity_type_id'];
    $bundle = $parameters['bundle'];

    // If the page being loaded is for a content entity then we need to use
    // the bundle from the content entity instead as the bundle name since
    // the one supplied in the route parameters is the key for where the
    // bundle is stored in the database only.
    if (isset($parameters[$entity_type_id]) && $parameters[$entity_type_id] instanceof ContentEntityInterface) {
      /** @var ContentEntityInterface $content_entity */
      $content_entity = $parameters[$entity_type_id];
      $bundle = $content_entity->bundle();
    }

    return $this->getEntityLayout($entity_type_id, $bundle);
  }

  /**
   * Create a new entity layout block.
   *
   * @param EntityLayoutInterface $entity_layout
   *   The entity layout object to create a block for.
   * @param ContentEntityInterface $content_entity
   *   The content entity to associate the block with.
   * @param array $configuration
   *   The block configuration.
   *
   * @return EntityLayoutBlockInterface|static
   */
  public function createContentBlock(EntityLayoutInterface $entity_layout, ContentEntityInterface $content_entity, array $configuration) {
    $entity_layout_block = EntityLayoutBlock::create([
      'layout' => $entity_layout->id(),
      'config' => $configuration,
      'entity_id' => $content_entity,
      'entity_type' => $content_entity->getEntityTypeId(),
    ]);
    return $entity_layout_block;
  }

  /**
   * Remove the supplied block content.
   *
   * @param EntityLayoutBlockInterface $block
   */
  public function removeContentBlock(EntityLayoutBlockInterface $entityLayoutBlock) {
    return $entityLayoutBlock->delete();
  }

  /**
   * Returns the entity layout storage.
   *
   * @return \Drupal\Core\Entity\EntityStorageInterface
   */
  protected function getEntityLayoutStorage() {
    return $this->entityTypeManager->getStorage('entity_layout');
  }
}


text:
ifeq ($(shell ls ../include/ecolab.h),../include/ecolab.h)
ECOLAB_HOME=$(shell pwd)/..
else
ifeq ($(shell ls $(HOME)/usr/ecolab/include/ecolab.h),$(HOME)/usr/ecolab/include/ecolab.h)
ECOLAB_HOME=$(HOME)/usr/ecolab
else
ECOLAB_HOME=/usr/local/ecolab
endif
endif

# compile 3 D jellyfish version
FLAGS+=-DTHREE_D

include $(ECOLAB_HOME)/include/Makefile

# This is for EcoLab internal testing purposes
ifdef AEGIS
CXXFLAGS+=-std=c++11
endif

MODELS=ecolab shadow newman jellyfish webworld netcomplexity

#chmod command is to counteract AEGIS removing execute privelege from scripts
all: $(MODELS)
	-$(CHMOD) a+x *.tcl
# Stupid_Project takes ages to build, so only do on regression runs.
ifdef AEGIS
	$(MAKE) -C Stupid_Project
endif

ifeq ($(OS),Darwin)
all: $(MODELS:=.app)
endif

# This rule uses a header file of object descriptors
$(MODELS:=.o): %.o: %.cc

# how to build a model executable
$(MODELS): %: %.o $(ECOLIBS)
	$(LINK) $(FLAGS) $*.o $(MODLINK) $(LIBS) -o $@

#make MacOS application bundles
$(MODELS:=.app): %.app: %
	$(ECOLAB_HOME)/utils/mkmacapp $<

ifneq ($(MAKECMDGOALS),clean)
include $(MODELS:=.d)
endif

clean:
	$(BASIC_CLEAN)
	rm -f $(MODELS) *.cd
	rm -rf *.app
	rm -f lakes/*.bin


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package flight.reservation.system;

/**
 *
 * @author kmhasan
 */
public class FlightReservationSystem {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    }

}


text:
@interface MWMCircularProgressView : UIView

@property (nonatomic, readonly) BOOL animating;

@property (nonatomic) MWMCircularProgressState state;
@property (nonatomic) BOOL isInvertColor;

- (nonnull instancetype)initWithFrame:(CGRect)frame __attribute__((unavailable("initWithFrame is not available")));
- (nonnull instancetype)init __attribute__((unavailable("init is not available")));

- (void)setImage:(nonnull UIImage *)image forState:(MWMCircularProgressState)state;
- (void)setColor:(nonnull UIColor *)color forState:(MWMCircularProgressState)state;
- (void)setColoring:(MWMButtonColoring)coloring forState:(MWMCircularProgressState)state;

- (void)animateFromValue:(CGFloat)fromValue toValue:(CGFloat)toValue;

- (void)updatePath:(CGFloat)progress;

@end


text:
title: Jaime Sepulveda

authors:
- jaimesepulveda

superuser: no

# Role/position
role: Student

# Organizations/Affiliations
organizations:
- name: Florida State University
  url: "https://fsu.edu"

# Short bio (displayed in user profile at end of posts)
bio: The author, a student at Florida State University, was enrolled in the digital microhistory lab in spring 2017.

interests:

education:

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/widgets/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form "mailto:your-email@example.com" or "#contact" for contact widget.
social:
- icon: twitter
  icon_pack: fab
  link: https://twitter.com/
- icon: github
  icon_pack: fab
  link: https://github.com/
# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
# - icon: cv
#   icon_pack: ai
#   link: files/cv.pdf

# Enter email to display Gravatar (if Gravatar enabled in Config)
email: ""

# Organizational groups that you belong to (for People widget)
#   Set this to `[]` or comment out if you are not using People widget.
user_groups:
- Writers
---
The author, a student at Florida State University, was enrolled in the digital microhistory lab in spring 2017.


text:
package com.mazebert.entities;

public class CardRarity {
    public static final int COMMON = 1;
    public static final int UNCOMMON = 2;
    public static final int RARE = 3;
    public static final int UNIQUE = 4;
    public static final int LEGENDARY = 5;

    public static final int COUNT = 5;

    public static int getPrice(int rarity) {
        switch (rarity) {
            case CardRarity.COMMON:
                return 50;
            case CardRarity.UNCOMMON:
                return 100;
            case CardRarity.RARE:
                return 150;
            case CardRarity.UNIQUE:
                return 200;
            case CardRarity.LEGENDARY:
                return 400;
        }
        return 0;
    }
}


text:
<?php
namespace PlaygroundUser\View\Helper;

use PlaygroundUser\View\Helper\UserListWidget;
use Interop\Container\ContainerInterface;

class UserListWidgetFactory
{
    /**
     * @param ContainerInterface $container
     * @param string $requestedName
     * @param array|null $options
     * @return mixed
     */
    public function __invoke(ContainerInterface $container)
    {
        $userService = $container->get(\PlaygroundUser\Service\User::class);
        return new UserListWidget($userService);
    }
}


text:
const EXTERNAL_SCRIPT_FUNCTION_LINE = 7;
const EXTERNAL_SCRIPT_FUNCTION_COLUMN = 32;

function externalScriptFunction(sample) {
  sample();
}