text:
#ifndef _BAT_H
#define _BAT_H

#define BAT_OBJ_TYPE	7

/*
	A "Bat" Monster
		3D Black Cube, flys around in the air, dives at player then runs away

*/

#include "monster.h"
#include "particles/fire.h"

#define BAT_ALTITUDE	15.0f
#define BAT_SPEED		35.0f
#define BAT_DIVE_SPEED	70.0f
#define BAT_CLIMB_SPEED	20.0f

#define BAT_DIVE_DISTANCE	14.0f
#define BAT_CLIMB_DISTANCE	25.0f

class CBat: public CMonster
{
public:
	CBat( float rotSpeed, float flapHeight, float flapSpeed, float flapIntensity );
	~CBat();

	void Update( float dt );
	void Render();
	void RenderAlpha();

	void DeathEffect();
protected:
	void LoadTexture();

	int	mAction;

	float mRotSpeed;

	float mFlap;
	float mFlapHeight;
	float mFlapSpeed;
	float mFlapIntensity;

	float mCruiseHeight;

	CFire* mEffect;

	CWaveSound* mBatSound;
	CSound* mSound;
};

#endif

redpajama_set_name: RedPajamaGithub


text:
package com.manik.level;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Rectangle;
import com.manik.handler.MapStatusHandler;

public class LevelBoard {

    private int row;
    private int col;
    private float ara;
    private float xKord;
    private float yKord;
    private float width;
    private float height;

    private LevelMap[][] levelMaps;
    private LevelTick[][] levelTicks;

    public LevelBoard(int row, int col){

        this.row=row;
        this.col=col;
        ara= Gdx.graphics.getWidth()/10;
        xKord=ara;
        yKord=ara;
        width=Gdx.graphics.getWidth()/5;
        height=Gdx.graphics.getHeight()/4;
        levelMaps=new LevelMap[row][col];
        levelTicks=new LevelTick[row][col];
        initLevelMap();
    }

    public void render(SpriteBatch sb){
        for(int i=0;i<row;i++){
            for(int j=0; j<col; j++){
                levelMaps[i][j].render(sb);
            }
        }
        if(MapStatusHandler.getLevelOne()){
            levelTicks[0][0].render(sb);
        }
        if(MapStatusHandler.getLevelTwo()){
            levelTicks[0][1].render(sb);
        }
        if(MapStatusHandler.getLevelThree()){
            levelTicks[0][2].render(sb);
        }
        if(MapStatusHandler.getLevelFour()){
            levelTicks[1][0].render(sb);
        }
        if(MapStatusHandler.getLevelFive()){
            levelTicks[1][1].render(sb);
        }
        if(MapStatusHandler.getLevelSix()){
            levelTicks[1][2].render(sb);
        }

    }

    public void update(float delta){
        for(int i=0;i<row;i++){
            for(int j=0; j<col; j++){
                levelMaps[i][j].update(delta);
            }
        }
        if(MapStatusHandler.getLevelOne()){
            levelTicks[0][0].update(delta);
        }
        if(MapStatusHandler.getLevelTwo()){
            levelTicks[0][1].update(delta);
        }
        if(MapStatusHandler.getLevelThree()){
            levelTicks[0][2].update(delta);
        }
        if(MapStatusHandler.getLevelFour()){
            levelTicks[1][0].update(delta);
        }
        if(MapStatusHandler.getLevelFive()){
            levelTicks[1][1].update(delta);
        }
        if(MapStatusHandler.getLevelSix()){
            levelTicks[1][2].update(delta);
        }
    }

    public void initLevelMap(){
        int [] dizi={40, 150, 78, 134, 28, 125 ,-60, 50 ,-25, -45, 35, -15};
        for(int i=0;i<row;i++){
            for(int j=0; j<col; j++){
                levelMaps[i][j]=new LevelMap(xKord,yKord,width,height);
                levelTicks[i][j]=new LevelTick(xKord+70,yKord+20,width/2,height/2);
                xKord+=(dizi[i+j]+width);
                yKord+=dizi[8-(j+i)];
            }
            xKord=dizi[i];
            yKord+=(ara+height);
        }
    }

    public int getRow() {
        return row;
    }

    public int getCol() {
        return col;
    }

    public LevelMap[][] getLevelMaps() {
        return levelMaps;
    }

    public LevelTick[][] getLevelTicks(){ return levelTicks; }
}


text:
require 'flexmock/noop'

class FlexMock

end


text:
title: "The Dark Side of Perfectionism"
date: 2012-09-11 00:00
---

On a recent episode of [Back to Work](http://5by5.tv/b2w/83), our friend Merlin Mann made the following remark, and it struck me so deeply that I stopped walking to work and rewound just to listen to it a few more times.

> The dark side of perfectionism is that you may not even start [your project] because you sense that it won't be perfect.

Holy shit. For me, he really hit the nail on the head. After all, if it's not perfect, why bother.

In North America, we are brought up to _believe_ in perfectionism. To _embrace_ it as a virtue.

During high school, guidance counsellors coaching us for job interviews would warn us that employers will ask for examples of our weaknesses; they said that perfection is a good answer since it's a positive weakness.

Near the beginning of one interview I had with a particularly awful Internet startup, the hiring manager asked me for _three weaknesses_. I gave him my earnest, albeit prepared answer of "I _need_ lots to do or else I get bored" (and the I quit, he would later learn). He nodded, wrote something down on his paper, and asked for the other two. I thought about it for a while and he eventually "offered" a few common ones. One was perfectionism. I nodded my head and he checked the little box he needed to have filled in. I got the job.

What the fuck.

_Strive_ for perfection; don't deify it.

There are so many projects and pursuits that I have personally chosen - **chosen** - to not undertake because _I know they won't be perfect_. We are creating a society where people have wonderful, fantastic ideas and they are letting them rot in Moleskin notebooks because they fear that the execution of their ideas will be less than absolutely, platonically perfect.

No artist ever created something a moving piece of art by first expecting it to be perfect. I suspect that many artists never create anything because perfection is their [expectation zero](http://5by5.tv/b2w/70).

There is a difference between polish and perfection. I think that you can have a polished product that you feel personally invested in, even if you know it's less than perfect. Don't let obsessions with perfection stop you from doing _anything_.

<!-- more -->


text:
extHist = org.parosproxy.paros.control.Control.getSingleton().
    getExtensionLoader().getExtension(
        org.parosproxy.paros.extension.history.ExtensionHistory.NAME)
if (extHist != null) {
    i=1
    lastRef=extHist.getLastHistoryId();// Get current max history reference
    // Loop through the history table, printing out the history id and the URL
    while (i <= lastRef) {
        hr = extHist.getHistoryReference(i)
        if (hr) {
            url = hr.getHttpMessage().getRequestHeader().getURI().toString();
            print('Got History record id ' + hr.getHistoryId() + ' URL=' + url);
        }
        i++
    }
}


text:
package io.aif.language.word.dict;

import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import io.aif.language.word.IWord;

import static org.testng.Assert.assertNotSame;

public class WordPlaceHolderMapperTest {

  @Test(groups = "unit-tests")
  public void testMap() throws Exception {
    Collection<String> inputTokens = Arrays.asList("I", "am", "from", "kandy", "land.", "And", "you?");
    Set<IWord> words = new HashSet<>();
    inputTokens.forEach(token -> words.add(new Word(token, Collections.singletonList(token), 1L)));
    Dict inputDict = Dict.create(words);

    List<IWord.IWordPlaceholder> expected = inputTokens
        .stream()
        .map(token -> {
          Word word = (Word) inputDict.search(token).get();
          return word.new WordPlaceholder(token);
        })
        .collect(Collectors.toList());

    WordPlaceHolderMapper mapper = new WordPlaceHolderMapper(inputDict);
    Collection<IWord.IWordPlaceholder> actual = mapper.map(inputTokens);

    assertNotSame(actual, expected); //  Asserts that two objects do not refer to the same object
  }

  @Test(groups = "unit-tests", expectedExceptions = RuntimeException.class)
  public void testMapTokenNotFoundInISearchable() throws Exception {
    Collection<String> tokens = Arrays.asList("I", "am", "from", "kandy", "land.", "And", "you?");
    Collection<String> input = new ArrayList<>(tokens.size());
    tokens.forEach(token -> input.add(token));
    input.add("Hoppa!");

    Set<IWord> words = new HashSet<>();
    tokens.forEach(token -> words.add(new Word(token, Collections.singletonList(token), 1L)));
    Dict inputDict = Dict.create(words);

    WordPlaceHolderMapper mapper = new WordPlaceHolderMapper(inputDict);
    mapper.map(input);
  }
}


text:
<?php

namespace App\Common\Models\Qyweixin\Mysql\ExternalContact;

use App\Common\Models\Base\Mysql\Base;

class ProductAlbum extends Base
{
    /**
     * 企业微信-外部联系人管理-商品图册
     * This model is mapped to the table iqyweixin_externalcontact_product_album
     */
    public function getSource()
    {
        return 'iqyweixin_externalcontact_product_album';
    }
}


text:
## Задание 08 "08_timers_pwm"
### Параметры ШИМ
После лекции вы должны быть уже знакомы с Широтно-Импульсной Модуляцией (Pulse Width Modulation).
На лекции упоминалось, что ШИМ применяется во многих сферах,
некоторые из них это регулирование яркости источников света и привод электродвигателей.

 Пример сигнала ШИМ

ШИМ представляет из себя прямоугольный сигнал. Кроме очевидных максимального и минимального значения напряжения,
имеются два важных параметра, описывающих форму сигнала: **коэффициент заполнения** и **частота**.
На картинке приведен пример с различными к.зап.: 10%, 50%, 90%.
Существует ещё **скважность** - **величина обратная коэффициенту заполнения**.
Для справки, в отношении скважности и к.зап. в англоязычной литературе используется только термин **Duty cycle**.

Хотелось бы отметить, что, интуитивно, для регулировки яркости лампочки частота не имеет большого значения.
Но эта интуиция нарушается в двух крайних случаях.
Частота **очень низкая** перестаёт казаться равномерным горением — человеческий глаз начинает видеть **мерцание**.
Вы могли это наблюдать на лабораторной работе с энкодером. А частота **очень высокая** может снизить яркость горения.
Когда длительность одного импульса становится сравнима с временем задержки цепочки транзисторов, используемых для переключения,
то **форма сигнала искажается**. Кроме того, **большая частота затрачивает бОльшую мощность**.
Поэтому стараются делать частоту чуть выше предела чувствительности глаза.
В электросети естественная частота это 50 Гц, но далеко не для всех глаз этого достаточно.
В данной работе вам выпадет шанс найти свой собственный предел.

### Генерация ШИМ

 Генерация ШИМ с выравниваем по фронту и с выравниванием по центру

Чтобы освежить, как генерируется ШИМ при помощи таймера, взгляните на схемы.
На картинках изображена зависимость значения таймера CNT от времени, а также изображён порог, лежащий в регистре CCR.
ШИМ получается простым вычислением `(CNT >= CCR)`. Если таймер все время растёт и переполняется, то такая ШИМ называется **edge-aligned** PWM.
Если таймер считает вверх/вниз, то получается **center-aligned** PWM.
Заметьте, что **скважность зависит от порога**. Если менять порог, то у `edge-aligned` ШИМ один из фронтов будет неподвижен,
в то время когда у `center-aligned` импульсов не смещается центр.
Глядя на картинку, вы должны обнаружить, что **частота зануления таймера совпадает с частотой ШИМ**.

### Настройка таймера в режиме генерации ШИМ
Перейдём от теории к практике. Изучите настройку таймера. Сначала идёт настройка выходного канала.

```C
// Тактирование порта А
LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);

// Настройка пина А5 в качестве канала CH1 таймера TIM2
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_5, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_0_7(GPIOA, LL_GPIO_PIN_5, LL_GPIO_AF_2);
```
Далее начинается настройка самого таймера

```C
// Тактирование таймера
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM2);

// Частота тактирования делится в 480 раз
LL_TIM_SetPrescaler(TIM2, 479);
// Настройка верхней границы счёта
LL_TIM_SetAutoReload(TIM2, 999);
```
Если вспомнить предыдущие работы по таймерам, то видно, что таймер отсчитывает каждую сотую миллисекунды.
Каждую сотую секунду таймер переполняется. Это значит, частота ШИМ будет равна 100 Гц.

Далее задаётся тот самый порог, с которым сравнивается текущее значение таймера.

```C
LL_TIM_OC_SetCompareCH1(TIM2, 15);
```

Эта функция кладёт значение порога в регистр `TIM2_CCR1`.
В этот регистр в режиме `Input Capture` при сигнале с CH1 автоматически запоминалось значение из счётчика таймера `TIM2_CNT`.
А теперь, в режиме `Output Compare (OC)`, наоборот,
регистр со счётчиком постоянно сравнивается с `CCR` и по результатам сравнения регулируется сигнал `CH1`.

Раз порог равен 15 из 999, то это либо очень маленькая, либо очень большая скважность.
Зависит от «полярности» ШИМ. Полярность выходящего канала задаётся следующей функцией.

```C
LL_TIM_OC_SetPolarity(TIM2, LL_TIM_CHANNEL_CH1, LL_TIM_OCPOLARITY_HIGH);
```
Канал выхода может находится в одном из двух состояний: активном или неактивном.
Что значит "активное сотояное" и определяется функцией выше.
В данном случае аргумент `LL_TIM_OCPOLARITY_HIGH` говорит о том, что активная линия будет с высоким напряжением, а неактивная - с низким (землёй).
Здесь стоит сказать, что функции `OC_SetPolarity` и `IC_SetPolarity` имеют **похожие названия, но разный смысл**.
**Первая функция определяет напряжение** для активной (и соответственно неактивной) выходящей линии,
в то время как **вторая задаёт по каким фронтам** на входном канале должно просходить событие.

Следующим шагом настраивается поведение `CH1` в зависимости от сравнения TIM2_CCR1 и TIM2_CNT.
Существует множество различных способов управления линией, которые описаны в `stm32f0xx_ll_tim.h`.
Но обращается внимание на следующий способ:

```C
#define LL_TIM_OCMODE_PWM1  (TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1)
/*
 * !<In upcounting, channel y is active as long as TIMx_CNT<TIMx_CCRy else inactive.
 * In downcounting, channel y is inactive as long as TIMx_CNT>TIMx_CCRy else active.
 */
```
Если присмотреться к описанию, то оно соотвествует происходящему на схеме генерации ШИМ. Выбираем этот аргумент.

```C
LL_TIM_OC_SetMode(TIM2, LL_TIM_CHANNEL_CH1, LL_TIM_OCMODE_PWM1);
```
Затем настраивается счёт вверх.
```C
LL_TIM_SetCounterMode(TIM2, LL_TIM_COUNTERMODE_UP);
```
В связи с этим активным (в данном случае с высоким напряжением) `CH1` будет пока счётчик таймера меньше `15`,
в остальном выход будет неактивен (земля). То есть изначально к.зап. составляет менее 2%.
Тогда ожидается, что интенсивность свечения будет невысока.

В последнюю очередь включается таймер после окончания настройки. При желании также можно организовать прерывание.
```C
// Включение прерываний по событиям на CH1
LL_TIM_EnableIT_CC1(TIM2);
// Включение таймера
LL_TIM_EnableCounter(TIM2);

// Настройка NVIC
NVIC_EnableIRQ(TIM2_IRQn);
NVIC_SetPriority(TIM2_IRQn, 1);
```

Подключите светодиод к каналу `А5`. Не забудьте про полярность светодиода.
После включения, пронаблюдайте яркость. Измените яркость, выставив другой порог.
Попробуйте изменить частоту, поменяв верхний порог счётчика `TIM2_ARR`.
Вы могли заметить, что после этого действия яркость тоже изменилась.
Яркость определяется в первую очередь отношением `TIM2_CCR1/TIM2_ARR`, которое в точности равно к.зап.
Если необходимо оставлять постоянную скважность при изменяемой частоте, то порог нужно заново пересчитать.

## Самостоятельные задания
Можно менять значения к.зап. и частоты не изменяя код каждый раз, а в реальном времени, и при этом смотреть как меняется характер ШИМ.
Эти величины скорее всего проще менять при помощи энкодера.
Сделайте два таймера, один для управления ШИМ, другой будет обрабатывать энкодер.
В качестве второго таймера можно взять `TIM3`, это таймер близкий `TIM2` по функционалу, только 16-битный.

Предлагается следующий ряд заданий. Некоторые пункты включают в себя предыдущие.
Чем больше заданий вы сможете сделать, тем лучше. Рекомендуется писать функции для перенастройки таймера.
1. **Регулировка к.зап**. После очередного поворота энкодера будет возникать прерывание,
при котором будет значение `TIM3_CCR` будет использовано в качестве нового порога.
Выставьте `TIM3_ARR` равным `TIM2_ARR`, ведь не имеет большого смысла устанавливать порог больше, чем предел счёта таймера `TIM2`.
Каналы `TIM3` отыщите таблице ([stm32f051_family.pdf](https://github.com/edosedgar/stm32f0_ARM/blob/master/docs/stm32f051_family.pdf), стр. 37-38).

2. Переведите к.зап. ШИМ в проценты и выведите на индикатор.

3. Определите порог наблюдаемости мерцания глазом. **Смотрите на светодиод прямо**.

4. Теперь найдите новый порог. Только смотрите на светодиод **боковым взглядом**. Изменился ли результат и в какую сторону?

5. **Регулируйте частоту энкодером**.
Кстати, если вам захочется изменять частоту не линейно, а экспоненциально, как в прошлой лабораторной работе, то есть два пути.
Либо обойтись без `TIM3` и вернуться к старому способу.
Или же значение таймера преобразовать при помощи нелинейной функции наподобие экспоненты.

6. Выводите частоту (период) на индикатор.

7. Заснимете на камеру смартфона светодиод, когда ШИМ по частоте порядка 60 Герц. Что-то особенное вы наблюдаете? Есть стробоскопический эффект?

8. Организуйте управление и частотой, и скважностью. Переключаться между величинами можно по кнопке.

## Пьезо-динамик

 Пьезо-динамик из набора

Если вы организовали переменную частоту, вы *бесплатно* получаете управление звуком.

Замените светодиод на **пьезо-динамик**. Обратите внимание на полярность! Настройте к. зап. 50% и выберите частоту в районе 400 Гц.
Послушайте результат.

Работа этого электронного компонента основана на пьезоэффекте.
Суть самого эффекта заключается в некоторых диэлектриках возникает поляризация,
то есть разность потенциалов, если образец механически деформировать.
Есть и обратный эффект: тело механически деформируется при приложении напряжения на него.
Если подать переменное напряжение - образец будет вибрировать в унисон.
Сам пьезо-динамик состоит из пластины пьезоэлектрика с двумя проводящими контактами с двух сторон.
Для увеличения громкости звука к пластине может крепиться небольшой рупор в виде металлического или пластикового купола с отверстием.

Если подать ШИМ частотой 400 Гц на динамик, то должен быть слышен меандр на той же частоте.
Чисто гармонический сигнал нельзя сгенерировать при помощи только ШИМ,
поэтому кроме основной частоты будут присутствовать гармоники высшего порядка.

### Музыкальная пауза

**Напишите любую мелодию**. Готовые таблицы частот нот и их длительностей можно найти в интернете для многих произведений.
Или же проявите креативность и сочините свой трек.


text:
var Path = require('path');
var Boom = require('boom');
var Code = require('code');
var Handlebars = require('handlebars');
var Hapi = require('..');
var Hoek = require('hoek');
var Lab = require('lab');
var Vision = require('vision');

// Declare internals

var internals = {};

// Test shortcuts

var lab = exports.lab = Lab.script();
var describe = lab.describe;
var it = lab.it;
var expect = Code.expect;

describe('authentication', function () {

    it('requires and authenticates a request', function (done) {

        var handler = function (request, reply) {

            return reply(request.auth.credentials.user);
        };

        var server = new Hapi.Server();
        server.connection();
        server.auth.scheme('custom', internals.implementation);
        server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
        server.route({ method: 'GET', path: '/', handler: handler });

        server.inject('/', function (res1) {

            expect(res1.statusCode).to.equal(401);

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res2) {

                expect(res2.statusCode).to.equal(200);
                done();
            });
        });
    });

    it('defaults cache to private if request authenticated', function (done) {

        var handler = function (request, reply) {

            return reply('ok').ttl(1000);
        };

        var server = new Hapi.Server();
        server.connection();
        server.auth.scheme('custom', internals.implementation);
        server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
        server.route({ method: 'GET', path: '/', handler: handler });

        server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

            expect(res.statusCode).to.equal(200);
            expect(res.headers['cache-control']).to.equal('max-age=1, must-revalidate, private');
            done();
        });
    });

    describe('strategy()', function () {

        it('fails when options default to null', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server({ debug: false });
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true);
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(500);
                done();
            });
        });

        it('throws when strategy missing scheme', function (done) {

            var server = new Hapi.Server();
            server.connection();
            expect(function () {

                server.auth.strategy('none');
            }).to.throw('Authentication strategy none missing scheme');
            done();
        });

        it('adds a route to server', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} }, route: true });

            server.inject('/', function (res1) {

                expect(res1.statusCode).to.equal(401);

                server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    done();
                });
            });
        });

        it('uses views', function (done) {

            var implementation = function (server, options) {

                server.views({
                    engines: { 'html': Handlebars },
                    relativeTo: Path.join(__dirname, '/templates/plugin')
                });

                var handler = function (request, reply) {

                    return reply.view('test', { message: 'steve' });
                };

                server.route({ method: 'GET', path: '/view', handler: handler, config: { auth: false } });

                return {
                    authenticate: function (request, reply) {

                        return reply.view('test', { message: 'xyz' });
                    }
                };
            };

            var server = new Hapi.Server();
            server.register(Vision, Hoek.ignore);
            server.connection();

            server.views({
                engines: { 'html': Handlebars },
                relativeTo: Path.join(__dirname, '/no/such/directory')
            });

            server.auth.scheme('custom', implementation);
            server.auth.strategy('default', 'custom', true);

            server.route({
                method: 'GET',
                path: '/',
                handler: function (request, reply) {

                    return reply();
                }
            });

            server.inject('/view', function (res1) {

                expect(res1.result).to.equal('
steve
');

                server.inject('/', function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    expect(res2.result).to.equal('
xyz
');
                    done();
                });
            });
        });
    });

    describe('default()', function () {

        it('sets default', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: {} } });

            server.auth.default('default');
            expect(server.connections[0].auth.settings.default).to.deep.equal({ strategies: ['default'], mode: 'required' });

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject('/', function (res1) {

                expect(res1.statusCode).to.equal(401);

                server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    done();
                });
            });
        });

        it('sets default with object', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: {} } });
            server.auth.default({ strategy: 'default' });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject('/', function (res1) {

                expect(res1.statusCode).to.equal(401);

                server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    done();
                });
            });
        });

        it('throws when setting default twice', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: {} } });
            expect(function () {

                server.auth.default('default');
                server.auth.default('default');
            }).to.throw('Cannot set default strategy more than once');
            done();
        });

        it('throws when setting default without strategy', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: {} } });
            expect(function () {

                server.auth.default({ mode: 'required' });
            }).to.throw('Default authentication strategy missing strategy name');
            done();
        });
    });

    describe('_setupRoute()', function () {

        it('throws when route refers to nonexistent strategy', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('a', 'custom', { users: { steve: {} } });
            server.auth.strategy('b', 'custom', { users: { steve: {} } });

            expect(function () {

                server.route({
                    path: '/',
                    method: 'GET',
                    config: {
                        auth: {
                            strategy: 'c'
                        },
                        handler: function (request, reply) {

                            return reply('ok');
                        }
                    }
                });
            }).to.throw('Unknown authentication strategy: c in path: /');

            done();
        });
    });

    describe('authenticate()', function () {

        it('setups route with optional authentication', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });

            var handler = function (request, reply) {

                return reply(!!request.auth.credentials);
            };
            server.route({ method: 'GET', path: '/', config: { handler: handler, auth: { mode: 'optional' } } });

            server.inject('/', function (res1) {

                expect(res1.statusCode).to.equal(200);
                expect(res1.payload).to.equal('false');

                server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    expect(res2.payload).to.equal('true');
                    done();
                });
            });
        });

        it('exposes mode', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
            server.route({
                method: 'GET',
                path: '/',
                handler: function (request, reply) {

                    return reply(request.auth.mode);
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                expect(res.result).to.equal('required');
                done();
            });
        });

        it('authenticates using multiple strategies', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('first', 'custom', { users: { steve: 'skip' } });
            server.auth.strategy('second', 'custom', { users: { steve: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.strategy);
                    },
                    auth: {
                        strategies: ['first', 'second']
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                expect(res.result).to.equal('second');
                done();
            });
        });

        it('authenticates using credentials object', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });

            var doubleHandler = function (request, reply) {

                var options = { url: '/2', credentials: request.auth.credentials };
                server.inject(options, function (res) {

                    return reply(res.result);
                });
            };

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            server.route({ method: 'GET', path: '/1', handler: doubleHandler });
            server.route({ method: 'GET', path: '/2', handler: handler });

            server.inject({ url: '/1', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('authenticates a request with custom auth settings', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        strategy: 'default'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('authenticates a request with auth strategy name config', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: 'default'
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('tries to authenticate a request', function (done) {

            var handler = function (request, reply) {

                return reply({ status: request.auth.isAuthenticated, error: request.auth.error });
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', 'try', { users: { steve: {} } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject('/', function (res1) {

                expect(res1.statusCode).to.equal(200);
                expect(res1.result.status).to.equal(false);
                expect(res1.result.error.message).to.equal('Missing authentication');

                server.inject({ url: '/', headers: { authorization: 'Custom john' } }, function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    expect(res2.result.status).to.equal(false);
                    expect(res2.result.error.message).to.equal('Missing credentials');

                    server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res3) {

                        expect(res3.statusCode).to.equal(200);
                        expect(res3.result.status).to.equal(true);
                        expect(res3.result.error).to.not.exist();
                        done();
                    });
                });
            });
        });

        it('errors on invalid authenticate callback missing both error and credentials', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server({ debug: false });
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject({ url: '/', headers: { authorization: 'Custom' } }, function (res) {

                expect(res.statusCode).to.equal(500);
                done();
            });
        });

        it('logs error', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.on('request-internal', function (request, event, tags) {

                if (tags.auth) {
                    done();
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom john' } }, function (res) {

                expect(res.statusCode).to.equal(401);
            });
        });

        it('returns a non Error error response', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { message: 'in a bottle' } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject({ url: '/', headers: { authorization: 'Custom message' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                expect(res.result).to.equal('in a bottle');
                done();
            });
        });

        it('handles errors thrown inside authenticate', function (done) {

            var server = new Hapi.Server({ debug: false });
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: 'throw' } });

            server.once('request-error', function (request, err) {

                expect(err.message).to.equal('Uncaught error: Boom');
            });

            var handler = function (request, reply) {

                return reply('ok');
            };

            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(500);
                done();
            });
        });

        it('passes non Error error response when set to try ', function (done) {

            var handler = function (request, reply) {

                return reply('ok');
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', 'try', { users: { message: 'in a bottle' } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject({ url: '/', headers: { authorization: 'Custom message' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                expect(res.result).to.equal('in a bottle');
                done();
            });
        });

        it('matches scope (array to single)', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: ['one'] } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: 'one'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('matches scope (array to array)', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: ['one', 'two'] } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: ['one', 'three']
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('matches scope (single to array)', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: 'one' } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: ['one', 'three']
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('matches scope (single to single)', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: 'one' } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: 'one'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('matches dynamic scope (single to single)', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: 'one-test' } } });
            server.route({
                method: 'GET',
                path: '/{id}',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        scope: 'one-{params.id}'
                    }
                }
            });

            server.inject({ url: '/test', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('matches dynamic scope with multiple parts (single to single)', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: 'one-test-admin' } } });
            server.route({
                method: 'GET',
                path: '/{id}/{role}',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        scope: 'one-{params.id}-{params.role}'
                    }
                }
            });

            server.inject({ url: '/test/admin', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('does not match broken dynamic scope (single to single)', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: 'one-test' } } });
            server.route({
                method: 'GET',
                path: '/{id}',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        scope: 'one-params.id}'
                    }
                }
            });

            server.inject({ url: '/test', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('does not match scope (single to single)', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: 'one' } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: 'onex'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('errors on missing scope', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: ['a'] } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: 'b'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('errors on missing scope property', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: 'b'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('errors on missing scope using arrays', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { scope: ['a', 'b'] } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: handler,
                    auth: {
                        scope: ['c', 'd']
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('ignores default scope when override set to null', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: {} } });
            server.auth.default({
                strategy: 'default',
                scope: 'one'
            });

            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        scope: false
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('matches user entity', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { user: 'steve' } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        entity: 'user'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('errors on missing user entity', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { client: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        entity: 'user'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom client' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('matches app entity', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { client: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        entity: 'app'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom client' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('errors on missing app entity', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { user: 'steve' } } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        entity: 'app'
                    }
                }
            });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(403);
                done();
            });
        });

        it('logs error code when authenticate returns a non-error error', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('test', function (srv, options) {

                return {
                    authenticate: function (request, reply) {

                        return reply('Redirecting ...').redirect('/test');
                    }
                };
            });

            server.auth.strategy('test', 'test', true, {});

            server.route({
                method: 'GET',
                path: '/',
                handler: function (request, reply) {

                    return reply('test');
                }
            });

            var result;
            server.on('request-internal', function (request, event, tags) {

                if (tags.unauthenticated) {
                    result = event.data;
                }
            });

            server.inject('/', function (res) {

                expect(result).to.equal(302);
                done();
            });
        });

        it('passes the options.artifacts object, even with an auth filter', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: {} } });
            server.route({
                method: 'GET',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.artifacts);
                    },
                    auth: 'default'
                }
            });

            var options = {
                url: '/',
                headers: { authorization: 'Custom steve' },
                credentials: { foo: 'bar' },
                artifacts: { bar: 'baz' }
            };

            server.inject(options, function (res) {

                expect(res.statusCode).to.equal(200);
                expect(res.result.bar).to.equal('baz');
                done();
            });

        });

    });

    describe('payload()', function () {

        it('authenticates request payload', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { validPayload: { payload: null } } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        payload: 'required'
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom validPayload' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('skips when scheme does not support it', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { validPayload: { payload: null } }, payload: false });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom validPayload' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('authenticates request payload (required scheme)', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { validPayload: { payload: null } }, options: { payload: true } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {}
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom validPayload' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('authenticates request payload (required scheme and required route)', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { validPayload: { payload: null } }, options: { payload: true } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        payload: true
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom validPayload' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('throws when scheme requires payload authentication and route conflicts', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { validPayload: { payload: null } }, options: { payload: true } });
            expect(function () {

                server.route({
                    method: 'POST',
                    path: '/',
                    config: {
                        handler: function (request, reply) {

                            return reply(request.auth.credentials.user);
                        },
                        auth: {
                            payload: 'optional'
                        }
                    }
                });
            }).to.throw('Cannot set authentication payload to optional when a strategy requires payload validation /');
            done();
        });

        it('throws when strategy does not support payload authentication', function (done) {

            var server = new Hapi.Server();
            server.connection();
            var implementation = function () {

                return { authenticate: internals.implementation().authenticate };
            };

            server.auth.scheme('custom', implementation);
            server.auth.strategy('default', 'custom', true, {});
            expect(function () {

                server.route({
                    method: 'POST',
                    path: '/',
                    config: {
                        handler: function (request, reply) {

                            return reply(request.auth.credentials.user);
                        },
                        auth: {
                            payload: 'required'
                        }
                    }
                });
            }).to.throw('Payload validation can only be required when all strategies support it in path: /');
            done();
        });

        it('throws when no strategy supports optional payload authentication', function (done) {

            var server = new Hapi.Server();
            server.connection();
            var implementation = function () {

                return { authenticate: internals.implementation().authenticate };
            };

            server.auth.scheme('custom', implementation);
            server.auth.strategy('default', 'custom', true, {});
            expect(function () {

                server.route({
                    method: 'POST',
                    path: '/',
                    config: {
                        handler: function (request, reply) {

                            return reply(request.auth.credentials.user);
                        },
                        auth: {
                            payload: 'optional'
                        }
                    }
                });
            }).to.throw('Payload authentication requires at least one strategy with payload support in path: /');
            done();
        });

        it('allows one strategy to supports optional payload authentication while another does not', function (done) {

            var server = new Hapi.Server();
            server.connection();
            var implementation = function () {

                return { authenticate: internals.implementation().authenticate };
            };

            server.auth.scheme('custom1', implementation);
            server.auth.scheme('custom2', internals.implementation);
            server.auth.strategy('default1', 'custom1', {});
            server.auth.strategy('default2', 'custom2', {});
            expect(function () {

                server.route({
                    method: 'POST',
                    path: '/',
                    config: {
                        handler: function (request, reply) {

                            return reply(request.auth.credentials.user);
                        },
                        auth: {
                            strategies: ['default2', 'default1'],
                            payload: 'optional'
                        }
                    }
                });
            }).to.not.throw();
            done();
        });

        it('skips request payload by default', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { skip: {} } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom skip' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('skips request payload when unauthenticated', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { skip: {} } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply();
                    },
                    auth: {
                        mode: 'try',
                        payload: 'required'
                    }
                }
            });

            server.inject({ method: 'POST', url: '/' }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('skips optional payload', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { optionalPayload: { payload: Boom.unauthorized(null, 'Custom') } } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        payload: 'optional'
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom optionalPayload' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                done();
            });
        });

        it('errors on missing payload when required', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { optionalPayload: { payload: Boom.unauthorized(null, 'Custom') } } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        payload: 'required'
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom optionalPayload' } }, function (res) {

                expect(res.statusCode).to.equal(401);
                done();
            });
        });

        it('errors on invalid payload auth when required', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { optionalPayload: { payload: Boom.unauthorized() } } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        payload: 'required'
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom optionalPayload' } }, function (res) {

                expect(res.statusCode).to.equal(401);
                done();
            });
        });

        it('errors on invalid request payload (non error)', function (done) {

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { invalidPayload: { payload: 'Payload is invalid' } } });
            server.route({
                method: 'POST',
                path: '/',
                config: {
                    handler: function (request, reply) {

                        return reply(request.auth.credentials.user);
                    },
                    auth: {
                        payload: 'required'
                    }
                }
            });

            server.inject({ method: 'POST', url: '/', headers: { authorization: 'Custom invalidPayload' } }, function (res) {

                expect(res.statusCode).to.equal(200);
                expect(res.result).to.equal('Payload is invalid');
                done();
            });
        });
    });

    describe('response()', function () {

        it('fails on response error', function (done) {

            var handler = function (request, reply) {

                return reply(request.auth.credentials.user);
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', true, { users: { steve: { response: Boom.internal() } } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res) {

                expect(res.statusCode).to.equal(500);
                done();
            });
        });
    });

    describe('test()', function () {

        it('tests a request', function (done) {

            var handler = function (request, reply) {

                request.server.auth.test('default', request, function (err, credentials) {

                    if (err) {
                        return reply({ status: false });
                    }

                    return reply({ status: true, user: credentials.name });
                });
            };

            var server = new Hapi.Server();
            server.connection();
            server.auth.scheme('custom', internals.implementation);
            server.auth.strategy('default', 'custom', { users: { steve: { name: 'steve' } } });
            server.route({ method: 'GET', path: '/', handler: handler });

            server.inject('/', function (res1) {

                expect(res1.statusCode).to.equal(200);
                expect(res1.result.status).to.equal(false);

                server.inject({ url: '/', headers: { authorization: 'Custom steve' } }, function (res2) {

                    expect(res2.statusCode).to.equal(200);
                    expect(res2.result.status).to.equal(true);
                    expect(res2.result.user).to.equal('steve');
                    done();
                });
            });
        });
    });
});

internals.implementation = function (server, options) {

    var settings = Hoek.clone(options);

    if (settings &&
        settings.route) {

        server.route({
            method: 'GET',
            path: '/',
            handler: function (request, reply) {

                return reply(request.auth.credentials.user);
            }
        });
    }

    var scheme = {
        authenticate: function (request, reply) {

            var req = request.raw.req;
            var authorization = req.headers.authorization;
            if (!authorization) {
                return reply(Boom.unauthorized(null, 'Custom'));
            }

            var parts = authorization.split(/\s+/);
            if (parts.length !== 2) {
                return reply.continue();        // Error without error or credentials
            }

            var username = parts[1];
            var credentials = settings.users[username];

            if (!credentials) {
                return reply(Boom.unauthorized('Missing credentials', 'Custom'));
            }

            if (credentials === 'skip') {
                return reply(Boom.unauthorized(null, 'Custom'));
            }

            if (credentials === 'throw') {
                throw new Error('Boom');
            }

            if (typeof credentials === 'string') {
                return reply(credentials);
            }

            return reply.continue({ credentials: credentials });
        },
        response: function (request, reply) {

            if (request.auth.credentials.response) {
                return reply(request.auth.credentials.response);
            }

            return reply.continue();
        }
    };

    if (!settings ||
        settings.payload !== false) {

        scheme.payload = function (request, reply) {

            if (request.auth.credentials.payload) {
                return reply(request.auth.credentials.payload);
            }

            return reply.continue();
        };
    }

    if (settings &&
        settings.options) {

        scheme.options = settings.options;
    }

    return scheme;
};


text:
class <%= @current_new_controller %> < <%= @current_old_controller %>
end


text:
FROM jenkins:2.32.3

USER root
RUN mkdir /cdb
RUN chown -R  jenkins:jenkins /cdb
RUN mkdir /cdb_war
RUN chown -R  jenkins:jenkins /cdb_war
RUN apt-get update \
      && apt-get install -y sudo \
      && rm -rf /var/lib/apt/lists/*
RUN echo "jenkins ALL=NOPASSWD: ALL" >> /etc/sudoers
RUN groupadd -g 999 docker && usermod -a -G docker jenkins

USER jenkins


text:
#include "FSM.h"
#include "State.h"
#include "RakAssert.h"

FSM::FSM()
{

}
FSM::~FSM()
{
	Clear();
}
void FSM::Clear(void)
{
	unsigned i;
	if (stateHistory.Size())
		stateHistory[stateHistory.Size()-1]->OnLeave(this, true);
	for (i=0; i < stateHistory.Size(); i++)
		stateHistory[i]->FSMRemoveRef(this);
	stateHistory.Clear(false, _FILE_AND_LINE_);
}
State *FSM::CurrentState(void) const
{
	if (stateHistory.Size()==0)
		return 0;
	return stateHistory[stateHistory.Size()-1];
}
State *FSM::GetState(int index) const
{
	RakAssert(index>=0 && index < (int) stateHistory.Size());
	return stateHistory[(unsigned) index];
}
int FSM::GetStateIndex(State *state) const
{
	return (int) stateHistory.GetIndexOf(state);
}
int FSM::GetStateHistorySize(void) const
{
	return stateHistory.Size();
}
void FSM::RemoveState(const int index)
{
	RakAssert(index>=0 && index < (int) stateHistory.Size());
	if (index==stateHistory.Size()-1)
		stateHistory[index]->OnLeave(this, true);
	stateHistory[index]->FSMRemoveRef(this);
	stateHistory.RemoveAtIndex((const unsigned int)index);
	if (index==stateHistory.Size())
		stateHistory[stateHistory.Size()-1]->OnEnter(this, false);
}
void FSM::AddState(State *state)
{
	if (stateHistory.Size())
		stateHistory[stateHistory.Size()-1]->OnLeave(this, false);
	state->FSMAddRef(this);
	state->OnEnter(this, true);
	stateHistory.Insert(state, _FILE_AND_LINE_ );
}
void FSM::ReplaceState(const int index, State *state)
{
	RakAssert(index>=0 && index < (int) stateHistory.Size());
	if (state!=stateHistory[index])
	{
		if (index==stateHistory.Size()-1)
			stateHistory[index]->OnLeave(this, true);
		stateHistory[index]->FSMRemoveRef(this);
		state->FSMAddRef(this);
		if (index==stateHistory.Size()-1)
			state->OnEnter(this, true);
		stateHistory[index]=state;
	}
}
void FSM::SetPriorState(const int index)
{
	RakAssert(index>=0 && index < (int) stateHistory.Size());
	stateHistory[stateHistory.Size()-1]->OnLeave(this, true);
	for (unsigned i=stateHistory.Size()-1; i > (unsigned) index; --i)
	{
		stateHistory[i]->FSMRemoveRef(this);
		stateHistory.RemoveFromEnd();
	}
	stateHistory[index]->OnEnter(this, false);
}


text:
// -----------------------------------------------------------------------
// <copyright file="AuthenticationProvider.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// -----------------------------------------------------------------------

namespace Microsoft.Store.PartnerCenter.Storefront.Security
{
    using System;
    using System.Net.Http;
    using System.Threading.Tasks;
    using Configuration;
    using Graph;
    using IdentityModel.Clients.ActiveDirectory;

    /// <summary>
    /// Authentication provider for the Microsoft Graph service client.
    /// </summary>
    /// <seealso cref="IAuthenticationProvider" />
    public class AuthenticationProvider : IAuthenticationProvider
    {
        /// <summary>
        /// Name of the authentication header to be utilized.
        /// </summary>
        private const string AuthHeaderName = "Authorization";

        /// <summary>
        /// The type of token being utilized for the authentication request.
        /// </summary>
        private const string TokenType = "Bearer";

        /// <summary>
        /// Provides the ability to request access tokens.
        /// </summary>
        private readonly IAccessTokenProvider tokenProvider;

        /// <summary>
        /// Address to return to upon receiving a response from the authority.
        /// </summary>
        private readonly Uri redirectUri;

        /// <summary>
        /// The authorization code received from service authorization endpoint.
        /// </summary>
        private readonly string authorizationCode;

        /// <summary>
        /// The customer identifier utilized to scope the Microsoft Graph requests.
        /// </summary>
        private readonly string customerId;

        /// <summary>
        /// Initializes a new instance of the <see cref="AuthenticationProvider"/> class.
        /// </summary>
        /// <param name="customerId">Identifier for customer whose resources are being accessed.</param>
        /// <param name="authorizationCode">The authorization code received from service authorization endpoint.</param>
        /// <param name="redirectUri">Address to return to upon receiving a response from the authority.</param>
        /// <exception cref="ArgumentException">
        /// <paramref name="customerId"/> is empty or null.
        /// or
        /// <paramref name="authorizationCode"/> is empty or null.
        /// </exception>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="redirectUri"/> is null.
        /// </exception>
        public AuthenticationProvider(string customerId, string authorizationCode, Uri redirectUri)
        {
            customerId.AssertNotEmpty(nameof(customerId));
            authorizationCode.AssertNotNull(nameof(authorizationCode));
            redirectUri.AssertNotNull(nameof(redirectUri));

            this.customerId = customerId;
            this.authorizationCode = authorizationCode;
            this.redirectUri = redirectUri;

            tokenProvider = new AccessTokenProvider();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AuthenticationProvider"/> class.
        /// </summary>
        /// <param name="tokenProvider">Provides the ability to request access tokens.</param>
        /// <param name="customerId">Identifier for customer whose resources are being accessed.</param>
        /// <param name="authorizationCode">The authorization code received from service authorization endpoint.</param>
        /// <param name="redirectUri">Address to return to upon receiving a response from the authority.</param>
        /// <exception cref="ArgumentException">
        /// <paramref name="customerId"/> is empty or null.
        /// or
        /// <paramref name="authorizationCode"/> is empty or null.
        /// </exception>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="tokenProvider"/> is null.
        /// or
        /// <paramref name="redirectUri"/> is null.
        /// </exception>
        public AuthenticationProvider(IAccessTokenProvider tokenProvider, string customerId, string authorizationCode, Uri redirectUri)
        {
            tokenProvider.AssertNotNull(nameof(tokenProvider));
            customerId.AssertNotEmpty(nameof(customerId));
            authorizationCode.AssertNotEmpty(nameof(authorizationCode));
            redirectUri.AssertNotNull(nameof(redirectUri));

            this.customerId = customerId;
            this.authorizationCode = authorizationCode;
            this.redirectUri = redirectUri;
            this.tokenProvider = tokenProvider;
        }

        /// <summary>
        /// Performs the necessary authentication and injects the required header.
        /// </summary>
        /// <param name="request">The request being made to the Microsoft Graph API.</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
        public async Task AuthenticateRequestAsync(HttpRequestMessage request)
        {
            AuthenticationResult token = await tokenProvider.GetAccessTokenAsync(
                $"{ApplicationConfiguration.ActiveDirectoryEndPoint}{customerId}",
                authorizationCode,
                redirectUri,
                new ClientCredential(
                    ApplicationConfiguration.ActiveDirectoryClientID,
                    ApplicationConfiguration.ActiveDirectoryClientSecret),
                "https://graph.microsoft.com").ConfigureAwait(false);

            request.Headers.Add(AuthHeaderName, $"{TokenType} {token.AccessToken}");
        }
    }
}


text:
suite('ErrorModel', function() {
  suite('#setSubject', function() {
    test('should set subject', function() {
      var error = new coupler.ErrorModel();
      error.setSubject('foo');
      assert.equal('foo', error.getSubject());
    });
  });

  suite('#setMessage', function() {
    test('should set message', function() {
      var error = new coupler.ErrorModel();
      error.setMessage('foo');
      assert.equal('foo', error.getMessage());
    });
  });
});


text:
USE test;

# against reference constraint, should roll back
UPDATE table_1 SET field_2 = 'VARCHAR009'
WHERE field_1 like '100[1-3]';

UPDATE table_1 SET field_2 = 'VARCHAR009'
WHERE field_1 like '100[1-3]' and
      field_1 < 1002;

# against reference constraint, should roll back
DELETE from table_2
WHERE field_1 > 000;

DELETE from table_2
WHERE field_1 like '.?103';


text:
<?php

namespace CleDiscount\CatalogueBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class CommandeController extends Controller {

    public function commandeAction() {
        return $this->render('CleDiscountCatalogueBundle:Commande:commande.html.twig');
    }

    public function panierAction() {
        return $this->render('CleDiscountCatalogueBundle:Commande:panier.html.twig');
    }

    public function faqcommandeAction() {
        return $this->render('CleDiscountCatalogueBundle:Commande:faqcommande.html.twig');
    }
}

?>


text:
function [params, names] = rbfperiodic2KernExtractParam(kern)

% RBFPERIODIC2KERNEXTRACTPARAM Extract parameters from the RBFPERIODIC2 kernel structure.
% FORMAT
% DESC extracts parameters from the RBF periodic covariance with variying period
% kernel structure into a vector of parameters for optimisation.
% ARG kern : the kernel structure containing the parameters to be
% extracted.
% RETURN param : vector of parameters extracted from the kernel. If
% the field 'transforms' is not empty in the kernel structure, the
% parameters will be transformed before optimisation (for example
% positive only parameters could be logged before being returned).
%
% FORMAT
% DESC extracts parameters and parameter names from the RBF periodic covariance with variying period
% kernel structure.
% ARG kern : the kernel structure containing the parameters to be
% extracted.
% RETURN param : vector of parameters extracted from the kernel. If
% the field 'transforms' is not empty in the kernel structure, the
% parameters will be transformed before optimisation (for example
% positive only parameters could be logged before being returned).
% RETURN names : cell array of strings containing names for each
% parameter.
%
% SEEALSO rbfperiodic2KernParamInit, rbfperiodic2KernExpandParam, kernExtractParam, scg, conjgrad
%
% COPYRIGHT : Neil D. Lawrence, 2007, 2009
%
%
% MODIFICATIONS : Andreas C. Damianou, 2011
%
% MODIFICATIONS : Michalis K. Titsias, 2011

% KERN

params = [kern.inverseWidth kern.variance kern.factor];
if nargout > 1
  names={'inverse width', 'variance', 'factor'};
end


text:
CreateBundleTargetGenerator::CreateBundleTargetGenerator(
    Target* target,
    Scope* scope,
    const FunctionCallNode* function_call,
    Err* err)
    : TargetGenerator(target, scope, function_call, err) {}

CreateBundleTargetGenerator::~CreateBundleTargetGenerator() {}

void CreateBundleTargetGenerator::DoRun() {
  target_->set_output_type(Target::CREATE_BUNDLE);

  BundleData& bundle_data = target_->bundle_data();
  if (!GetBundleDir(SourceDir(),
                    variables::kBundleRootDir,
                    &bundle_data.root_dir()))
    return;
  if (!GetBundleDir(bundle_data.root_dir(),
                    variables::kBundleResourcesDir,
                    &bundle_data.resources_dir()))
    return;
  if (!GetBundleDir(bundle_data.root_dir(),
                    variables::kBundleExecutableDir,
                    &bundle_data.executable_dir()))
    return;
  if (!GetBundleDir(bundle_data.root_dir(),
                    variables::kBundlePlugInsDir,
                    &bundle_data.plugins_dir()))
    return;

  const Value* value = scope_->GetValue(variables::kProductType, true);
  if (value) {
    if (!value->VerifyTypeIs(Value::STRING, err_))
      return;

    bundle_data.product_type().assign(value->string_value());
  }
}

bool CreateBundleTargetGenerator::GetBundleDir(
    const SourceDir& bundle_root_dir,
    const base::StringPiece& name,
    SourceDir* bundle_dir) {
  const Value* value = scope_->GetValue(name, true);
  if (!value)
    return true;
  if (!value->VerifyTypeIs(Value::STRING, err_))
    return false;
  std::string str = value->string_value();
  if (!str.empty() && str[str.size() - 1] != '/')
    str.push_back('/');
  if (!EnsureStringIsInOutputDir(GetBuildSettings()->build_dir(), str,
                                 value->origin(), err_))
    return false;
  if (str != bundle_root_dir.value() &&
      !IsStringInOutputDir(bundle_root_dir, str)) {
    *err_ = Err(value->origin(), "Path is not in bundle root dir.",
        "The given file should be in the bundle root directory or below.\n"
        "Normally you would do \"$bundle_root_dir/foo\". I interpreted this\n"
        "as \"" + str + "\".");
    return false;
  }
  bundle_dir->SwapValue(&str);
  return true;
}


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Lilloa 22: 245 (1951)

#### Original name
Lentinus americanus Peck, 1902

### Remarks
null


text:
using System.Collections.Generic;
using System.Threading;
using OpenMetaverse;
using Nini.Config;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
using OpenSim.Region.CoreModules.Avatar.NPC;
using OpenSim.Framework;
using Timer=System.Timers.Timer;
using OpenSim.Services.Interfaces;

namespace OpenSim.Region.OptionalModules.World.NPC
{
    public class NPCModule : IRegionModule, INPCModule
    {
        // private const bool m_enabled = false;

        private Mutex m_createMutex;
        private Timer m_timer;

        private Dictionary<UUID,NPCAvatar> m_avatars = new Dictionary<UUID, NPCAvatar>();
        private Dictionary<UUID,AvatarAppearance> m_appearanceCache = new Dictionary<UUID, AvatarAppearance>();

        // Timer vars.
        private bool p_inUse = false;
        private readonly object p_lock = new object();
        // Private Temporary Variables.
        private string p_firstname;
        private string p_lastname;
        private Vector3 p_position;
        private Scene p_scene;
        private UUID p_cloneAppearanceFrom;
        private UUID p_returnUuid;

        private AvatarAppearance GetAppearance(UUID target, Scene scene)
        {
            if (m_appearanceCache.ContainsKey(target))
                return m_appearanceCache[target];

            AvatarAppearance appearance = scene.AvatarService.GetAppearance(target);
            if (appearance != null)
            {
                m_appearanceCache.Add(target, appearance);
                return appearance;
            }

            return new AvatarAppearance();
        }

        public UUID CreateNPC(string firstname, string lastname,Vector3 position, Scene scene, UUID cloneAppearanceFrom)
        {
            // Block.
            m_createMutex.WaitOne();

            // Copy Temp Variables for Timer to pick up.
            lock (p_lock)
            {
                p_firstname = firstname;
                p_lastname = lastname;
                p_position = position;
                p_scene = scene;
                p_cloneAppearanceFrom = cloneAppearanceFrom;
                p_inUse = true;
                p_returnUuid = UUID.Zero;
            }

            while (p_returnUuid == UUID.Zero)
            {
                Thread.Sleep(250);
            }

            m_createMutex.ReleaseMutex();

            return p_returnUuid;
        }

        public void Autopilot(UUID agentID, Scene scene, Vector3 pos)
        {
            lock (m_avatars)
            {
                if (m_avatars.ContainsKey(agentID))
                {
                    ScenePresence sp;
                    scene.TryGetScenePresence(agentID, out sp);
                    sp.DoAutoPilot(0, pos, m_avatars[agentID]);
                }
            }
        }

        public void Say(UUID agentID, Scene scene, string text)
        {
            lock (m_avatars)
            {
                if (m_avatars.ContainsKey(agentID))
                {
                    m_avatars[agentID].Say(text);
                }
            }
        }

        public void DeleteNPC(UUID agentID, Scene scene)
        {
            lock (m_avatars)
            {
                if (m_avatars.ContainsKey(agentID))
                {
                    scene.RemoveClient(agentID);
                    m_avatars.Remove(agentID);
                }
            }
        }

        public void Initialise(Scene scene, IConfigSource source)
        {
            m_createMutex = new Mutex(false);

            m_timer = new Timer(500);
            m_timer.Elapsed += m_timer_Elapsed;
            m_timer.Start();

            scene.RegisterModuleInterface<INPCModule>(this);
        }

        void m_timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            lock (p_lock)
            {
                if (p_inUse)
                {
                    p_inUse = false;

                    NPCAvatar npcAvatar = new NPCAvatar(p_firstname, p_lastname, p_position, p_scene);
                    npcAvatar.CircuitCode = (uint) Util.RandomClass.Next(0, int.MaxValue);

                    p_scene.AddNewClient(npcAvatar);

                    ScenePresence sp;
                    if (p_scene.TryGetScenePresence(npcAvatar.AgentId, out sp))
                    {
                        AvatarAppearance x = GetAppearance(p_cloneAppearanceFrom, p_scene);

                        sp.Appearance.SetTextureEntries(x.Texture);
                        sp.Appearance.SetVisualParams((byte[])x.VisualParams.Clone());
                        sp.SendAppearanceToAllOtherAgents();
                    }

                    m_avatars.Add(npcAvatar.AgentId, npcAvatar);

                    p_returnUuid = npcAvatar.AgentId;
                }
            }
        }

        public void PostInitialise()
        {
        }

        public void Close()
        {
        }

        public string Name
        {
            get { return "NPCModule"; }
        }

        public bool IsSharedModule
        {
            get { return true; }
        }
    }
}


text:
const start = require('../../../db');
const config = require('../../../config');
const client = start.client;
const activityDAO = require('../../index').activity;
const followDAO = require('../../index').follow;
const circleDAO = require('../../index').circle;

function getOpenMailboxes(range, callback) {
  const offset = parseInt(range.offset);
  const count = parseInt(range.count);
  const users = (Object.keys(activityDAO.listeners)).slice(offset, (offset+count));
  const response = {
    record_count: users.length,
    total_count: Object.keys(activityDAO.listeners).length,
    records: users,
  };
  return callback(null, response);
}

function getAllActivitiesOfACircle(circleId, range, callback) {
  const before=parseInt(range.before);
  const after=parseInt(range.after);
  const limit= parseInt(range.limit);
  const activityObject = (activityDAO.activities).filter(activity => activity.circleId === circleId);
  const activity= activityObject.map(filteredActivity => filteredActivity.mailboxId)
    .slice(after, (after+limit));
  const response = {
    record_count: activity.length,
    total_count: activityObject.length,
    records: activity,
  };

  callback(null, response);
}
function getAllCircles(mailboxId, callback) {
     const query = (`SELECT * from circlesfollowedbymailbox where mailboxId = ${mailboxId}`);
    client.execute(query, (error, result) => {
      if (error) {
        return callback(error, null);
      }

       let a = result.rows.length;
      let b = result.rows;
      return callback(null, {a,b});
           });
  }

module.exports = {
  getOpenMailboxes,
  getAllCircles,
  getAllActivitiesOfACircle,
};


text: {% include "reports/async/filters.html" %}


text:
"""Copy a file or directory. Multiple source files may be specified if the destination is
an existing directory.
"""

from __future__ import print_function

import argparse
import os
import shutil

def pprint(path):
    if path.startswith(os.environ['HOME']):
        return '~' + path.split(os.environ['HOME'], 1)[-1]
    return path

def main(args):
    ap = argparse.ArgumentParser()
    ap.add_argument('source', nargs='+', help='one or more files or directories to be copied')
    ap.add_argument('dest', help='destination file or folder')
    ns = ap.parse_args(args)

    files = ns.source
    dest = ns.dest

    if len(files) > 1:
        # Copying multiple files, destination must be an existing directory.
        if os.path.isdir(dest):
            full_dest = os.path.abspath(dest)
            for filef in files:
                full_file = os.path.abspath(filef)
                file_name = os.path.basename(full_file)
                new_name  = os.path.join(full_dest, file_name)

                try:
                    if os.path.isdir(full_file):
                        shutil.copytree(full_file, new_name)
                    else:
                        shutil.copy(full_file, new_name)
                except Exception as err:
                    print("cp: {}: {!s}".format(type(err).__name__, err), file=sys.stderr)
        else:
            print("cp: {}: No such directory".format(pprint(dest)), file=sys.stderr)
    else:
        # Copying a single file to a (pre-existing) directory or a file
        filef = files[0]
        full_file = os.path.abspath(filef)
        file_name = os.path.basename(full_file)
        full_dest = os.path.abspath(dest)
        new_name = os.path.join(full_dest, file_name)
        if os.path.exists(full_file):
            try:
                if os.path.exists(full_dest):
                    # Destination already exists
                    if os.path.isdir(full_dest):
                        # Destination is a directory
                        if os.path.isdir(full_file):
                            shutil.copytree(full_file, new_name)
                        else:
                            shutil.copy(full_file, new_name)
                    else:
                        # Destination is a file
                        shutil.copy(full_file, full_dest)
                else:
                    # Destination does not yet exist
                    if os.path.isdir(full_file):
                        # Source is a directory, destination should become a directory
                        shutil.copytree(full_file,full_dest)
                    else:
                        # Source is a file, destination should become a file
                        shutil.copy(full_file,full_dest)
            except Exception as err:
                print("cp: {}: {!s}".format(type(err).__name__, err), file=sys.stderr)
        else:
            print("cp: {}: No such file".format(pprint(filef)), file=sys.stderr)

if __name__ == "__main__":
    main(sys.argv[1:])


text:
include ../common/make/Make.defs

SUBDIRS = svcbuilder purgelog client gearbox_tools

include ../common/make/Make.rules