text:
@interface ShareFileSDKQueryTests : ShareFileSDKTests

@end

@implementation ShareFileSDKQueryTests

- (void)testQueryInit {
    SFApiQuery *query = [[SFApiQuery alloc] initWithClient:self.client];
    XCTAssertEqual(self.client, query.client, @"Did not init with passed parameters");
}

- (void)testQuerySetupTest {
    SFApiQuery *query = [[SFApiQuery alloc] initWithClient:self.client];
    query.httpMethod = @"POST";
    query.from = @"entity";
    [query setAction:@"action"];
    [query addIds:@"id1"];
    [query addIds:@"id2"];
    [query addActionIds:@"act1" withKey:@"kact1"];
    [query addActionIds:@"act2"];
    [query addSubAction:@"subaction1" withValue:@"subact1"];
    [query addSubAction:@"subaction2" key:@"ksubact2" withValue:@"subact2"];
    [query addSubAction:@"subaction3"];
    [query addQueryString:@"k1" withValue:@"q1"];
    [query addQueryString:@"k2" withValue:@"q2"];
    NSDictionary *dict = @{ @"test" : @"test" };
    query.body = dict;
    [query selectProperty:@"test11"];
    [query expandProperty:@"test12"];
    [query selectProperties:@[@"test21"]];
    [query expandProperties:@[@"test22"]];
    [query skip:10];
    [query top:20];
    [query addHeaderWithKey:@"headerKey" value:@"headerValue"];
    id <SFAFilter> filter = [[SFAEndsWithFilter alloc] initWithPropertyName:@"test31" value:@"abc" isEqual:YES];
    [query filterBy:filter];
    // Test
    XCTAssertTrue([query.httpMethod isEqualToString:@"POST"], @"Expected method to be POST.");
    XCTAssertTrue([query.from isEqualToString:@"entity"], @"Unexpected value returned for from.");
    XCTAssertTrue(query.ids.count == 2, @"Unexpected value returned for ids.count.");
    BOOL foundValue1 = NO;
    BOOL foundValue2 = NO;
    id <NSFastEnumeration> enumerable = [query.ids collectionAsFastEnumrable];
    for (SFAODataParameter *param in enumerable) {
        if ([param.value isEqualToString:@"id1"]) {
            foundValue1 = YES;
        }
        if ([param.value isEqualToString:@"id2"]) {
            foundValue2 = YES;
        }
    }
    XCTAssertTrue(foundValue1 && foundValue2, @"Expected all added ids to be found.");
    XCTAssertTrue([query.action.actionName isEqualToString:@"action"], @"Unexpected value returned for action.actionName.");
    XCTAssertTrue(query.action.parameters.count == 2, @"Unexpected value returned for action.parameters.count.");
    foundValue1 = NO;
    foundValue2 = NO;
    enumerable = [query.action.parameters collectionAsFastEnumrable];
    for (SFAODataParameter *param in enumerable) {
        if ([param.value isEqualToString:@"act1"] && [param.key isEqualToString:@"kact1"]) {
            foundValue1 = YES;
        }
        if ([param.value isEqualToString:@"act2"]) {
            foundValue2 = YES;
        }
    }
    XCTAssertTrue(foundValue1 && foundValue2, @"Expected all added actions to be found.");
    // subaction1
    foundValue1 = NO;
    SFAODataAction *subaction = query.subActions[0];
    XCTAssertTrue([subaction.actionName isEqualToString:@"subaction1"], @"* Unexpected value returned for subaction.actionNames.");
    enumerable = [subaction.parameters collectionAsFastEnumrable];
    for (SFAODataParameter *param in enumerable) {
        if ([param.value isEqualToString:@"subact1"]) {
            foundValue1 = YES;
        }
        break;
    }
    XCTAssertTrue(foundValue1, @"* Unexpected value returned for subaction value.");
    // subaction2
    foundValue1 = NO;
    subaction = query.subActions[1];
    XCTAssertTrue([subaction.actionName isEqualToString:@"subaction2"], @"** Unexpected value returned for subaction.actionNames.");
    enumerable = [subaction.parameters collectionAsFastEnumrable];
    for (SFAODataParameter *param in enumerable) {
        if ([param.value isEqualToString:@"subact2"] && [param.key isEqualToString:@"ksubact2"]) {
            foundValue1 = YES;
        }
        break;
    }
    XCTAssertTrue(foundValue1, @"** Unexpected key value returned for subaction.");
    // subaction3
    subaction = query.subActions[2];
    XCTAssertTrue([subaction.actionName isEqualToString:@"subaction3"], @"*** Unexpected value returned for subaction.actionNames.");
    XCTAssertTrue(subaction.parameters.count == 0, @"*** Unexpected value returned for subaction.parameters.count");
    // query sring
    foundValue1 = NO;
    foundValue2 = NO;
    XCTAssertTrue(query.queryString.count == 2, @"Unexpected count returned for query.queryString.count.");
    enumerable = [query.queryString collectionAsFastEnumrable];
    for (SFAODataParameter *param in enumerable) {
        if ([param.key isEqualToString:@"k1"] && [param.value isEqualToString:@"q1"]) {
            foundValue1 = YES;
        }
        if ([param.key isEqualToString:@"k2"] && [param.value isEqualToString:@"q2"]) {
            foundValue2 = YES;
        }
    }
    XCTAssertTrue(foundValue1 && foundValue2, @"Unexpected key value pairs returned for queryString.");
    // body
    XCTAssertEqual(query.body, dict, @"Unexpected value returned for body.");
    // select expand
    BOOL fail = NO;
    XCTAssertTrue(query.selectProperties.count == 2, @"Unexpected count of selectProperties returned.");
    XCTAssertTrue(query.expandProperties.count == 2, @"Unexpected coutn of expandProperties returned.");
    for (int i = 1; i <= 2; i++) {
        if (![query.selectProperties[i - 1] isEqualToString:[NSString stringWithFormat:@"test%d1", i]] || ![query.expandProperties[i - 1] isEqualToString:[NSString stringWithFormat:@"test%d2", i]]) {
            fail = YES;
            break;
        }
    }
    XCTAssertFalse(fail, @"Unexpected select/expand property found returned.");
    // skip top
    XCTAssertTrue(query.skip == 10, @"Unexpected value returned for skip.");
    XCTAssertTrue(query.top == 20, @"Unexpected value returned for top.");
    // header
    XCTAssertTrue(query.headers.count == 1, @"Unexpected header count returned.");
    for (NSString *key in query.headers) {
        XCTAssertTrue([key isEqualToString:@"headerKey"], @"Unexpected value returned for header key.");
        XCTAssertTrue([query.headers[key] isEqualToString:@"headerValue"], @"Unexpected value returned for header value.");
    }
}

@end


text:
package io.atomix.primitive.session;

import io.atomix.utils.Managed;

/**
 * Managed session ID service.
 */
public interface ManagedSessionIdService extends SessionIdService, Managed<SessionIdService> {
}

redpajama_set_name: RedPajamaGithub


text:
<bill session="110" type="hc" number="319" updated="2009-01-08T16:07:01-05:00">
	<status><introduced date="1205467200" datetime="2008-03-14"/></status>

	<introduced date="1205467200" datetime="2008-03-14"/>
	<titles>
		<title type="official" as="introduced">Recognizing March 19, 2008, as the fifth anniversary of the Iraq war and urging President George W. Bush to begin an immediate and safe redeployment of United States Armed Forces from Iraq.</title>
	</titles>
	<sponsor id="400430"/>
	<cosponsors>

	</cosponsors>
	<actions>
		<action date="1205467200" datetime="2008-03-14"><text>Referred to the Committee on Armed Services, and in addition to the Committee on Foreign Affairs, for a period to be subsequently determined by the Speaker, in each case for consideration of such provisions as fall within the jurisdiction of the committee concerned.</text></action>
		<action date="1205467200" datetime="2008-03-14"><text>Referred to House Armed Services</text></action>
		<action date="1205467200" datetime="2008-03-14"><text>Referred to House Foreign Affairs</text></action>
	</actions>
	<committees>

	</committees>
	<relatedbills>

	</relatedbills>
	<subjects>

	</subjects>
	<amendments>

	</amendments>

	3/14/2008--Introduced.
Recognizes and honors the sacrifice of the members of the U.S. Armed Forces and their families on the fifth anniversary of the Iraq war.
Urges President George W. Bush: (1) not to enter into any long-term United States-Iraq strategic agreement without the approval of Congress; (2) to begin an immediate and safe redeployment of forces from Iraq; and (3) to live up to his responsibilities and adequately provide health care assistance to U.S. troops returning from Iraq and Afghanistan.

</bill>


text:
<phpunit
    beStrictAboutOutputDuringTests="true"
>
    <testsuite name="all">
        <directory>.</directory>
    </testsuite>
    <coverage processUncoveredFiles="true">
        <include>
            <directory>../src</directory>
        </include>
    </coverage>
</phpunit>


text:
<?php
namespace Jgalenski\DemoBundle\Entity;

use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use DateTime;

/**
 * Jgalenski\DemoBundle\Entity\Article
 * @ORM\Entity(repositoryClass="Jgalenski\DemoBundle\Entity\Repository\ArticleRepository")
 * @ORM\Table(name="tumblr_jgalenski_article")
 * @ORM\HasLifecycleCallbacks
 * @author jgalenski
 */
class Article
{

    /**
     * @var integer $id
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    protected $id;

    /**
     * @ORM\Column(type="string", length=255)
     * @Assert\NotBlank()
     * @Assert\MaxLength(limit=255, message="Title: You exceed the {{limit}} charactere limit")
     */
    protected $title;

    /**
     * @ORM\Column(type="text", length=4000)
     * @Assert\NotBlank()
     * @Assert\MaxLength(limit=4000, message="Content: You exceed the {{limit}} charactere limit")
     */
    protected $content;

    /**
     * @ORM\Column(type="text", nullable=true)
     */
    protected $picture;

    protected $picture_tmp;

    /**
     * @ORM\Column(type="datetime")
     */
    protected $created_at;

    function __construct()
    {
        $this->created_at = new DateTime();
    }

    /**
     * @return void
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @param $id
     * @return void
     */
    public function setId($id)
    {
        $this->id = $id;
    }

    /**
     * @return string
     */
    public function getTitle()
    {
        return $this->title;
    }

    /**
     * @param string $title
     * @return void
     */
    public function setTitle($title)
    {
        $this->title = $title;
    }

    /**
     * @return string
     */
    public function getContent()
    {
        return $this->content;
    }

    /**
     * @param string $content
     * @return void
     */
    public function setContent($content)
    {
        $this->content = $content;
    }

    /**
     * @return DateTime
     */
    public function getCreatedAt()
    {
        return $this->created_at;
    }

    /**
     * @return void
     */
    public function getPicture()
    {
        return $this->picture;
    }

    /**
     * @param $picture
     * @return void
     */
    public function setPicture($picture)
    {
        $this->picture = $picture;
    }

    /**
     * @return void
     */
    public function getPictureTmp()
    {
        return $this->picture_tmp;
    }

    /**
     * @param $picture
     * @return void
     */
    public function setPictureTmp($picture)
    {
        $this->picture_tmp = $picture;
    }
}


text:
#define LUA_API		extern "C" __declspec(dllimport)
extern "C"
{
	#include "lua.h"
	#include "lauxlib.h"
	#include "lualib.h"
}

int				LuaCharting_CreateAutomaticLocator(lua_State *L);
int				LuaCharting_CreateCartesiansLocator(lua_State *L);
int				LuaCharting_CreateChart(lua_State *L);
int				LuaCharting_CreateFunctionRenderer(lua_State *L);
int				LuaCharting_AddChart(lua_State *L);
int				LuaCharting_AddChartPoint(lua_State *L);


text:
package ru.gebekovas.c1client;

import android.app.ActionBar;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

/**
 * Created by GebekovAS on 22.02.2015.
 */
public class SettingsActivity extends ActionBarActivity {
    public final String SKEY_MAIN="MAIN";
    public final String SKEY_HOST="HOST_NAME";
    public final String SKEY_LOGIN="LOGIN";
    public final String SKEY_PASSWORD="PASSWORD";
    public final String SKEY_PERIOD_BEGIN="PERIOD_BEGIN";
    public final String SKEY_PERIOD_END="PERIOD_END";
    public final String SKEY_TIMEROUT="PERIOD_TIMEROUT";

    public String gHostName;
    public String gLogin;
    public String gPassword;
    public String gPeriodBegin;
    public String gPeriodEnd;
    public String gTimerOut;

    public final String LOG_KEY="GebekovAS";
    TextView hostEdit;
    TextView loginEdit;
    TextView pwdEdit;
    TextView periodBeginEdit;
    TextView periodEndEdit;
    TextView timerOutEdit;

    @Override
    protected void onPostCreate(Bundle saveIntsanceState) {
        super.onPostCreate(saveIntsanceState);
        setContentView(R.layout.activity_settings);

        hostEdit=(TextView) findViewById(R.id.elHostName);
        loginEdit=(TextView) findViewById(R.id.elLogin);
        pwdEdit=(TextView) findViewById(R.id.elPassword);
        periodBeginEdit=(TextView) findViewById(R.id.elPeriodBegin);
        periodEndEdit=(TextView) findViewById(R.id.elPeriodEnd);
        timerOutEdit=(TextView) findViewById(R.id.elTimerOut);

        //Объект для получения данных из родительского активити
        Intent intent=getIntent();
        Bundle bundle=intent.getExtras();

        //Получаю данные отправленные с родительского активити
        if (!bundle.getString(SKEY_HOST).equals(null)) {
            hostEdit.setText(bundle.getString(SKEY_HOST));
            loginEdit.setText(bundle.getString(SKEY_LOGIN));
            pwdEdit.setText(bundle.getString(SKEY_PASSWORD));
            periodBeginEdit.setText(bundle.getString(SKEY_PERIOD_BEGIN));
            periodEndEdit.setText(bundle.getString(SKEY_PERIOD_END));
            if (bundle.containsKey(SKEY_TIMEROUT)) {
                timerOutEdit.setText(bundle.getString(SKEY_TIMEROUT));
            }
        }

        Button svBtn=(Button) findViewById(R.id.saveBtn);
        svBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d(LOG_KEY,"Saved settings");

                gHostName=hostEdit.getText().toString();
                gLogin=loginEdit.getText().toString();
                gPassword=pwdEdit.getText().toString();
                gPeriodBegin=periodBeginEdit.getText().toString();

                SharedPreferences settingsObj=getSharedPreferences(SKEY_MAIN, Context.MODE_PRIVATE);
                try {
                    SharedPreferences.Editor editor = settingsObj.edit();
                    editor.putString(SKEY_HOST,gHostName);
                    editor.putString(SKEY_LOGIN,gLogin);
                    editor.putString(SKEY_PASSWORD,gPassword);
                    editor.putString(SKEY_PERIOD_BEGIN,gPeriodBegin);
                    editor.putString(SKEY_PERIOD_END,gPeriodEnd);
                    editor.putString(SKEY_TIMEROUT, gTimerOut);
                    Log.d(LOG_KEY,gHostName);
                    editor.apply();
                    finish();

                } catch (Exception e) {
                    Log.d(LOG_KEY,"Errore: "+e.getMessage());
                }
            }
        });

    }
        @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_settings);

    }
}


text:
from __future__ import unicode_literals

from django.db import migrations

from emgapianns import models as m_models

def add_antismash_clusters(apps, schema_editor):
    """antiSMASM GC
    https://docs.antismash.secondarymetabolites.org/glossary/
    """
    genecluster_types = [
        ['acyl_amino_acids', 'N-acyl amino acid cluster'],
        ['amglyccycl', 'Aminoglycoside/aminocyclitol cluster'],
        ['aminocoumarin', 'Aminocoumarin cluster'],
        ['arylpolyene', 'Aryl polyene cluster'],
        ['bacteriocin', 'Bacteriocin or other unspecified ribosomally ' +
                        'synthesised and post-translationally modified peptide product (RiPP) cluster'],
        ['betalactone', 'beta-lactone containing protease inhibitor'],
        ['blactam', 'β-lactam cluster'],
        ['bottromycin', 'Bottromycin cluster'],
        ['butyrolactone', 'Butyrolactone cluster'],
        ['CDPS', 'tRNA-dependent cyclodipeptide synthases'],
        ['cyanobactin', 'Cyanobactin cluster'],
        ['ectoine', 'Ectoine cluster'],
        ['fatty_acid', 'Fatty acid cluster (loose strictness, likely from primary metabolism)'],
        ['fungal-RiPP', 'Fungal RiPP with POP or UstH peptidase types and a modification'],
        ['furan', 'Furan cluster'],
        ['fused', 'Pheganomycin-style protein ligase-containing cluster'],
        ['glycocin', 'Glycocin cluster'],
        ['halogenated', 'Cluster containing a halogenase and thus potentially generating a halogenated product'],
        ['head_to_tail', 'Head-to-tail cyclised (subtilosin-like) cluster'],
        ['hglE-KS', 'heterocyst glycolipid synthase-like PKS'],
        ['hserlactone', 'Homoserine lactone cluster'],
        ['indole', 'Indole cluster'],
        ['ladderane', 'Ladderane cluster'],
        ['lanthipeptide', 'Lanthipeptide cluster'],
        ['LAP', 'Linear azol(in)e-containing peptides'],
        ['lassopeptide', 'Lasso peptide cluster'],
        ['linaridin', 'Linaridin cluster'],
        ['lipolanthine', 'Lanthipeptide class containing N-terminal fatty acids'],
        ['melanin', 'Melanin cluster'],
        ['microviridin', 'Microviridin cluster'],
        ['NAGGN', 'N-acetylglutaminylglutamine amide'],
        ['nrps-like', 'NRPS-like fragment'],
        ['nrps', 'Non-ribosomal peptide synthetase cluster'],
        ['nucleoside', 'Nucleoside cluster'],
        ['oligosaccharide', 'Oligosaccharide cluster'],
        ['other', 'Cluster containing a secondary metabolite-related protein that does not fit into any other category'],
        ['PBDE', 'Polybrominated diphenyl ether cluster'],
        ['phenazine', 'Phenazine cluster'],
        ['phosphoglycolipid', 'Phosphoglycolipid cluster'],
        ['phosphonate', 'Phosphonate cluster'],
        ['PKS-like', 'Other types of PKS cluster'],
        ['PpyS-KS', 'PPY-like pyrone cluster'],
        ['proteusin', 'Proteusin cluster'],
        ['PUFA', 'Polyunsaturated fatty acid cluster'],
        ['RaS-RiPP', 'Streptide-like thioether-bond RiPPs'],
        ['resorcinol', 'Resorcinol cluster'],
        ['saccharide', 'Saccharide cluster (loose strictness, likely from primary metabolism)'],
        ['sactipeptide', 'Sactipeptide cluster'],
        ['siderophore', 'Siderophore cluster'],
        ['T1PKS', 'Type I PKS (Polyketide synthase)'],
        ['T2PKS', 'Type II PKS'],
        ['T3PKS', 'Type III PKS'],
        ['terpene', 'Terpene'],
        ['thioamide-NRP', 'Thioamide-containing non-ribosomal peptide'],
        ['thiopeptide', 'Thiopeptide cluster'],
        ['transAT-PKS', 'Trans-AT PKS fragment, with trans-AT domain not found'],
        ['transAT-PKS', 'Trans-AT PKS']
    ]
    for accession, description in genecluster_types:
        m_models.AntiSmashGeneCluster.objects(accession=accession) \
                                     .modify(upsert=True, new=True, set__description=description)

def remove_antismash_clusters(apps, schema_editor):
    """Remove geneclusters types from mongo
    """
    m_models.AntiSmashGeneCluster.objects.all().delete()

class Migration(migrations.Migration):

    dependencies = [
        ('emgapi', '0017_auto_20190918_1239'),
    ]

    operations = [
         migrations.RunPython(add_antismash_clusters, remove_antismash_clusters),
    ]


text:
<?php

namespace Pterodactyl\Transformers\Api\Client;

use Pterodactyl\Models\Allocation;

class AllocationTransformer extends BaseClientTransformer
{
    /**
     * Return the resource name for the JSONAPI output.
     */
    public function getResourceName(): string
    {
        return 'allocation';
    }

    /**
     * Return basic information about the currently logged in user.
     *
     * @return array
     */
    public function transform(Allocation $model)
    {
        return [
            'id' => $model->id,
            'ip' => $model->ip,
            'ip_alias' => $model->ip_alias,
            'port' => $model->port,
            'notes' => $model->notes,
            'is_default' => $model->server->allocation_id === $model->id,
        ];
    }
}


text:
'''
Created on Apr 15, 2015

@author: christian
'''

from optparse import OptionParser
import numpy

import os
from os import listdir
from os.path import isfile, join
import cPickle
import glob

def unpickle(file):
    fo = open(file, 'rb')
    dictionary = cPickle.load(fo)
    fo.close()
    return dictionary

if __name__ == '__main__':
    optionParser = OptionParser("usage: %prog [options] INPUT_FILE OUTPUT_FILE [WITH_ROTATION]")
    optionParser.add_option("-i", "--input", action="store", dest="input", type="string", metavar="FILE", help="pickled python dataset folder")
    optionParser.add_option("-o", "--output", action="store", dest="output", type="string", metavar="FILE", help="output experiment dataset folder")
    optionParser.add_option("-C", "--classes", action="store", dest="nclasses", type="int", help="number of classes (all, if omitted)", default = 100)
    optionParser.add_option("-I", "--images", action="store", dest="nimages", type="int", help="number of images per class", default = 10)

    #optionParser.add_option("-i", "--input-file", action="store", dest="inputFile", type="string", metavar="FILE", help="additional pickled python dataset (no addition, if omitted)")
    #optionParser.add_option("-R", "--RISCAN", action="store_true", dest="transform", help="add (true) or remove (true) tags", default=False)
    #optionParser.add_option("-Z", "--offset_z", action="store", dest="offset_z", type="float", help="number of images per class added", default = 0.0)
    #optionParser.add_option("-Z", "--offset_z", action="store", dest="offset_z", type="float", help="tag number to add", default = 0.0)

    (options, args) = optionParser.parse_args()

    num_img_base_array = [0]*(options.nclasses)
    img_base_array = [[0]*3072]*(options.nclasses*options.nimages)
    img_array = numpy.array(img_base_array, dtype=numpy.uint8)
    class_array = [0]*(options.nclasses*options.nimages)

    test_img_array = None
    test_array = []
    test_classes = []

    if options.output==None:
        exit()

    if options.input != None:
        #onlyfiles = [ f for f in listdir(options.input) if isfile(join(options.input,f)) ]
        onlyfiles = glob.glob(options.input+os.path.sep+"data_batch*")
        cursor_point = 0
        #for entry in onlyfiles:
        for k in range(0, len(onlyfiles)):
            entry = onlyfiles[k]
            print "Processing file "+entry+" ..."
            #my_obj = dict()
            my_obj = unpickle(entry)
            #print my_obj
            print "Data fieldsize: "+str(my_obj['data'].shape[0])
            for i in range(0, my_obj['data'].shape[0]):
                data_entry = my_obj['data'][i]
                tag_no = my_obj['labels'][i]
                #print "Current tagnumber: "+str(tag_no)
                if (tag_no < options.nclasses) and (num_img_base_array[tag_no]<options.nimages):
                    print "Image: "+str(i)+" => Tag: "+str(tag_no)
                    img_array[cursor_point] = data_entry
                    class_array[cursor_point] = tag_no
                    num_img_base_array[tag_no]+=1
                    cursor_point+=1
    else:
        exit()

    if options.input != None:
        #onlyfiles = [ f for f in listdir(options.input) if isfile(join(options.input,f)) ]

        tcursor_point = 0
        entry = os.path.join(options.input,"test_batch")
        print "Processing file "+entry+" ..."
        #my_obj = dict()
        test_obj = unpickle(entry)
        print "Test Data fieldsize: "+str(test_obj['data'].shape[0])
        #test_img_array = [[0]*3072]*(test_obj['data'].shape[0])
        for i in range(0, test_obj['data'].shape[0]):
            data_entry = test_obj['data'][i]
            tag_no = test_obj['labels'][i]
            if (tag_no < options.nclasses):
                print "Test Image: "+str(i)+" => Tag: "+str(tag_no)
                #test_img_array[tcursor_point] = data_entry
                #class_array[cursor_point] = tag_no
                test_array.append(data_entry.tolist())
                test_classes.append(tag_no)
                tcursor_point+=1
        test_img_array = numpy.array(test_array, dtype=numpy.uint8)
    else:
        exit()

    meta_filenames = []
    meta_filenames += glob.glob(options.input+os.path.sep+"batches.meta*")
    #meta_filenames += glob.glob(options.input+os.path.sep+"*.meta*")
    meta_obj = unpickle(meta_filenames[0])
    label_names = meta_obj['label_names']
    label_names_new = []
    for i in range(0, max(options.nclasses, len(label_names))):
        tag_name = label_names[i]
        print "Tag: "+str(i)+" => Name: "+tag_name
        label_names_new.append(tag_name)

    out_obj = dict()
    out_obj['data']=img_array
    out_obj['labels']=class_array
    #fo = open(os.path.join(options.output,"experiment"), 'wb')
    cPickle.dump(out_obj, open(os.path.join(options.output,"experiment"), "wb"), protocol=2)

    test_n_obj = dict()
    test_n_obj['data']=test_img_array
    test_n_obj['labels']=test_classes
    cPickle.dump(test_n_obj, open(os.path.join(options.output,"test"), "wb"), protocol=2)

    meta_obj_out = dict()
    meta_obj_out['label_names'] = label_names_new
    cPickle.dump(meta_obj_out, open(os.path.join(options.output,"meta"), "wb"), protocol=2)


text:
import request from '@/utils/request'

export function fetchList(query) {
  return request({
    url: '/v1/products',
    method: 'get',
    params: query
  })
}


text:
package com.apollographql.apollo.cache.normalized;

import com.apollographql.apollo.internal.json.CacheJsonStreamReader;
import com.apollographql.apollo.internal.json.JsonWriter;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.List;
import java.util.Map;

import javax.annotation.Nonnull;

import okio.Buffer;
import okio.BufferedSource;
import okio.Okio;

import static com.apollographql.apollo.api.internal.Utils.checkNotNull;
import static com.apollographql.apollo.internal.json.ApolloJsonReader.bufferedSourceJsonReader;
import static com.apollographql.apollo.internal.json.ApolloJsonReader.cacheJsonStreamReader;

/**
 * An adapter used to serialize and deserialize Record fields. Record object types will be serialized to
 * {@link CacheReference}.
 */
public final class RecordFieldJsonAdapter {

  public static RecordFieldJsonAdapter create() {
    return new RecordFieldJsonAdapter();
  }

  private RecordFieldJsonAdapter() {
  }

  public String toJson(@Nonnull Map<String, Object> fields) {
    checkNotNull(fields, "fields == null");
    Buffer buffer = new Buffer();
    JsonWriter jsonWriter = JsonWriter.of(buffer);

    try {
      jsonWriter.beginObject();
      for (Map.Entry<String, Object> fieldEntry : fields.entrySet()) {
        String key = fieldEntry.getKey();
        Object value = fieldEntry.getValue();
        jsonWriter.name(key);
        writeJsonValue(value, jsonWriter);
      }
      jsonWriter.endObject();
      jsonWriter.close();
      return buffer.readUtf8();
    } catch (IOException e) {
      // should never happen as we are working with mem buffer
      throw new RuntimeException(e);
    }
  }

  public Map<String, Object> from(BufferedSource bufferedFieldSource) throws IOException {
    final CacheJsonStreamReader cacheJsonStreamReader =
        cacheJsonStreamReader(bufferedSourceJsonReader(bufferedFieldSource));
    return cacheJsonStreamReader.toMap();
  }

  public Map<String, Object> from(String jsonFieldSource) throws IOException {
    final BufferedSource bufferSource = Okio.buffer(Okio.source(new ByteArrayInputStream(jsonFieldSource.getBytes())));
    return from(bufferSource);
  }

  private static void writeJsonValue(Object value, JsonWriter jsonWriter) throws IOException {
    if (value == null) {
      jsonWriter.nullValue();
    } else if (value instanceof String) {
      jsonWriter.value((String) value);
    } else if (value instanceof Boolean) {
      jsonWriter.value((boolean) value);
    } else if (value instanceof Number) {
      jsonWriter.value((Number) value);
    } else if (value instanceof CacheReference) {
      jsonWriter.value(((CacheReference) value).serialize());
    } else if (value instanceof List) {
      jsonWriter.beginArray();
      for (Object item : (List) value) {
        writeJsonValue(item, jsonWriter);
      }
      jsonWriter.endArray();
    } else {
      throw new RuntimeException("Unsupported record value type: " + value.getClass());
    }
  }
}


text:
using DumbQQ.Models.Abstract;

namespace DumbQQ.Models
{
    public class Message : IClientExclusive
    {
        public enum SourceType
        {
            Friend,
            Group,
            Discussion
        }

        public SourceType Type { get; internal set; }

        public ulong? Timestamp { get; internal set; }

        public string Content { get; internal set; }

        public ulong? SenderId { get; internal set; }

        public ulong? SourceId { get; internal set; }

        public DumbQQClient Client { get; set; }
    }
}


text:
using System;
using System.Linq;

namespace VioletGrass.ProjectModel.ChangeOrders
{
    /// <summary>
    /// Change Order to delete a collaborator from a project.
    /// </summary>
    public class DeleteCollaborator : ChangeOrderBase<Owner>
    {
        private string _personName;
        private string _projectName;

        /// <summary>
        /// Creates a new change order.
        /// </summary>
        /// <param name="projectName">The name of the project.</param>
        /// <param name="personName">The name of the person to remove as collaborator.</param>
        /// <param name="userName">The name of the person who issued this change</param>
        public DeleteCollaborator(string projectName, string personName, string userName)
            : base(userName)
        {
            _personName = personName;
            _projectName = projectName;
        }

        /// <summary>
        /// Apply Method.
        /// </summary>
        /// <param name="original">The original owner.</param>
        /// <returns>The modified owner.</returns>
        public override Owner Apply(Owner original)
        {
            var project = original?.Projects.FirstOrDefault(x => x.Name == _projectName);
            if (project == null)
            {
                throw new InvalidOperationException("owner or project does not exist.");
            }
            if (!ProjectSecurityHelper.IsUserAuthorizedToChangeProjectSettings(UserName, original, project))
            {
                throw new InvalidOperationException("UserName is not authorized on owner to add collaborator.");
            }

            var newCollaborators = project.Collaborators.RemoveAll(c => c.PersonName == _personName);

            var newProject = new Project(project.OwnerName, project.Name, project.Type, project.DisplayName, project.Description, newCollaborators, project.IsPublic);

            return original.WithProjects(original.Projects.Replace(project, newProject));
        }
    }
}


text:
require 'spec_helper'
require 'toy_robot'

describe ExtendedBoard do

  let(:board) { ExtendedBoard.new }

  subject { board }

  it_should_behave_like "a board"

  specify "model attributes" do
    should respond_to(:occupied_positions)
  end

  specify "instance methods" do
    should respond_to(:occupy).with(1).argument
    should respond_to(:change_position).with(2).arguments
    should respond_to(:space_empty?).with(1).argument
  end

  describe "initial state" do
    its(:occupied_positions) { should be_empty }
  end

  describe "#occupy" do
    let(:position) { Position.new(1, 1) }
    before { board.occupy(position) }
    its(:occupied_positions) { should include(position) }
  end

  describe "#change_position" do
    let(:position) { Position.new(1, 1) }
    let(:new_position) { Position.new(2, 2) }

    before do
      board.occupy(position)
      board.change_position(position, new_position)
    end

    its(:occupied_positions) do
      should_not include(position)
      should include(new_position)
    end
  end

  describe "#space_empty?" do
    let(:position) { Position.new(1, 1) }

    before { board.occupy(position) }

    context "when space is not empty" do
      subject { board.space_empty?(position) }
      it { should be false }
    end

    context "when space is empty" do
      let(:empty_position) { Position.new(2, 1) }
      subject { board.space_empty?(empty_position) }
      it { should be true }
    end
  end

  describe "#map" do
    let(:map) { board.map }

    subject { map.gsub(ansi_colors, '') }

    context "before a #place" do
      let(:expected_map) { false }
      before do
        allow(board).to receive_message_chain(:map, :gsub).and_return(false)
      end
      it { should == expected_map }
    end

    context "after a #place" do
      let(:robot) { ExtendedRobot.new(board, "R1") }
      let(:expected_map) { robot_2_2_north_with_block_board_map }

      before do
        robot.place(2, 2, "NORTH")
        robot.block
      end

      it { should == expected_map }
    end
  end

  # #within_boundaries? tested in Robot#place in robot_spec.rb
end


text:
package codeOrchestra.colt.as.compiler.fcsh;

/**
 * @author Alexander Eliseyev
 */
public class FCSHException extends Exception {
  public FCSHException(String s, Throwable throwable) {
    super(s, throwable);
  }
  public FCSHException(Throwable throwable) {
    super(throwable);
  }
}


text:
package io.spring;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import javax.sql.DataSource;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.core.explore.JobExplorer;
import org.springframework.batch.core.partition.PartitionHandler;
import org.springframework.batch.core.partition.support.Partitioner;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.deployer.resource.support.DelegatingResourceLoader;
import org.springframework.cloud.deployer.spi.task.TaskLauncher;
import org.springframework.cloud.task.batch.partition.DeployerPartitionHandler;
import org.springframework.cloud.task.batch.partition.DeployerStepExecutionHandler;
import org.springframework.cloud.task.batch.partition.PassThroughCommandLineArgsProvider;
import org.springframework.cloud.task.batch.partition.SimpleEnvironmentVariablesProvider;
import org.springframework.cloud.task.repository.TaskRepository;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;

/**
 * @author Michael Minella
 */
@Configuration
public class JobConfiguration {

	private static final int GRID_SIZE = 4;
	// @checkstyle:off
	@Autowired
	public JobBuilderFactory jobBuilderFactory;
	@Autowired
	public StepBuilderFactory stepBuilderFactory;
	@Autowired
	public DataSource dataSource;
	@Autowired
	public JobRepository jobRepository;
	// @checkstyle:on
	@Autowired
	private ConfigurableApplicationContext context;
	@Autowired
	private DelegatingResourceLoader resourceLoader;
	@Autowired
	private Environment environment;

	@Bean
	public PartitionHandler partitionHandler(TaskLauncher taskLauncher, JobExplorer jobExplorer, TaskRepository taskRepository) throws Exception {
		Resource resource = this.resourceLoader
			.getResource("maven://io.spring.cloud:partitioned-batch-job:2.2.0.BUILD-SNAPSHOT");

		DeployerPartitionHandler partitionHandler =
			new DeployerPartitionHandler(taskLauncher, jobExplorer, resource, "workerStep");

		List<String> commandLineArgs = new ArrayList<>(3);
		commandLineArgs.add("--spring.profiles.active=worker");
		commandLineArgs.add("--spring.cloud.task.initialize-enabled=false");
		commandLineArgs.add("--spring.batch.initializer.enabled=false");
		partitionHandler
			.setCommandLineArgsProvider(new PassThroughCommandLineArgsProvider(commandLineArgs));
		partitionHandler
			.setEnvironmentVariablesProvider(new SimpleEnvironmentVariablesProvider(this.environment));
		partitionHandler.setMaxWorkers(2);
		partitionHandler.setApplicationName("PartitionedBatchJobTask");

		return partitionHandler;
	}

	@Bean
	public Partitioner partitioner() {
		return new Partitioner() {
			@Override
			public Map<String, ExecutionContext> partition(int gridSize) {

				Map<String, ExecutionContext> partitions = new HashMap<>(gridSize);

				for (int i = 0; i < GRID_SIZE; i++) {
					ExecutionContext context1 = new ExecutionContext();
					context1.put("partitionNumber", i);

					partitions.put("partition" + i, context1);
				}

				return partitions;
			}
		};
	}

	@Bean
	@Profile("worker")
	public DeployerStepExecutionHandler stepExecutionHandler(JobExplorer jobExplorer) {
		return new DeployerStepExecutionHandler(this.context, jobExplorer, this.jobRepository);
	}

	@Bean
	@StepScope
	public Tasklet workerTasklet(
		final @Value("#{stepExecutionContext['partitionNumber']}") Integer partitionNumber) {

		return new Tasklet() {
			@Override
			public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
				System.out.println("This tasklet ran partition: " + partitionNumber);

				return RepeatStatus.FINISHED;
			}
		};
	}

	@Bean
	public Step step1(PartitionHandler partitionHandler) throws Exception {
		return this.stepBuilderFactory.get("step1")
			.partitioner(workerStep().getName(), partitioner())
			.step(workerStep())
			.partitionHandler(partitionHandler)
			.build();
	}

	@Bean
	public Step workerStep() {
		return this.stepBuilderFactory.get("workerStep")
			.tasklet(workerTasklet(null))
			.build();
	}

	@Bean
	@Profile("!worker")
	public Job partitionedJob(PartitionHandler partitionHandler) throws Exception {
		Random random = new Random();
		return this.jobBuilderFactory.get("partitionedJob" + random.nextInt())
			.start(step1(partitionHandler))
			.build();
	}
}


text:
<?php

namespace Lunr\Gravity\Database\MySQL\Tests;

use Lunr\Gravity\Database\MySQL\MySQLConnection;

/**
 * This class contains query related unit tests for MySQLConnection.
 *
 * @covers Lunr\Gravity\Database\MySQL\MySQLConnection
 */
class MySQLConnectionQueryTest extends MySQLConnectionTest
{

    /**
     * Test that query() returns a QueryResult that indicates a failed query when not connected.
     *
     * @covers Lunr\Gravity\Database\MySQL\MySQLConnection::query
     */
    public function testQueryReturnsFailedQueryResultWhenNotConnected()
    {
        $mysqli = new MockMySQLiFailedConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);

        $query = $this->class->query('query');

        $this->assertInstanceOf('Lunr\Gravity\Database\MySQL\MySQLQueryResult', $query);
        $this->assertTrue($query->has_failed());
    }

    /**
     * Test that query() returns a QueryResult when connected.
     *
     * @requires extension mysqli
     * @covers   Lunr\Gravity\Database\MySQL\MySQLConnection::query
     */
    public function testQueryReturnsQueryResultWhenConnected()
    {
        $mysqli = new MockMySQLiSuccessfulConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);
        $this->set_reflection_property_value('connected', TRUE);

        $mysqli->expects($this->once())
               ->method('query')
               ->will($this->returnValue(TRUE));

        $query = $this->class->query('query');

        $this->assertInstanceOf('Lunr\Gravity\Database\MySQL\MySQLQueryResult', $query);
        $this->assertFalse($query->has_failed());
    }

    /**
     * Test that query() prepends the SQL query with a query hint if one is set.
     *
     * @requires extension mysqli
     * @covers   Lunr\Gravity\Database\MySQL\MySQLConnection::query
     */
    public function testQueryPrependsQueryHintIfPresent()
    {
        $mysqli = new MockMySQLiSuccessfulConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);
        $this->set_reflection_property_value('connected', TRUE);
        $this->set_reflection_property_value('query_hint', '/*hint*/');

        $mysqli->expects($this->once())
               ->method('query')
               ->with($this->equalTo('/*hint*/query'))
               ->will($this->returnValue(TRUE));

        $query = $this->class->query('query');

        $this->assertEquals('/*hint*/query', $query->query());
    }

    /**
     * Test that query() returns a QueryResult when connected.
     *
     * @requires extension mysqli
     * @covers   Lunr\Gravity\Database\MySQL\MySQLConnection::query
     */
    public function testQueryResetsQueryHint()
    {
        $mysqli = new MockMySQLiSuccessfulConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);
        $this->set_reflection_property_value('connected', TRUE);

        $hint = $this->get_accessible_reflection_property('query_hint');
        $hint->setValue($this->class, '/*hint*/');

        $mysqli->expects($this->once())
               ->method('query')
               ->with($this->equalTo('/*hint*/query'))
               ->will($this->returnValue(TRUE));

        $this->class->query('query');

        $this->assertSame('', $hint->getValue($this->class));
    }

    /**
     * Test that async_query() returns an AsyncQueryResult that indicates a failed query when not connected.
     *
     * @covers Lunr\Gravity\Database\MySQL\MySQLConnection::async_query
     */
    public function testAsyncQueryReturnsFailedQueryResultWhenNotConnected()
    {
        $mysqli = new MockMySQLiFailedConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);

        $query = $this->class->async_query('query');

        $this->assertInstanceOf('Lunr\Gravity\Database\MySQL\MySQLQueryResult', $query);
        $this->assertTrue($query->has_failed());
    }

    /**
     * Test that async_query() returns a AsyncQueryResult when connected.
     *
     * @requires extension mysqli
     * @covers   Lunr\Gravity\Database\MySQL\MySQLConnection::async_query
     */
    public function testAsyncQueryReturnsQueryResultWhenConnected()
    {
        $mysqli = new MockMySQLiSuccessfulConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);

        $property = $this->get_accessible_reflection_property('connected');
        $property->setValue($this->class, TRUE);

        $mysqli->expects($this->once())
               ->method('query');

        $mysqli->expects($this->once())
               ->method('reap_async_query')
               ->will($this->returnValue(TRUE));

        $query = $this->class->async_query('query');

        $this->assertInstanceOf('Lunr\Gravity\Database\MySQL\MySQLAsyncQueryResult', $query);
        $this->assertFalse($query->has_failed());

        $property->setValue($this->class, FALSE);
    }

    /**
     * Test that async_query() prepends the SQL query with a query hint if one is set.
     *
     * @requires extension mysqli
     * @covers   Lunr\Gravity\Database\MySQL\MySQLConnection::async_query
     */
    public function testAsyncQueryPrependsQueryHintIfPresent()
    {
        $mysqli = new MockMySQLiSuccessfulConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);
        $this->set_reflection_property_value('connected', TRUE);
        $this->set_reflection_property_value('query_hint', '/*hint*/');

        $mysqli->expects($this->once())
               ->method('query')
               ->with($this->equalTo('/*hint*/query'), $this->equalTo(MYSQLI_ASYNC));

        $query = $this->class->async_query('query');

        $this->assertEquals('/*hint*/query', $query->query());
    }

    /**
     * Test that async_query() returns a QueryResult when connected.
     *
     * @requires extension mysqli
     * @covers   Lunr\Gravity\Database\MySQL\MySQLConnection::async_query
     */
    public function testAsyncQueryResetsQueryHint()
    {
        $mysqli = new MockMySQLiSuccessfulConnection($this->getMockBuilder('\mysqli')->getMock());

        $this->set_reflection_property_value('mysqli', $mysqli);
        $this->set_reflection_property_value('connected', TRUE);

        $hint = $this->get_accessible_reflection_property('query_hint');
        $hint->setValue($this->class, '/*hint*/');

        $mysqli->expects($this->once())
               ->method('query')
               ->with($this->equalTo('/*hint*/query'), $this->equalTo(MYSQLI_ASYNC));

        $this->class->async_query('query');

        $this->assertSame('', $hint->getValue($this->class));
    }

}

?>


text:
var component_1 = require("./component");
exports.Component = component_1.Component;
exports.Option = component_1.Option;
exports.AbstractComponent = component_1.AbstractComponent;
exports.ChildableComponent = component_1.ChildableComponent;
var events_1 = require("./events");
exports.Event = events_1.Event;
exports.EventDispatcher = events_1.EventDispatcher;
var fs_1 = require("./fs");
exports.normalizePath = fs_1.normalizePath;
exports.directoryExists = fs_1.directoryExists;
exports.ensureDirectoriesExist = fs_1.ensureDirectoriesExist;
exports.writeFile = fs_1.writeFile;
var loggers_1 = require("./loggers");
exports.Logger = loggers_1.Logger;
exports.LogLevel = loggers_1.LogLevel;
exports.ConsoleLogger = loggers_1.ConsoleLogger;
exports.CallbackLogger = loggers_1.CallbackLogger;
var plugins_1 = require("./plugins");
exports.PluginHost = plugins_1.PluginHost;


text:
cask "ariang" do
  version "1.2.1"
  sha256 "797e0a0017f20afae8417baa7aeb2bba4723a33af3ed2c37d2495a06711ce3b4"

  url "https://github.com/mayswind/AriaNg-Native/releases/download/#{version}/AriaNg_Native-#{version}-macOS.dmg"
  appcast "https://github.com/mayswind/AriaNg-Native/releases.atom"
  name "AriaNg Native"
  desc "Better aria2 desktop frontend than AriaNg"
  homepage "https://github.com/mayswind/AriaNg-Native"

  app "AriaNg Native.app"
end


text:
mod to_schema;

use to_schema::transform_fixture;
use fixture_tests::test_fixture;

#[test]
fn client_edge_relay_resolver() {
    let input = include_str!("to_schema/fixtures/client-edge-relay-resolver.js");
    let expected = include_str!("to_schema/fixtures/client-edge-relay-resolver.expected");
    test_fixture(transform_fixture, "client-edge-relay-resolver.js", "to_schema/fixtures/client-edge-relay-resolver.expected", input, expected);
}

#[test]
fn relay_resolver() {
    let input = include_str!("to_schema/fixtures/relay-resolver.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver.expected");
    test_fixture(transform_fixture, "relay-resolver.js", "to_schema/fixtures/relay-resolver.expected", input, expected);
}

#[test]
fn relay_resolver_deprecated() {
    let input = include_str!("to_schema/fixtures/relay-resolver-deprecated.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-deprecated.expected");
    test_fixture(transform_fixture, "relay-resolver-deprecated.js", "to_schema/fixtures/relay-resolver-deprecated.expected", input, expected);
}

#[test]
fn relay_resolver_deprecated_no_description() {
    let input = include_str!("to_schema/fixtures/relay-resolver-deprecated-no-description.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-deprecated-no-description.expected");
    test_fixture(transform_fixture, "relay-resolver-deprecated-no-description.js", "to_schema/fixtures/relay-resolver-deprecated-no-description.expected", input, expected);
}

#[test]
fn relay_resolver_on_interface() {
    let input = include_str!("to_schema/fixtures/relay-resolver-on-interface.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-on-interface.expected");
    test_fixture(transform_fixture, "relay-resolver-on-interface.js", "to_schema/fixtures/relay-resolver-on-interface.expected", input, expected);
}

#[test]
fn relay_resolver_on_interface_with_type_invalid() {
    let input = include_str!("to_schema/fixtures/relay-resolver-on-interface-with-type.invalid.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-on-interface-with-type.invalid.expected");
    test_fixture(transform_fixture, "relay-resolver-on-interface-with-type.invalid.js", "to_schema/fixtures/relay-resolver-on-interface-with-type.invalid.expected", input, expected);
}

#[test]
fn relay_resolver_on_invalid_interface_invalid() {
    let input = include_str!("to_schema/fixtures/relay-resolver-on-invalid-interface.invalid.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-on-invalid-interface.invalid.expected");
    test_fixture(transform_fixture, "relay-resolver-on-invalid-interface.invalid.js", "to_schema/fixtures/relay-resolver-on-invalid-interface.invalid.expected", input, expected);
}

#[test]
fn relay_resolver_on_invalid_type_invalid() {
    let input = include_str!("to_schema/fixtures/relay-resolver-on-invalid-type.invalid.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-on-invalid-type.invalid.expected");
    test_fixture(transform_fixture, "relay-resolver-on-invalid-type.invalid.js", "to_schema/fixtures/relay-resolver-on-invalid-type.invalid.expected", input, expected);
}

#[test]
fn relay_resolver_on_type_with_interface_invalid() {
    let input = include_str!("to_schema/fixtures/relay-resolver-on-type-with-interface.invalid.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-on-type-with-interface.invalid.expected");
    test_fixture(transform_fixture, "relay-resolver-on-type-with-interface.invalid.js", "to_schema/fixtures/relay-resolver-on-type-with-interface.invalid.expected", input, expected);
}

#[test]
fn relay_resolver_with_args() {
    let input = include_str!("to_schema/fixtures/relay-resolver-with-args.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-with-args.expected");
    test_fixture(transform_fixture, "relay-resolver-with-args.js", "to_schema/fixtures/relay-resolver-with-args.expected", input, expected);
}

#[test]
fn relay_resolver_with_field_and_fragment_args() {
    let input = include_str!("to_schema/fixtures/relay-resolver-with-field-and-fragment-args.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-with-field-and-fragment-args.expected");
    test_fixture(transform_fixture, "relay-resolver-with-field-and-fragment-args.js", "to_schema/fixtures/relay-resolver-with-field-and-fragment-args.expected", input, expected);
}

#[test]
fn relay_resolver_with_field_args() {
    let input = include_str!("to_schema/fixtures/relay-resolver-with-field-args.js");
    let expected = include_str!("to_schema/fixtures/relay-resolver-with-field-args.expected");
    test_fixture(transform_fixture, "relay-resolver-with-field-args.js", "to_schema/fixtures/relay-resolver-with-field-args.expected", input, expected);
}


text:
<!DOCTYPE html>

  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Chapter 1—Introducing Flexbox | Flexbox.website</title>
  <link rel="stylesheet" href="/css/prism.css">
  <link rel="stylesheet" href="/css/reader.css">

        Home

        Flexbox.website

      <root>
Chapter 1—Introducing Flexbox

Flex direction

Center alignment

Container and items

Flex grow and shrink

Inputs

</root>

      You can find the PDF/ePub/Mobi edition at https://leanpub.com/flexbox-website. Buy now and read the book in your favorite reader.

      ← Preparing for the workshop

      flex-direction →

    ←

    →

    Flexbox.website. v1.0. © 2015 by Makzan.
Text and images are in CC BY-NC 4.0 lincense.
All code examples are in MIT license.


text:
function Get-VMDiskLimit {
    <#
        .SYNOPSIS
            Function for getting limits on a single VMDK
        .DESCRIPTION
            The function will get the IOPS limit on a specific
            VMDK
        .LINK
            https://www.rudimartinsen.com/2018/06/29/working-with-disk-limits-in-powercli/
        .NOTES
            Info
            Author : Rudi Martinsen / Intility AS
            Date : 24/02-2018
            Version : 0.1.1
            Revised : 24/02-2018
            Changelog:
            0.1.1 -- Added VM name to output
        .PARAMETER Harddisk
            VMDK to get limits from
        .EXAMPLE
            Get-VMDiskLimit -Harddisk $disk
            Gets the limits on a VMDK
    #>
    [cmdletbinding()]
    param(
        [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName="vmdk")]
        [Alias("VMDK")]
        [VMware.VimAutomation.ViCore.Types.V1.VirtualDevice.FlatHardDisk]
        $Harddisk
    )

    $Harddisk.Parent | Get-VMResourceConfiguration | Select-Object -ExpandProperty DiskResourceConfiguration | Where-Object {$_.key -eq $Harddisk.ExtensionData.key} | Select-Object @{l="VM";e={$Harddisk.Parent.Name}},@{l="Label";e={$Harddisk.Name}},@{l="IOPSLimit";e={$_.DiskLimitIOPerSecond}}

}


text:
apollo_down() {
  pushd $APOLLO_ROOT/terraform/${APOLLO_PROVIDER}
    terraform destroy -var "region=${TF_VAR_region}"
  popd
}


text:
var midi = require("../midi.js");

var output1 = new midi.output();
output1.openVirtualPort("JellyVibes1");

//var exec = require("child_process").exec ;
var querystring = require("querystring") ;
	fs = require("fs") ;

var ipAdd ;

function start(response, postData)
{
	console.log("Request handler 'start' was called.") ;

	var body = '' +
	'' +
	'<meta http-equiv = "Content-Type" content = "text/html" ; ' +
	'charset = UTF-8 />' +
	'' +

	''+
	'<form action="/upload" method="post">'+
 	'<textarea name="text" rows="1" cols="35"></textarea>'+
 	'<input type="submit" value="Submit text" />'+
 	'</form>'+
 	''+
 	'';

 	response.writeHead(200, {"Content-Type": "text/html"}) ;
 	response.write(body) ;
 	response.end() ;

/*
	exec("find /",
	{
		timeout: 3000, maxBuffer: 20000*1024 },
		function (error, stdout, stderr)
		{
			response.writeHead(200, { "Content-Type": "text/plain"}) ;
			response.write(stdout) ;
			response.end() ;
	}) ;
*/

/*
	exec("ls -lah", function (error, stdout, stderr)
		{
			response.writeHead(200, {"Content-Type": "text/plain"}) ;
			response.write(stdout) ;
			response.end() ;
		} ) ;

	*/
}

function upload(response, postData)
{
	console.log("Request handler 'upload' was called.") ;
	response.writeHead(200, {"Content-Type": "text/plain"}) ;
	response.write("You've sent: " + querystring.parse(postData).text) ;
	ipAdd = postData ;
	console.log(ipAdd) ;
	response.end() ;
}

function show(response)
{
	console.log("Request handler 'show' was called.") ;
	response.writeHead(200, {"Content-Type": "image/png"}) ;
	fs.createReadStream("/tmp/test.png").pipe(response) ;
}

function printWeb()
{

}

exports.start = start ;
exports.upload = upload ;
exports.show = show ;


text:
a
abandon
ability
able
abortion
about
above
abroad
absence
absolute
absolutely
absorb
abuse
academic
accept
access
accident
accompany
accomplish
according
account
accurate
accuse
achieve
achievement
acid
acknowledge
acquire
across
act
action
active
activist
activity
actor
actress
actual
actually
ad
adapt
add
addition
additional
address
adequate
adjust
adjustment
administration
administrator
admire
admission
admit
adolescent
adopt
adult
advance
advanced
advantage
adventure
advertising
advice
advise
adviser
advocate
affair
affect
afford
afraid
African
African-American
after
afternoon
again
against
age
agency
agenda
agent
aggressive
ago
agree
agreement
agricultural
ah
ahead
aid
aide
AIDS
aim
air
aircraft
airline
airport
album
alcohol
alive
all
alliance
allow
ally
almost
alone
along
already
also
alter
alternative
although
always
AM
amazing
American
among
amount
analysis
analyst
analyze
ancient
and
anger
angle
angry
animal
anniversary
announce
annual
another
answer
anticipate
anxiety
any
anybody
anymore
anyone
anything
anyway
anywhere
apart
apartment
apparent
apparently
appeal
appear
appearance
apple
application
apply
appoint
appointment
appreciate
approach
appropriate
approval
approve
approximately
Arab
architect
area
argue
argument
arise
arm
armed
army
around
arrange
arrangement
arrest
arrival
arrive
art
article
artist
artistic
as
Asian
aside
ask
asleep
aspect
assault
assert
assess
assessment
asset
assign
assignment
assist
assistance
assistant
associate
association
assume
assumption
assure
at
athlete
athletic
atmosphere
attach
attack
attempt
attend
attention
attitude
attorney
attract
attractive
attribute
audience
author
authority
auto
available
average
avoid
award
aware
awareness
away
awful
baby
back
background
bad
badly
bag
bake
balance
ball
ban
band
bank
bar
barely
barrel
barrier
base
baseball
basic
basically
basis
basket
basketball
bathroom
battery
battle
be
beach
bean
bear
beat
beautiful
beauty
because
become
bed
bedroom
beer
before
begin
beginning
behavior
behind
being
belief
believe
bell
belong
below
belt
bench
bend
beneath
benefit
beside
besides
best
bet
better
between
beyond
Bible
big
bike
bill
billion
bind
biological
bird
birth
birthday
bit
bite
black
blade
blame
blanket
blind
block
blood
blow
blue
board
boat
body
bomb
bombing
bond
bone
book
boom
boot
border
born
borrow
boss
both
bother
bottle
bottom
boundary
bowl
box
boy
boyfriend
brain
branch
brand
bread
break
breakfast
breast
breath
breathe
brick
bridge
brief
briefly
bright
brilliant
bring
British
broad
broken
brother
brown
brush
buck
budget
build
building
bullet
bunch
burden
burn
bury
bus
business
busy
but
butter
button
buy
buyer
by
cabin
cabinet
cable
cake
calculate
call
camera
camp
campaign
campus
can
Canadian
cancer
candidate
cap
capability
capable
capacity
capital
captain
capture
car
carbon
card
care
career
careful
carefully
carrier
carry
case
cash
cast
cat
catch
category
Catholic
cause
ceiling
celebrate
celebration
celebrity
cell
center
central
century
CEO
ceremony
certain
certainly
chain
chair
chairman
challenge
chamber
champion
championship
chance
change
changing
channel
chapter
character
characteristic
characterize
charge
charity
chart
chase
cheap
check
cheek
cheese
chef
chemical
chest
chicken
chief
child
childhood
Chinese
chip
chocolate
choice
cholesterol
choose
Christian
Christmas
church
cigarette
circle
circumstance
cite
citizen
city
civil
civilian
claim
class
classic
classroom
clean
clear
clearly
client
climate
climb
clinic
clinical
clock
close
closely
closer
clothes
clothing
cloud
club
clue
cluster
coach
coal
coalition
coast
coat
code
coffee
cognitive
cold
collapse
colleague
collect
collection
collective
college
colonial
color
column
combination
combine
come
comedy
comfort
comfortable
command
commander
comment
commercial
commission
commit
commitment
committee
common
communicate
communication
community
company
compare
comparison
compete
competition
competitive
competitor
complain
complaint
complete
completely
complex
complicated
component
compose
composition
comprehensive
computer
concentrate
concentration
concept
concern
concerned
concert
conclude
conclusion
concrete
condition
conduct
conference
confidence
confident
confirm
conflict
confront
confusion
Congress
congressional
connect
connection
consciousness
consensus
consequence
conservative
consider
considerable
consideration
consist
consistent
constant
constantly
constitute
constitutional
construct
construction
consultant
consume
consumer
consumption
contact
contain
container
contemporary
content
contest
context
continue
continued
contract
contrast
contribute
contribution
control
controversial
controversy
convention
conventional
conversation
convert
conviction
convince
cook
cookie
cooking
cool
cooperation
cop
cope
copy
core
corn
corner
corporate
corporation
correct
correspondent
cost
cotton
couch
could
council
counselor
count
counter
country
county
couple
courage
course
court
cousin
cover
coverage
cow
crack
craft
crash
crazy
cream
create
creation
creative
creature
credit
crew
crime
criminal
crisis
criteria
critic
critical
criticism
criticize
crop
cross
crowd
crucial
cry
cultural
culture
cup
curious
current
currently
curriculum
custom
customer
cut
cycle
dad
daily
damage
dance
danger
dangerous
dare
dark
darkness
data
date
daughter
day
dead
deal
dealer
dear
death
debate
debt
decade
decide
decision
deck
declare
decline
decrease
deep
deeply
deer
defeat
defend
defendant
defense
defensive
deficit
define
definitely
definition
degree
delay
deliver
delivery
demand
democracy
Democrat
democratic
demonstrate
demonstration
deny
department
depend
dependent
depending
depict
depression
depth
deputy
derive
describe
description
desert
deserve
design
designer
desire
desk
desperate
despite
destroy
destruction
detail
detailed
detect
determine
develop
developing
development
device
devote
dialogue
die
diet
differ
difference
different
differently
difficult
difficulty
dig
digital
dimension
dining
dinner
direct
direction
directly
director
dirt
dirty
disability
disagree
disappear
disaster
discipline
discourse
discover
discovery
discrimination
discuss
discussion
disease
dish
dismiss
disorder
display
dispute
distance
distant
distinct
distinction
distinguish
distribute
distribution
district
diverse
diversity
divide
division
divorce
DNA
do
doctor
document
dog
domestic
dominant
dominate
door
double
doubt
down
downtown
dozen
draft
drag
drama
dramatic
dramatically
draw
drawing
dream
dress
drink
drive
driver
drop
drug
dry
due
during
dust
duty
each
eager
ear
early
earn
earnings
earth
ease
easily
east
eastern
easy
eat
economic
economics
economist
economy
edge
edition
editor
educate
education
educational
educator
effect
effective
effectively
efficiency
efficient
effort
egg
eight
either
elderly
elect
election
electric
electricity
electronic
element
elementary
eliminate
elite
else
elsewhere
e-mail
embrace
emerge
emergency
emission
emotion
emotional
emphasis
emphasize
employ
employee
employer
employment
empty
enable
encounter
encourage
end
enemy
energy
enforcement
engage
engine
engineer
engineering
English
enhance
enjoy
enormous
enough
ensure
enter
enterprise
entertainment
entire
entirely
entrance
entry
environment
environmental
episode
equal
equally
equipment
era
error
escape
especially
essay
essential
essentially
establish
establishment
estate
estimate
etc
ethics
ethnic
European
evaluate
evaluation
even
evening
event
eventually
ever
every
everybody
everyday
everyone
everything
everywhere
evidence
evolution
evolve
exact
exactly
examination
examine
example
exceed
excellent
except
exception
exchange
exciting
executive
exercise
exhibit
exhibition
exist
existence
existing
expand
expansion
expect
expectation
expense
expensive
experience
experiment
expert
explain
explanation
explode
explore
explosion
expose
exposure
express
expression
extend
extension
extensive
extent
external
extra
extraordinary
extreme
extremely
eye
fabric
face
facility
fact
factor
factory
faculty
fade
fail
failure
fair
fairly
faith
fall
false
familiar
family
famous
fan
fantasy
far
farm
farmer
fashion
fast
fat
fate
father
fault
favor
favorite
fear
feature
federal
fee
feed
feel
feeling
fellow
female
fence
few
fewer
fiber
fiction
field
fifteen
fifth
fifty
fight
fighter
fighting
figure
file
fill
film
final
finally
finance
financial
find
finding
fine
finger
finish
fire
firm
first
fish
fishing
fit
fitness
five
fix
flag
flame
flat
flavor
flee
flesh
flight
float
floor
flow
flower
fly
focus
folk
follow
following
food
foot
football
for
force
foreign
forest
forever
forget
form
formal
formation
former
formula
forth
fortune
forward
found
foundation
founder
four
fourth
frame
framework
free
freedom
freeze
French
frequency
frequent
frequently
fresh
friend
friendly
friendship
from
front
fruit
frustration
fuel
full
fully
fun
function
fund
fundamental
funding
funeral
funny
furniture
furthermore
future
gain
galaxy
gallery
game
gang
gap
garage
garden
garlic
gas
gate
gather
gay
gaze
gear
gender
gene
general
generally
generate
generation
genetic
gentleman
gently
German
gesture
get
ghost
giant
gift
gifted
girl
girlfriend
give
given
glad
glance
glass
global
glove
go
goal
God
gold
golden
golf
good
government
governor
grab
grade
gradually
graduate
grain
grand
grandfather
grandmother
grant
grass
grave
gray
great
greatest
green
grocery
ground
group
grow
growing
growth
guarantee
guard
guess
guest
guide
guideline
guilty
gun
guy
habit
habitat
hair
half
hall
hand
handful
handle
hang
happen
happy
hard
hardly
hat
hate
have
he
head
headline
headquarters
health
healthy
hear
hearing
heart
heat
heaven
heavily
heavy
heel
height
helicopter
hell
hello
help
helpful
her
here
heritage
hero
herself
hey
hi
hide
high
highlight
highly
highway
hill
him
himself
hip
hire
his
historian
historic
historical
history
hit
hold
hole
holiday
holy
home
homeless
honest
honey
honor
hope
horizon
horror
horse
hospital
host
hot
hotel
hour
house
household
housing
how
however
huge
human
humor
hundred
hungry
hunter
hunting
hurt
husband
hypothesis
I
ice
idea
ideal
identification
identify
identity
ie
if
ignore
ill
illegal
illness
illustrate
image
imagination
imagine
immediate
immediately
immigrant
immigration
impact
implement
implication
imply
importance
important
impose
impossible
impress
impression
impressive
improve
improvement
in
incentive
incident
include
including
income
incorporate
increase
increased
increasing
increasingly
incredible
indeed
independence
independent
index
Indian
indicate
indication
individual
industrial
industry
infant
infection
inflation
influence
inform
information
ingredient
initial
initially
initiative
injury
inner
innocent
inquiry
inside
insight
insist
inspire
install
instance
instead
institution
institutional
instruction
instructor
instrument
insurance
intellectual
intelligence
intend
intense
intensity
intention
interaction
interest
interested
interesting
internal
international
Internet
interpret
interpretation
intervention
interview
into
introduce
introduction
invasion
invest
investigate
investigation
investigator
investment
investor
invite
involve
involved
involvement
Iraqi
Irish
iron
Islamic
island
Israeli
issue
it
Italian
item
its
itself
jacket
jail
Japanese
jet
Jew
Jewish
job
join
joint
joke
journal
journalist
journey
joy
judge
judgment
juice
jump
junior
jury
just
justice
justify
keep
key
kick
kid
kill
killer
killing
kind
king
kiss
kitchen
knee
knife
knock
know
knowledge
lab
label
labor
laboratory
lack
lady
lake
land
landscape
language
lap
large
largely
last
late
later
Latin
latter
laugh
launch
law
lawn
lawsuit
lawyer
lay
layer
lead
leader
leadership
leading
leaf
league
lean
learn
learning
least
leather
leave
left
leg
legacy
legal
legend
legislation
legitimate
lemon
length
less
lesson
let
letter
level
liberal
library
license
lie
life
lifestyle
lifetime
lift
light
like
likely
limit
limitation
limited
line
link
lip
list
listen
literally
literary
literature
little
live
living
load
loan
local
locate
location
lock
long
long-term
look
loose
lose
loss
lost
lot
lots
loud
love
lovely
lover
low
lower
luck
lucky
lunch
lung
machine
mad
magazine
mail
main
mainly
maintain
maintenance
major
majority
make
maker
makeup
male
mall
man
manage
management
manager
manner
manufacturer
manufacturing
many
map
margin
mark
market
marketing
marriage
married
marry
mask
mass
massive
master
match
material
math
matter
may
maybe
mayor
me
meal
mean
meaning
meanwhile
measure
measurement
meat
mechanism
media
medical
medication
medicine
medium
meet
meeting
member
membership
memory
mental
mention
menu
mere
merely
mess
message
metal
meter
method
Mexican
middle
might
military
milk
million
mind
mine
minister
minor
minority
minute
miracle
mirror
miss
missile
mission
mistake
mix
mixture
mm-hmm
mode
model
moderate
modern
modest
mom
moment
money
monitor
month
mood
moon
moral
more
moreover
morning
mortgage
most
mostly
mother
motion
motivation
motor
mount
mountain
mouse
mouth
move
movement
movie
Mr
Mrs
Ms
much
multiple
murder
muscle
museum
music
musical
musician
Muslim
must
mutual
my
myself
mystery
myth
naked
name
narrative
narrow
nation
national
native
natural
naturally
nature
near
nearby
nearly
necessarily
necessary
neck
need
negative
negotiate
negotiation
neighbor
neighborhood
neither
nerve
nervous
net
network
never
nevertheless
new
newly
news
newspaper
next
nice
night
nine
no
nobody
nod
noise
nomination
none
nonetheless
nor
normal
normally
north
northern
nose
not
note
nothing
notice
notion
novel
now
nowhere
n't
nuclear
number
numerous
nurse
nut
object
objective
obligation
observation
observe
observer
obtain
obvious
obviously
occasion
occasionally
occupation
occupy
occur
ocean
odd
odds
of
off
offense
offensive
offer
office
officer
official
often
oh
oil
ok
okay
old
Olympic
on
once
one
ongoing
onion
online
only
onto
open
opening
operate
operating
operation
operator
opinion
opponent
opportunity
oppose
opposite
opposition
option
or
orange
order
ordinary
organic
organization
organize
orientation
origin
original
originally
other
others
otherwise
ought
our
ourselves
out
outcome
outside
oven
over
overall
overcome
overlook
owe
own
owner
pace
pack
package
page
pain
painful
paint
painter
painting
pair
pale
Palestinian
palm
pan
panel
pant
paper
parent
park
parking
part
participant
participate
participation
particular
particularly
partly
partner
partnership
party
pass
passage
passenger
passion
past
patch
path
patient
pattern
pause
pay
payment
PC
peace
peak
peer
penalty
people
pepper
per
perceive
percentage
perception
perfect
perfectly
perform
performance
perhaps
period
permanent
permission
permit
person
personal
personality
personally
personnel
perspective
persuade
pet
phase
phenomenon
philosophy
phone
photo
photograph
photographer
phrase
physical
physically
physician
piano
pick
picture
pie
piece
pile
pilot
pine
pink
pipe
pitch
place
plan
plane
planet
planning
plant
plastic
plate
platform
play
player
please
pleasure
plenty
plot
plus
PM
pocket
poem
poet
poetry
point
pole
police
policy
political
politically
politician
politics
poll
pollution
pool
poor
pop
popular
population
porch
port
portion
portrait
portray
pose
position
positive
possess
possibility
possible
possibly
post
pot
potato
potential
potentially
pound
pour
poverty
powder
power
powerful
practical
practice
pray
prayer
precisely
predict
prefer
preference
pregnancy
pregnant
preparation
prepare
prescription
presence
present
presentation
preserve
president
presidential
press
pressure
pretend
pretty
prevent
previous
previously
price
pride
priest
primarily
primary
prime
principal
principle
print
prior
priority
prison
prisoner
privacy
private
probably
problem
procedure
proceed
process
produce
producer
product
production
profession
professional
professor
profile
profit
program
progress
project
prominent
promise
promote
prompt
proof
proper
properly
property
proportion
proposal
propose
proposed
prosecutor
prospect
protect
protection
protein
protest
proud
prove
provide
provider
province
provision
psychological
psychologist
psychology
public
publication
publicly
publish
publisher
pull
punishment
purchase
pure
purpose
pursue
push
put
qualify
quality
quarter
quarterback
question
quick
quickly
quiet
quietly
quit
quite
quote
race
racial
radical
radio
rail
rain
raise
range
rank
rapid
rapidly
rare
rarely
rate
rather
rating
ratio
raw
reach
react
reaction
read
reader
reading
ready
real
reality
realize
really
reason
reasonable
recall
receive
recent
recently
recipe
recognition
recognize
recommend
recommendation
record
recording
recover
recovery
recruit
red
reduce
reduction
refer
reference
reflect
reflection
reform
refugee
refuse
regard
regarding
regardless
regime
region
regional
register
regular
regularly
regulate
regulation
reinforce
reject
relate
relation
relationship
relative
relatively
relax
release
relevant
relief
religion
religious
rely
remain
remaining
remarkable
remember
remind
remote
remove
repeat
repeatedly
replace
reply
report
reporter
represent
representation
representative
Republican
reputation
request
require
requirement
research
researcher
resemble
reservation
resident
resist
resistance
resolution
resolve
resort
resource
respect
respond
respondent
response
responsibility
responsible
rest
restaurant
restore
restriction
result
retain
retire
retirement
return
reveal
revenue
review
revolution
rhythm
rice
rich
rid
ride
rifle
right
ring
rise
risk
river
road
rock
role
roll
romantic
roof
room
root
rope
rose
rough
roughly
round
route
routine
row
rub
rule
run
running
rural
rush
Russian
sacred
sad
safe
safety
sake
salad
salary
sale
sales
salt
same
sample
sanction
sand
satellite
satisfaction
satisfy
sauce
save
saving
say
scale
scandal
scared
scenario
scene
schedule
scheme
scholar
scholarship
school
science
scientific
scientist
scope
score
scream
screen
script
sea
search
season
seat
second
secret
secretary
section
sector
secure
security
see
seed
seek
seem
segment
seize
select
selection
self
sell
Senate
senator
send
senior
sense
sensitive
sentence
separate
sequence
series
serious
seriously
serve
service
session
set
setting
settle
settlement
seven
several
severe
sex
sexual
shade
shadow
shake
shall
shape
share
sharp
she
sheet
shelf
shell
shelter
shift
shine
ship
shirt
shit
shock
shoe
shoot
shooting
shop
shopping
shore
short
shortly
shot
should
shoulder
shout
show
shower
shrug
shut
sick
side
sigh
sight
sign
signal
significance
significant
significantly
silence
silent
silver
similar
similarly
simple
simply
sin
since
sing
singer
single
sink
sir
sister
sit
site
situation
six
size
ski
skill
skin
sky
slave
sleep
slice
slide
slight
slightly
slip
slow
slowly
small
smart
smell
smile
smoke
smooth
snap
snow
so
so-called
soccer
social
society
soft
software
soil
solar
soldier
solid
solution
solve
some
somebody
somehow
someone
something
sometimes
somewhat
somewhere
son
song
soon
sophisticated
sorry
sort
soul
sound
soup
source
south
southern
Soviet
space
Spanish
speak
speaker
special
specialist
species
specific
specifically
speech
speed
spend
spending
spin
spirit
spiritual
split
spokesman
sport
spot
spread
spring
square
squeeze
stability
stable
staff
stage
stair
stake
stand
standard
standing
star
stare
start
state
statement
station
statistics
status
stay
steady
steal
steel
step
stick
still
stir
stock
stomach
stone
stop
storage
store
storm
story
straight
strange
stranger
strategic
strategy
stream
street
strength
strengthen
stress
stretch
strike
string
strip
stroke
strong
strongly
structure
struggle
student
studio
study
stuff
stupid
style
subject
submit
subsequent
substance
substantial
succeed
success
successful
successfully
such
sudden
suddenly
sue
suffer
sufficient
sugar
suggest
suggestion
suicide
suit
summer
summit
sun
super
supply
support
supporter
suppose
supposed
Supreme
sure
surely
surface
surgery
surprise
surprised
surprising
surprisingly
surround
survey
survival
survive
survivor
suspect
sustain
swear
sweep
sweet
swim
swing
switch
symbol
symptom
system
table
tablespoon
tactic
tail
take
tale
talent
talk
tall
tank
tap
tape
target
task
taste
tax
taxpayer
tea
teach
teacher
teaching
team
tear
teaspoon
technical
technique
technology
teen
teenager
telephone
telescope
television
tell
temperature
temporary
ten
tend
tendency
tennis
tension
tent
term
terms
terrible
territory
terror
terrorism
terrorist
test
testify
testimony
testing
text
than
thank
thanks
that
the
theater
their
them
theme
themselves
then
theory
therapy
there
therefore
these
they
thick
thin
thing
think
thinking
third
thirty
this
those
though
thought
thousand
threat
threaten
three
throat
through
throughout
throw
thus
ticket
tie
tight
time
tiny
tip
tire
tired
tissue
title
to
tobacco
today
toe
together
tomato
tomorrow
tone
tongue
tonight
too
tool
tooth
top
topic
toss
total
totally
touch
tough
tour
tourist
tournament
toward
towards
tower
town
toy
trace
track
trade
tradition
traditional
traffic
tragedy
trail
train
training
transfer
transform
transformation
transition
translate
transportation
travel
treat
treatment
treaty
tree
tremendous
trend
trial
tribe
trick
trip
troop
trouble
truck
true
truly
trust
truth
try
tube
tunnel
turn
TV
twelve
twenty
twice
twin
two
type
typical
typically
ugly
ultimate
ultimately
unable
uncle
under
undergo
understand
understanding
unfortunately
uniform
union
unique
unit
United
universal
universe
university
unknown
unless
unlike
unlikely
until
unusual
up
upon
upper
urban
urge
us
use
used
useful
user
usual
usually
utility
vacation
valley
valuable
value
variable
variation
variety
various
vary
vast
vegetable
vehicle
venture
version
versus
very
vessel
veteran
via
victim
victory
video
view
viewer
village
violate
violation
violence
violent
virtually
virtue
virus
visible
vision
visit
visitor
visual
vital
voice
volume
volunteer
vote
voter
vs
vulnerable
wage
wait
wake
walk
wall
wander
want
war
warm
warn
warning
wash
waste
watch
water
wave
way
we
weak
wealth
wealthy
weapon
wear
weather
wedding
week
weekend
weekly
weigh
weight
welcome
welfare
well
west
western
wet
what
whatever
wheel
when
whenever
where
whereas
whether
which
while
whisper
white
who
whole
whom
whose
why
wide
widely
widespread
wife
wild
will
willing
win
wind
window
wine
wing
winner
winter
wipe
wire
wisdom
wise
wish
with
withdraw
within
without
witness
woman
wonder
wonderful
wood
wooden
word
work
worker
working
works
workshop
world
worried
worry
worth
would
wound
wrap
write
writer
writing
wrong
yard
yeah
year
yell
yellow
yes
yesterday
yet
yield
you
young
your
yours
yourself
youth
zone


text:
layout: post
title: Shane Diesel Compilation
titleinfo: pornvd
desc: Watch Shane Diesel Compilation. Pornhub is the ultimate xxx porn and sex site.
---

Shane Diesel Compilation

Watch Shane Diesel Compilation. Pornhub is the ultimate xxx porn and sex site.


text:
package ch.woggle.rohonxi.alphabet;

/**
 * Represents an alphabet that can be used to generate random character strings.
 *
 * @author Thomas Moser
 *
 */
public interface Alphabet {
  /**
   * @return The number of characters available in this alphabet.
   */
  public int size();

  /**
   * Get the character at the specified index. If index exceeds the size of the alphabet, this
   * should not cause an error. A common possibility would be to use % size to get the new index.
   *
   * @param index The index of the character to get.
   *
   * @return The character at the specified index. If the alphabet does not contain any characters
   *         the return value is not defined.
   */
  public char get(int index);

  /**
   * @return The name of the alphabet.
   */
  public String getName();

  /**
   * Get the string containing all the symbols used by this alphabet.
   *
   * @return
   */
  public String getSymbolString();
}


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.4-2
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2014.09.07 at 08:01:35 PM IST
//

package com.mozu.qbintegration.model.qbmodel.allgen;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for anonymous complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType>
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <sequence>
 *         <group ref="{}AddressData"/>
 *       </sequence>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "addr1",
    "addr2",
    "addr3",
    "addr4",
    "addr5",
    "city",
    "state",
    "postalCode",
    "country",
    "note"
})
@XmlRootElement(name = "ShipAddress")
public class ShipAddress {

    @XmlElement(name = "Addr1")
    protected String addr1;
    @XmlElement(name = "Addr2")
    protected String addr2;
    @XmlElement(name = "Addr3")
    protected String addr3;
    @XmlElement(name = "Addr4")
    protected String addr4;
    @XmlElement(name = "Addr5")
    protected String addr5;
    @XmlElement(name = "City")
    protected String city;
    @XmlElement(name = "State")
    protected String state;
    @XmlElement(name = "PostalCode")
    protected String postalCode;
    @XmlElement(name = "Country")
    protected String country;
    @XmlElement(name = "Note")
    protected String note;

    /**
     * Gets the value of the addr1 property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getAddr1() {
        return addr1;
    }

    /**
     * Sets the value of the addr1 property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setAddr1(String value) {
        this.addr1 = value;
    }

    /**
     * Gets the value of the addr2 property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getAddr2() {
        return addr2;
    }

    /**
     * Sets the value of the addr2 property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setAddr2(String value) {
        this.addr2 = value;
    }

    /**
     * Gets the value of the addr3 property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getAddr3() {
        return addr3;
    }

    /**
     * Sets the value of the addr3 property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setAddr3(String value) {
        this.addr3 = value;
    }

    /**
     * Gets the value of the addr4 property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getAddr4() {
        return addr4;
    }

    /**
     * Sets the value of the addr4 property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setAddr4(String value) {
        this.addr4 = value;
    }

    /**
     * Gets the value of the addr5 property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getAddr5() {
        return addr5;
    }

    /**
     * Sets the value of the addr5 property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setAddr5(String value) {
        this.addr5 = value;
    }

    /**
     * Gets the value of the city property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getCity() {
        return city;
    }

    /**
     * Sets the value of the city property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setCity(String value) {
        this.city = value;
    }

    /**
     * Gets the value of the state property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getState() {
        return state;
    }

    /**
     * Sets the value of the state property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setState(String value) {
        this.state = value;
    }

    /**
     * Gets the value of the postalCode property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getPostalCode() {
        return postalCode;
    }

    /**
     * Sets the value of the postalCode property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setPostalCode(String value) {
        this.postalCode = value;
    }

    /**
     * Gets the value of the country property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getCountry() {
        return country;
    }

    /**
     * Sets the value of the country property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setCountry(String value) {
        this.country = value;
    }

    /**
     * Gets the value of the note property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getNote() {
        return note;
    }

    /**
     * Sets the value of the note property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setNote(String value) {
        this.note = value;
    }

}


text:
package com.imadcn.framework.idworker.spring.schema.parser;

import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Element;

import com.imadcn.framework.idworker.common.GeneratorStrategy;
import com.imadcn.framework.idworker.config.ApplicationConfiguration;
import com.imadcn.framework.idworker.generator.CompressUUIDGenerator;
import com.imadcn.framework.idworker.generator.SnowflakeGenerator;
import com.imadcn.framework.idworker.register.zookeeper.ZookeeperWorkerRegister;
import com.imadcn.framework.idworker.spring.common.GeneratorBeanDefinitionTag;

/**
 * Id生成策略解析
 *
 * @author imadcn
 * @since 1.2.0
 */
public abstract class GeneratorRegisteryBuilder extends BaseBeanDefinitionParser {

    /**
     * snowflake策略:zookeeper配置(idworker:registry)
     *
     * @param element element
     * @param parserContext parserContext
     * @return AbstractBeanDefinition
     */
    public static AbstractBeanDefinition buildWorkerNodeRegisterBeanDefinition(final Element element,
        final ParserContext parserContext) {
        BeanDefinitionBuilder result = BeanDefinitionBuilder.rootBeanDefinition(ZookeeperWorkerRegister.class);
        String registryCenterRef = element.getAttribute(GeneratorBeanDefinitionTag.REGISTRY_CENTER_REF);
        if (registryCenterRef == null || registryCenterRef.isEmpty()) {
            throw new IllegalArgumentException("no attribute [registry-center-ref] found");
        }
        result.addConstructorArgReference(registryCenterRef);
        result.addConstructorArgValue(buildApplicationConfigurationBeanDefinition(element, parserContext));
        return result.getBeanDefinition();
    }

    /**
     * snowflake策略:参数(idworker:generator / generator:snowflake)
     *
     * @param element element
     * @param parserContext parserContext
     * @return AbstractBeanDefinition
     */
    public static AbstractBeanDefinition buildApplicationConfigurationBeanDefinition(final Element element,
        final ParserContext parserContext) {
        BeanDefinitionBuilder configuration = BeanDefinitionBuilder.rootBeanDefinition(ApplicationConfiguration.class);
        addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.GROUOP, "group", element, configuration);
        addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.STRATEGY, "strategy", element, configuration);
        addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.REGISTRY_FILE, "registryFile", element, configuration);
        addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.DURABLE, "durable", element, configuration);
        addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.SERIALIZE, "serialize", element, configuration);
        addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.CACHEABLE, "cacheable", element, configuration);
        // addPropertyValueIfNotEmpty(GeneratorBeanDefinitionTag.LOW_CONCURRENCY,
        // "lowConcurrency", element, configuration);
        return configuration.getBeanDefinition();
    }

    /**
     * 获取ID生成策略 Class
     *
     * @param element element
     * @return ID生成策略 Class
     */
    public static Class<?> getGeneratorClass(final Element element) {
        String strategyCode = getAttributeValue(element, GeneratorBeanDefinitionTag.STRATEGY);
        GeneratorStrategy strategy = GeneratorStrategy.getByCode(strategyCode);
        if (strategy == null) {
            throw new IllegalArgumentException("unsupported generator strategy.");
        }
        switch (strategy) {
            case SNOWFLAKE:
                return SnowflakeGenerator.class;
            case COMPRESS_UUID:
                return CompressUUIDGenerator.class;
            default:
                return SnowflakeGenerator.class;
        }
    }
}


text:
<?php

namespace Sonata\AdminBundle\Export;

use Exporter\Source\SourceIteratorInterface;
use Symfony\Component\HttpFoundation\StreamedResponse;

use Exporter\Writer\XlsWriter;
use Exporter\Writer\XmlWriter;
use Exporter\Writer\JsonWriter;
use Exporter\Writer\CsvWriter;

class Exporter
{
    /**
     * @throws \RuntimeException
     *
     * @param string                  $format
     * @param string                  $filename
     * @param SourceIteratorInterface $source
     *
     * @return StreamedResponse
     */
    public function getResponse($format, $filename, SourceIteratorInterface $source)
    {
        switch ($format) {
            case 'xls':
                $writer      = new XlsWriter('php://output');
                $contentType = 'application/vnd.ms-excel';
                break;
            case 'xml':
                $writer      = new XmlWriter('php://output');
                $contentType = 'text/xml';
                break;
            case 'json':
                $writer      = new JsonWriter('php://output');
                $contentType = 'application/json';
                break;
            case 'csv':
                $writer      = new CsvWriter('php://output', ',', '"', "", true, true);
                $contentType = 'text/csv';
                break;
            default:
                throw new \RuntimeException('Invalid format');
        }

        $callback = function() use ($source, $writer) {
            $handler = \Exporter\Handler::create($source, $writer);
            $handler->export();
        };

        return new StreamedResponse($callback, 200, array(
            'Content-Type'        => $contentType,
            'Content-Disposition' => sprintf('attachment; filename=%s', $filename)
        ));
    }
}


text:
<?php

declare (strict_types = 1);

namespace BinSoul\Net\Http\Response\Type\ClientError;

use BinSoul\Net\Http\Message\Collection\HeaderCollection;
use BinSoul\Net\Http\Response\Body;
use BinSoul\Net\Http\Response\Type\ClientErrorResponse;

/**
 * Represents a response with the HTTP status code 410.
 */
class GoneResponse extends ClientErrorResponse
{
    /**
     * Constructs an instance of this class.
     *
     * @param Body                  $body
     * @param HeaderCollection|null $headers
     */
    public function __construct(Body $body = null, HeaderCollection $headers = null)
    {
        parent::__construct(410, $body, $headers);
    }
}