text:
<?php

use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\RequestContext;

/**
 * appDevUrlMatcher
 *
 * This class has been auto-generated
 * by the Symfony Routing Component.
 */
class appDevUrlMatcher extends Symfony\Bundle\FrameworkBundle\Routing\RedirectableUrlMatcher
{
    /**
     * Constructor.
     */
    public function __construct(RequestContext $context)
    {
        $this->context = $context;
    }

    public function match($pathinfo)
    {
        $allow = array();
        $pathinfo = rawurldecode($pathinfo);

        if (0 === strpos($pathinfo, '/css/5f9861e')) {
            // _assetic_5f9861e
            if ($pathinfo === '/css/5f9861e.css') {
                return array (  '_controller' => 'assetic.controller:render',  'name' => '5f9861e',  'pos' => NULL,  '_format' => 'css',  '_route' => '_assetic_5f9861e',);
            }

            // _assetic_5f9861e_0
            if ($pathinfo === '/css/5f9861e_styles_1.css') {
                return array (  '_controller' => 'assetic.controller:render',  'name' => '5f9861e',  'pos' => 0,  '_format' => 'css',  '_route' => '_assetic_5f9861e_0',);
            }

        }

        if (0 === strpos($pathinfo, '/_')) {
            // _wdt
            if (0 === strpos($pathinfo, '/_wdt') && preg_match('#^/_wdt/(?P<token>[^/]++)$#s', $pathinfo, $matches)) {
                return $this->mergeDefaults(array_replace($matches, array('_route' => '_wdt')), array (  '_controller' => 'web_profiler.controller.profiler:toolbarAction',));
            }

            if (0 === strpos($pathinfo, '/_profiler')) {
                // _profiler_home
                if (rtrim($pathinfo, '/') === '/_profiler') {
                    if (substr($pathinfo, -1) !== '/') {
                        return $this->redirect($pathinfo.'/', '_profiler_home');
                    }

                    return array (  '_controller' => 'web_profiler.controller.profiler:homeAction',  '_route' => '_profiler_home',);
                }

                if (0 === strpos($pathinfo, '/_profiler/search')) {
                    // _profiler_search
                    if ($pathinfo === '/_profiler/search') {
                        return array (  '_controller' => 'web_profiler.controller.profiler:searchAction',  '_route' => '_profiler_search',);
                    }

                    // _profiler_search_bar
                    if ($pathinfo === '/_profiler/search_bar') {
                        return array (  '_controller' => 'web_profiler.controller.profiler:searchBarAction',  '_route' => '_profiler_search_bar',);
                    }

                }

                // _profiler_purge
                if ($pathinfo === '/_profiler/purge') {
                    return array (  '_controller' => 'web_profiler.controller.profiler:purgeAction',  '_route' => '_profiler_purge',);
                }

                if (0 === strpos($pathinfo, '/_profiler/i')) {
                    // _profiler_info
                    if (0 === strpos($pathinfo, '/_profiler/info') && preg_match('#^/_profiler/info/(?P<about>[^/]++)$#s', $pathinfo, $matches)) {
                        return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler_info')), array (  '_controller' => 'web_profiler.controller.profiler:infoAction',));
                    }

                    // _profiler_import
                    if ($pathinfo === '/_profiler/import') {
                        return array (  '_controller' => 'web_profiler.controller.profiler:importAction',  '_route' => '_profiler_import',);
                    }

                }

                // _profiler_export
                if (0 === strpos($pathinfo, '/_profiler/export') && preg_match('#^/_profiler/export/(?P<token>[^/\\.]++)\\.txt$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler_export')), array (  '_controller' => 'web_profiler.controller.profiler:exportAction',));
                }

                // _profiler_phpinfo
                if ($pathinfo === '/_profiler/phpinfo') {
                    return array (  '_controller' => 'web_profiler.controller.profiler:phpinfoAction',  '_route' => '_profiler_phpinfo',);
                }

                // _profiler_search_results
                if (preg_match('#^/_profiler/(?P<token>[^/]++)/search/results$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler_search_results')), array (  '_controller' => 'web_profiler.controller.profiler:searchResultsAction',));
                }

                // _profiler
                if (preg_match('#^/_profiler/(?P<token>[^/]++)$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler')), array (  '_controller' => 'web_profiler.controller.profiler:panelAction',));
                }

                // _profiler_router
                if (preg_match('#^/_profiler/(?P<token>[^/]++)/router$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler_router')), array (  '_controller' => 'web_profiler.controller.router:panelAction',));
                }

                // _profiler_exception
                if (preg_match('#^/_profiler/(?P<token>[^/]++)/exception$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler_exception')), array (  '_controller' => 'web_profiler.controller.exception:showAction',));
                }

                // _profiler_exception_css
                if (preg_match('#^/_profiler/(?P<token>[^/]++)/exception\\.css$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_profiler_exception_css')), array (  '_controller' => 'web_profiler.controller.exception:cssAction',));
                }

            }

            if (0 === strpos($pathinfo, '/_configurator')) {
                // _configurator_home
                if (rtrim($pathinfo, '/') === '/_configurator') {
                    if (substr($pathinfo, -1) !== '/') {
                        return $this->redirect($pathinfo.'/', '_configurator_home');
                    }

                    return array (  '_controller' => 'Sensio\\Bundle\\DistributionBundle\\Controller\\ConfiguratorController::checkAction',  '_route' => '_configurator_home',);
                }

                // _configurator_step
                if (0 === strpos($pathinfo, '/_configurator/step') && preg_match('#^/_configurator/step/(?P<index>[^/]++)$#s', $pathinfo, $matches)) {
                    return $this->mergeDefaults(array_replace($matches, array('_route' => '_configurator_step')), array (  '_controller' => 'Sensio\\Bundle\\DistributionBundle\\Controller\\ConfiguratorController::stepAction',));
                }

                // _configurator_final
                if ($pathinfo === '/_configurator/final') {
                    return array (  '_controller' => 'Sensio\\Bundle\\DistributionBundle\\Controller\\ConfiguratorController::finalAction',  '_route' => '_configurator_final',);
                }

            }

        }

        if (0 === strpos($pathinfo, '/index')) {
            // gsb_homepage
            if ($pathinfo === '/index') {
                return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\DefaultController::indexAction',  '_route' => 'gsb_homepage',);
            }

            // gsb_homepage_visiteurs
            if ($pathinfo === '/indexV') {
                return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::accueilVisiteursAction',  '_route' => 'gsb_homepage_visiteurs',);
            }

            // gsb_homepage_comptable
            if ($pathinfo === '/indexC') {
                return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::accueilComptableAction',  '_route' => 'gsb_homepage_comptable',);
            }

        }

        if (0 === strpos($pathinfo, '/saisieFrais')) {
            // gsb_saisie_frais
            if ($pathinfo === '/saisieFrais') {
                return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::saisirFraisForfaitAction',  '_route' => 'gsb_saisie_frais',);
            }

            // gsb_saisie_frais_type
            if ($pathinfo === '/saisieFraisType') {
                return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::saisirFicheFraisAction',  '_route' => 'gsb_saisie_frais_type',);
            }

            // gsb_saisie_frais_hf
            if ($pathinfo === '/saisieFraisHorsForfait') {
                return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::saisirFraisForfaitHFAction',  '_route' => 'gsb_saisie_frais_hf',);
            }

        }

        // gsb_valide_frais
        if ($pathinfo === '/valideFrais') {
            return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::validerFraisForfaitAction',  '_route' => 'gsb_valide_frais',);
        }

        // gsb_consultation_frais
        if ($pathinfo === '/consultationFrais') {
            return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::consulterFraisAction',  '_route' => 'gsb_consultation_frais',);
        }

        // gsb_update_fhf
        if ($pathinfo === '/updateFHF') {
            return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::updateFHFAction',  '_route' => 'gsb_update_fhf',);
        }

        // gsb_consultation_frais_type
        if ($pathinfo === '/consultationFraisType') {
            return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::consulterFraisAction',  '_route' => 'gsb_consultation_frais_type',);
        }

        // gsb_consultation_Frais_Mois
        if ($pathinfo === '/listeFraisForfait') {
            return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::listerFraisForfaitAction',  '_route' => 'gsb_consultation_Frais_Mois',);
        }

        // gsb_visiteurs_deconnexion
        if ($pathinfo === '/deconnexion') {
            return array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\DefaultController::seDeconnecterAction',  '_route' => 'gsb_visiteurs_deconnexion',);
        }

        // gsb_visiteurs_mod_FhF
        if (0 === strpos($pathinfo, '/modFhF') && preg_match('#^/modFhF/(?P<id>[^/]++)$#s', $pathinfo, $matches)) {
            return $this->mergeDefaults(array_replace($matches, array('_route' => 'gsb_visiteurs_mod_FhF')), array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::modFHFAction',));
        }

        // gsb_visiteurs_sup_FhF
        if (0 === strpos($pathinfo, '/supFhF') && preg_match('#^/supFhF/(?P<id>[^/]++)$#s', $pathinfo, $matches)) {
            return $this->mergeDefaults(array_replace($matches, array('_route' => 'gsb_visiteurs_sup_FhF')), array (  '_controller' => 'Ahe\\gsbBundle\\Controller\\FraisVisiteursController::supFHFAction',));
        }

        // _welcome
        if (rtrim($pathinfo, '/') === '') {
            if (substr($pathinfo, -1) !== '/') {
                return $this->redirect($pathinfo.'/', '_welcome');
            }

            return array (  '_controller' => 'Acme\\DemoBundle\\Controller\\WelcomeController::indexAction',  '_route' => '_welcome',);
        }

        if (0 === strpos($pathinfo, '/demo')) {
            if (0 === strpos($pathinfo, '/demo/secured')) {
                if (0 === strpos($pathinfo, '/demo/secured/log')) {
                    if (0 === strpos($pathinfo, '/demo/secured/login')) {
                        // _demo_login
                        if ($pathinfo === '/demo/secured/login') {
                            return array (  '_controller' => 'Acme\\DemoBundle\\Controller\\SecuredController::loginAction',  '_route' => '_demo_login',);
                        }

                        // _security_check
                        if ($pathinfo === '/demo/secured/login_check') {
                            return array (  '_controller' => 'Acme\\DemoBundle\\Controller\\SecuredController::securityCheckAction',  '_route' => '_security_check',);
                        }

                    }

                    // _demo_logout
                    if ($pathinfo === '/demo/secured/logout') {
                        return array (  '_controller' => 'Acme\\DemoBundle\\Controller\\SecuredController::logoutAction',  '_route' => '_demo_logout',);
                    }

                }

                if (0 === strpos($pathinfo, '/demo/secured/hello')) {
                    // acme_demo_secured_hello
                    if ($pathinfo === '/demo/secured/hello') {
                        return array (  'name' => 'World',  '_controller' => 'Acme\\DemoBundle\\Controller\\SecuredController::helloAction',  '_route' => 'acme_demo_secured_hello',);
                    }

                    // _demo_secured_hello
                    if (preg_match('#^/demo/secured/hello/(?P<name>[^/]++)$#s', $pathinfo, $matches)) {
                        return $this->mergeDefaults(array_replace($matches, array('_route' => '_demo_secured_hello')), array (  '_controller' => 'Acme\\DemoBundle\\Controller\\SecuredController::helloAction',));
                    }

                    // _demo_secured_hello_admin
                    if (0 === strpos($pathinfo, '/demo/secured/hello/admin') && preg_match('#^/demo/secured/hello/admin/(?P<name>[^/]++)$#s', $pathinfo, $matches)) {
                        return $this->mergeDefaults(array_replace($matches, array('_route' => '_demo_secured_hello_admin')), array (  '_controller' => 'Acme\\DemoBundle\\Controller\\SecuredController::helloadminAction',));
                    }

                }

            }

            // _demo
            if (rtrim($pathinfo, '/') === '/demo') {
                if (substr($pathinfo, -1) !== '/') {
                    return $this->redirect($pathinfo.'/', '_demo');
                }

                return array (  '_controller' => 'Acme\\DemoBundle\\Controller\\DemoController::indexAction',  '_route' => '_demo',);
            }

            // _demo_hello
            if (0 === strpos($pathinfo, '/demo/hello') && preg_match('#^/demo/hello/(?P<name>[^/]++)$#s', $pathinfo, $matches)) {
                return $this->mergeDefaults(array_replace($matches, array('_route' => '_demo_hello')), array (  '_controller' => 'Acme\\DemoBundle\\Controller\\DemoController::helloAction',));
            }

            // _demo_contact
            if ($pathinfo === '/demo/contact') {
                return array (  '_controller' => 'Acme\\DemoBundle\\Controller\\DemoController::contactAction',  '_route' => '_demo_contact',);
            }

        }

        throw 0 < count($allow) ? new MethodNotAllowedException(array_unique($allow)) : new ResourceNotFoundException();
    }
}


text:
/* global Java */

define(['boxing'], function(B) {
    var className = "com.eas.client.changes.Command";
    var javaClass = Java.type(className);
    /**
     * Generated constructor.
     * @constructor Command Command
     */
    function Command() {
        var maxArgs = 0;
        var delegate = arguments.length > maxArgs ?
              arguments[maxArgs]
            : new javaClass();

        Object.defineProperty(this, "unwrap", {
            configurable: true,
            value: function() {
                return delegate;
            }
        });
        if(Command.superclass)
            Command.superclass.constructor.apply(this, arguments);
        delegate.setPublished(this);
        /**
         * Indicates the change's type (Insert, Update, Delete or Command).
         */
        this.type = '';
        Object.defineProperty(this, "type", {
            get: function() {
                var value = delegate.type;
                return B.boxAsJs(value);
            }
        });

        /**
         * Parameters of command.
         */
        this.parameters = new Object();
        Object.defineProperty(this, "parameters", {
            get: function() {
                var value = delegate.parameters;
                return B.boxAsJs(value);
            }
        });

        /**
         * Command sql text to be applied in a database.
         */
        this.command = '';
        Object.defineProperty(this, "command", {
            get: function() {
                var value = delegate.command;
                return B.boxAsJs(value);
            }
        });

        /**
         *Indicates the change's destination entity.
         */
        this.entity = '';
        Object.defineProperty(this, "entity", {
            get: function() {
                var value = delegate.entity;
                return B.boxAsJs(value);
            }
        });

    }

    var ScriptsClass = Java.type("com.eas.script.Scripts");
    var space = ScriptsClass.getSpace();
    space.putPublisher(className, function(aDelegate) {
        return new Command(aDelegate);
    });
    return Command;
});

redpajama_set_name: RedPajamaGithub


text:
package com.alibaba.dubbo.common.extensionloader.activate.impl;

import com.alibaba.dubbo.common.extension.Activate;
import com.alibaba.dubbo.common.extensionloader.activate.ActivateExt1;

/**
 * @author kimi
 */
@Activate(group = {"default_group"})
public class ActivateExt1Impl1 implements ActivateExt1 {
    public String echo(String msg) {
        return msg;
    }
}


text:
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render } from '@ember/test-helpers';
import hbs from 'htmlbars-inline-precompile';
import State from 'ember-burger-menu/-private/state';

const template = hbs`
  {{#bm-outlet state=state}}
    Content
  {{/bm-outlet}}
`;

module('Integration | Component | bm outlet', function(hooks) {
  setupRenderingTest(hooks);

  hooks.beforeEach(function() {
    this.setProperties({
      state: State.create()
    });
  });

  test('it renders', async function(assert) {
    await render(template);
    assert.dom('*').hasText('Content');
  });
});


text:
package org.kuali.kfs.sys.document.web.renderers;

public abstract class TotalRendererBase implements Renderer, CellCountCurious, RepresentedCellCurious {
    private int cellCount = 0;
    private String representedCellPropertyName;
    private int columnNumberOfRepresentedCell = 0;

    public void clear() {
        cellCount = 0;
        columnNumberOfRepresentedCell = 0;
        representedCellPropertyName = null;
    }

    /**
     * Gets the cellCount attribute.
     * @return Returns the cellCount.
     */
    public int getCellCount() {
        return cellCount;
    }

    /**
     * Sets the cellCount attribute value.
     * @param cellCount The cellCount to set.
     */
    public void setCellCount(int cellCount) {
        this.cellCount = cellCount;
    }

    /**
     * Gets the representedCellPropertyName attribute.
     * @return Returns the representedCellPropertyName.
     */
    public String getRepresentedCellPropertyName() {
        return representedCellPropertyName;
    }

    /**
     * Sets the representedCellPropertyName attribute value.
     * @param representedCellPropertyName The representedCellPropertyName to set.
     */
    public void setRepresentedCellPropertyName(String representedCellPropertyName) {
        this.representedCellPropertyName = representedCellPropertyName;
    }

    /**
     * Gets the columnNumberOfRepresentedCell attribute.
     * @return Returns the columnNumberOfRepresentedCell.
     */
    public int getColumnNumberOfRepresentedCell() {
        return columnNumberOfRepresentedCell;
    }

    /**
     * Sets the columnNumberOfRepresentedCell attribute value.
     * @param columnNumberOfRepresentedCell The columnNumberOfRepresentedCell to set.
     */
    public void setColumnNumberOfRepresentedCell(int columnNumberOfRepresentedCell) {
        this.columnNumberOfRepresentedCell = columnNumberOfRepresentedCell;
    }

}


text:
require 'aims'
include Aims

describe Atom do

  a = Atom.new(0,0,0,"Atom")
  a_copy = a.copy

  it "Should not be constrained" do
    a.constrained?.should be_false
  end

  it "constrained should be TRUE" do
    a.constrain = true
    a.constrained?.should be_true
  end

  it "constrained should be '.true.'" do
    a.constrain = ".true."
    a.constrained?.should be_true
  end

  it "should == its copy" do
    (a == a_copy).should be_true
  end

  it "should have the same hash as its copy" do
    a.hash.should eq(a_copy.hash)
  end

  it "should eql? its copy" do
    (a.eql?(a_copy)).should be_true
  end

  context "An array of duplicates" do
    it "should have one element when uniq" do
      [a, a_copy].uniq.size.should eq(1)
    end
  end
end


text:
@interface ImageCropPicker : NSObject<
UIImagePickerControllerDelegate,
UINavigationControllerDelegate,
RCTBridgeModule,
QBImagePickerControllerDelegate,
RSKImageCropViewControllerDelegate,
RSKImageCropViewControllerDataSource>

typedef enum selectionMode {
    CAMERA,
    CROPPING,
    PICKER
} SelectionMode;

@property (nonatomic, strong) NSMutableDictionary *croppingFile;
@property (nonatomic, strong) NSDictionary *defaultOptions;
@property (nonatomic, strong) Compression *compression;
@property (nonatomic, retain) NSMutableDictionary *options;
@property (nonatomic, strong) RCTPromiseResolveBlock resolve;
@property (nonatomic, strong) RCTPromiseRejectBlock reject;
@property SelectionMode currentSelectionMode;

@end

#endif


text:
from __future__ import absolute_import

from google.appengine.api import images
from google.appengine.ext import blobstore
from google.appengine.ext import ndb
import flask
import flask_restful
import werkzeug

from api import helpers
import auth
import config
import model
import util
import json
from main import api_v1

###############################################################################
# Endpoints
###############################################################################
@api_v1.resource('/star/<int:post_key>/', endpoint='api.star')
class StarApi(flask_restful.Resource):

  @auth.login_required
  def delete(self, post_key):
      post_db = model.Post.get_by_id(post_key)
      user_db = auth.current_user_key().get()

      stars = model.Star.query(model.Star.post_key==post_db.key, model.Star.user_key==user_db.key).fetch()

      for star in stars:
          star.key.delete()

      return str(stars)

  @auth.login_required
  def put(self, post_key):
      post_db = model.Post.get_by_id(post_key)
      user_db = auth.current_user_key().get()

      star = model.Star(user_key=user_db.key, post_key=post_db.key)
      star_id = star.put()

      return util.jsonpify({'post_key': str(post_db.key.id),
                            'user_key': str(user_db.key.id),
                            'star': str(star_id)})

# curl http://127.0.0.1:8080/api/v1/star/4904028018311168/ -d "data={\"user_key\":\"5629499534213120\"}" -X PUT
# curl http://127.0.0.1:8080/api/v1/star/4904028018311168/ -X DELETE -v


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
org.apache.hadoop.record (Hadoop-common 0.21.0 API)
</TITLE>

<META NAME="date" CONTENT="2010-08-17">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../stylesheet.css" TITLE="Style">

org.apache.hadoop.record

Interfaces

Index

RecordInput

RecordOutput

Classes

BinaryRecordInput

BinaryRecordOutput

Buffer

CsvRecordInput

CsvRecordOutput

Record

RecordComparator

Utils

XmlRecordInput

XmlRecordOutput


text:
/*                        __    __  __  __    __  ___
 *                       \  \  /  /    \  \  /  /  __/
 *                        \  \/  /  /\  \  \/  /  /
 *                         \____/__/  \__\____/__/.ɪᴏ
 * ᶜᵒᵖʸʳᶦᵍʰᵗ ᵇʸ ᵛᵃᵛʳ ⁻ ˡᶦᶜᵉⁿˢᵉᵈ ᵘⁿᵈᵉʳ ᵗʰᵉ ᵃᵖᵃᶜʰᵉ ˡᶦᶜᵉⁿˢᵉ ᵛᵉʳˢᶦᵒⁿ ᵗʷᵒ ᵈᵒᵗ ᶻᵉʳᵒ
 */
package io.vavr.collection;

import io.vavr.*;
import io.vavr.control.Option;
import org.assertj.core.api.Assertions;
import org.assertj.core.api.IterableAssert;
import org.assertj.core.api.ObjectAssert;
import org.junit.Ignore;
import org.junit.Test;

import java.io.InvalidObjectException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Spliterator;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

/**
 * Tests all methods defined in {@link Tree}.
 */
public class TreeTest extends AbstractTraversableTest {

    /**
     *

     *         1
     *        / \
     *       /   \
     *      /     \
     *     2       3
     *    / \     /
     *   4   5   6
     *  /       / \
     * 7       8   9
     *

     */
    private final Tree<Integer> tree = $(1, $(2, $(4, $(7)), $(5)), $(3, $(6, $(8), $(9))));

    @Override
    protected <T> IterableAssert<T> assertThat(Iterable<T> actual) {
        return new IterableAssert<T>(actual) {
            @SuppressWarnings("unchecked")
            @Override
            public IterableAssert<T> isEqualTo(Object expected) {
                if (actual instanceof Option) {
                    final Option<?> opt1 = ((Option<?>) actual);
                    final Option<?> opt2 = (Option<?>) expected;
                    Assertions.assertThat(convOption(opt1)).isEqualTo(convOption(opt2));
                } else if (expected instanceof Map) {
                    final Map<?, ?> map1 = (Map<?, ?>) actual;
                    final Map<?, ?> map2 = (Map<?, ?>) expected;
                    Assertions.assertThat(convMap(map1)).isEqualTo(convMap(map2));
                } else if (expected instanceof Tree) {
                    assertThat(Stream.ofAll(actual)).isEqualTo(Stream.ofAll((Tree<?>) expected));
                } else {
                    Assertions.assertThat(actual).isEqualTo((Iterable<T>) expected);
                }
                return this;
            }

            private Option<?> convOption(Option<?> option) {
                return option.map(o -> (o instanceof Iterable) ? Stream.ofAll((Iterable<?>) o) : o);
            }

            private Map<?, ?> convMap(Map<?, ?> map) {
                return map.map((k, v) -> Tuple.of(k, v instanceof Iterable ? Stream.ofAll((Iterable<?>) v) : v));
            }
        };
    }

    @Override
    protected <T> ObjectAssert<T> assertThat(T actual) {
        return new ObjectAssert<T>(actual) {
            @Override
            public ObjectAssert<T> isEqualTo(Object expected) {
                if (actual instanceof Tuple2) {
                    final Tuple2<?, ?> t1 = (Tuple2<?, ?>) actual;
                    final Tuple2<?, ?> t2 = (Tuple2<?, ?>) expected;
                    assertThat((Iterable<?>) t1._1).isEqualTo(t2._1);
                    assertThat((Iterable<?>) t1._2).isEqualTo(t2._2);
                    return this;
                } else {
                    return super.isEqualTo(expected);
                }
            }
        };
    }

    @Override
    protected <T> Collector<T, ArrayList<T>, Tree<T>> collector() {
        return Tree.collector();
    }

    @Override
    protected <T> Tree<T> empty() {
        return Tree.empty();
    }

    @Override
    protected <T> Tree.Node<T> of(T element) {
        return Tree.of(element);
    }

    @SuppressWarnings("varargs")
    @SafeVarargs
    @Override
    protected final <T> Tree<T> of(T... elements) {
        return Tree.ofAll(List.of(elements));
    }

    @Override
    protected <T> Tree<T> ofAll(Iterable<? extends T> elements) {
        return Tree.ofAll(elements);
    }

    @Override
    protected <T extends Comparable<? super T>> Tree<T> ofJavaStream(java.util.stream.Stream<? extends T> javaStream) {
        return Tree.ofAll(javaStream);
    }

    @Override
    protected Tree<Boolean> ofAll(boolean... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Byte> ofAll(byte... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Character> ofAll(char... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Double> ofAll(double... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Float> ofAll(float... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Integer> ofAll(int... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Long> ofAll(long... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected Tree<Short> ofAll(short... elements) {
        return Tree.ofAll(List.ofAll(elements));
    }

    @Override
    protected <T> Tree<T> tabulate(int n, Function<? super Integer, ? extends T> f) {
        return Tree.tabulate(n, f);
    }

    @Override
    protected <T> Tree<T> fill(int n, Supplier<? extends T> s) {
        return Tree.fill(n, s);
    }

    @Override
    protected boolean useIsEqualToInsteadOfIsSameAs() {
        return true;
    }

    @Override
    protected int getPeekNonNilPerformingAnAction() {
        return 1;
    }

    @SuppressWarnings("varargs")
    @SafeVarargs
    protected final <T> Tree.Node<T> $(T value, Tree.Node<T>... children) {
        return Tree.of(value, children);
    }

    // -- static narrow

    @Test
    public void shouldNarrowTree() {
        final Tree<Double> doubles = of(1.0d);
        final Tree<Number> numbers = Tree.narrow(doubles);
        final boolean actual = numbers.contains(new BigDecimal("2.0"));
        assertThat(actual).isFalse();
    }

    // -- Tree test

    @Test
    public void shouldInstantiateTreeBranchWithOf() {
        final Tree<Integer> actual = Tree.of(1, Tree.of(2), Tree.of(3));
        final Tree<Integer> expected = new Tree.Node<>(1, List.of(new Tree.Node<>(2, List.empty()), new Tree.Node<>(3, List.empty())));
        assertThat(actual).isEqualTo(expected);
    }

    // -- Leaf test

    @Test
    public void shouldInstantiateTreeLeafWithOf() {
        final Tree<Integer> actual = Tree.of(1);
        final Tree<Integer> expected = new Tree.Node<>(1, List.empty());
        assertThat(actual).isEqualTo(expected);
    }

    // -- Node test

    @Test
    public void shouldCreateANodeWithoutChildren() {
        new Tree.Node<>(1, List.empty());
    }

    @Test(expected = InvalidObjectException.class)
    public void shouldNotCallReadObjectOnNodeInstance() throws Throwable {
        Serializables.callReadObject(tree);
    }

    // -- getValue

    @Test(expected = UnsupportedOperationException.class)
    public void shouldNotGetValueOfNil() {
        Tree.empty().getValue();
    }

    @Test
    public void shouldNotGetValueOfNonNil() {
        assertThat(tree.get()).isEqualTo(1);
    }

    // -- size

    @Test
    public void shouldCalculateSizeOfALeaf() {
        assertThat($(0).size()).isEqualTo(1);
    }

    @Test
    public void shouldCalculateSizeOfNestedNodes() {
        assertThat(tree.size()).isEqualTo(9);
    }

    // -- isEmpty

    @Test
    public void shouldIdentifyNilAsEmpty() {
        assertThat(Tree.empty().isEmpty()).isTrue();
    }

    @Test
    public void shouldIdentifyNonNilAsNotEmpty() {
        assertThat(tree.isEmpty()).isFalse();
    }

    // -- isLeaf

    @Test
    public void shouldIdentifyLeafAsLeaf() {
        assertThat($(0).isLeaf()).isTrue();
    }

    @Test
    public void shouldIdentifyNonLeafAsNonLeaf() {
        assertThat(tree.isLeaf()).isFalse();
    }

    @Test
    public void shouldIdentifyNilAsNonLeaf() {
        assertThat(Tree.empty().isLeaf()).isFalse();
    }

    // -- isBranch

    @Test
    public void shouldIdentifyLeafAsNonBranch() {
        assertThat($(0).isBranch()).isFalse();
    }

    @Test
    public void shouldIdentifyNonLeafAsBranch() {
        assertThat(tree.isBranch()).isTrue();
    }

    @Test
    public void shouldIdentifyNilAsNonBranch() {
        assertThat(Tree.empty().isBranch()).isFalse();
    }

    // -- getChildren

    @Test
    public void shouldGetChildrenOfLeaf() {
        assertThat($(0).getChildren()).isEqualTo(List.empty());
    }

    @Test
    public void shouldGetChildrenOfBranch() {
        final List<? extends Tree<Integer>> children = tree.getChildren();
        assertThat(children.length()).isEqualTo(2);
        assertThat(children.get(0).toLispString()).isEqualTo("(2 (4 7) 5)");
        assertThat(children.get(1).toLispString()).isEqualTo("(3 (6 8 9))");
    }

    @Test
    public void shouldIGetChildrenOfNil() {
        assertThat(Tree.empty().getChildren()).isEqualTo(List.empty());
    }

    // -- branchCount

    @Test
    public void shouldCountBranchesOfNil() {
        assertThat(Tree.empty().branchCount()).isEqualTo(0);
    }

    @Test
    public void shouldCountBranchesOfNonNil() {
        assertThat(tree.branchCount()).isEqualTo(5);
    }

    // -- leafCount

    @Test
    public void shouldCountLeavesOfNil() {
        assertThat(Tree.empty().leafCount()).isEqualTo(0);
    }

    @Test
    public void shouldCountLeavesOfNonNil() {
        assertThat(tree.leafCount()).isEqualTo(4);
    }

    // -- nodeCount

    @Test
    public void shouldCountNodesOfNil() {
        assertThat(Tree.empty().nodeCount()).isEqualTo(0);
    }

    @Test
    public void shouldCountNodesOfNonNil() {
        assertThat(tree.nodeCount()).isEqualTo(9);
    }

    // -- contains

    @Test
    public void shouldNotFindNodeInNil() {
        assertThat(Tree.empty().contains(1)).isFalse();
    }

    @Test
    public void shouldFindExistingNodeInNonNil() {
        assertThat(tree.contains(5)).isTrue();
    }

    @Test
    public void shouldNotFindNonExistingNodeInNonNil() {
        assertThat(tree.contains(0)).isFalse();
    }

    // -- flatMap

    @Test
    public void shouldFlatMapEmptyTree() {
        assertThat(Tree.empty().flatMap(t -> Tree.of(1))).isEqualTo(Tree.empty());
    }

    @Test
    public void shouldFlatMapNonEmptyTree() {
        final Tree.Node<Integer> testee = $(1, $(2), $(3));
        final Tree<Integer> actual = testee.flatMap(i -> $(i, $(i), $(i)));
        final Tree<Integer> expected = $(1, $(1), $(1), $(2, $(2), $(2)), $(3, $(3), $(3)));
        assertThat(actual).isEqualTo(expected);
    }

    @Test
    public void shouldFlatMapNonEmptyByExpandingElements() {
        assertThat(of(1, 2, 3).flatMap(i -> {
            if (i == 1) {
                return of(1, 2, 3);
            } else if (i == 2) {
                return of(4, 5);
            } else {
                return of(6);
            }
        })).isEqualTo($(1, $(2), $(3), $(4, $(5)), $(6)));
    }

    @Test
    public void shouldFlatMapNonEmptyInTheRightOrder() {
        final AtomicInteger seq = new AtomicInteger(0);
        final Tree<Integer> actualInts = $(0, $(1), $(2))
                .flatMap(ignored -> of(seq.getAndIncrement(), seq.getAndIncrement()));
        final Tree<Integer> expectedInts = $(0, $(1), $(2, $(3)), $(4, $(5)));
        assertThat(actualInts).isEqualTo(expectedInts);
    }

    // -- iterator

    @Override
    @Test
    public void shouldNotHasNextWhenNilIterator() {
        assertThat(Tree.empty().iterator().hasNext()).isFalse();
    }

    @Override
    @Test(expected = NoSuchElementException.class)
    public void shouldThrowOnNextWhenNilIterator() {
        Tree.empty().iterator().next();
    }

    @Override
    @Test
    public void shouldIterateFirstElementOfNonNil() {
        assertThat(tree.iterator().next()).isEqualTo(1);
    }

    @Override
    @Test
    public void shouldFullyIterateNonNil() {
        final int length = List
                .of(1, 2, 4, 7, 5, 3, 6, 8, 9)
                .zip(tree)
                .filter(t -> Objects.equals(t._1, t._2))
                .length();
        assertThat(length).isEqualTo(9);
    }

    // -- map

    @Test
    public void shouldMapEmpty() {
        assertThat(Tree.empty().map(i -> i)).isEqualTo(Tree.empty());
    }

    @Test
    public void shouldMapTree() {
        assertThat(tree.map(i -> (char) (i + 64)).toLispString()).isEqualTo("(A (B (D G) E) (C (F H I)))");
    }

    // -- replace

    @Test
    public void shouldReplaceNullInEmpty() {
        assertThat(Tree.empty().replace(null, null)).isEmpty();
    }

    @Test
    public void shouldReplaceFirstOccurrenceUsingDepthFirstSearchInNonEmptyTree() {
        //   1        1
        //  / \  ->  / \
        // 2   3    99  3
        final Tree<Integer> testee = Tree.of(1, Tree.of(2), Tree.of(3));
        final Tree<Integer> actual = testee.replace(2, 99);
        final Tree<Integer> expected = Tree.of(1, Tree.of(99), Tree.of(3));
        assertThat(actual).isEqualTo(expected);
    }

    @Test
    public void shouldNotReplaceAnyElementIfThereIsNoOccurrenceInNonEmptyTree() {
        final Tree<Integer> testee = Tree.of(1, Tree.of(2), Tree.of(3));
        final Tree<Integer> actual = testee.replace(4, 99);
        assertThat(actual).isEqualTo(testee);
    }

    // -- values()

    @Test
    public void shouldTraverseValuesOfEmptyTree() {
        assertThat(Tree.empty().values()).isEqualTo(empty());
    }

    // -- values(Order)

    @Test
    public void shouldTraverseValuesUsingPreOrder() {
        assertThat(tree.values(Tree.Order.PRE_ORDER)).isEqualTo(Stream.of(1, 2, 4, 7, 5, 3, 6, 8, 9));
    }

    @Test
    public void shouldTraverseValuesUsingInOrder() {
        assertThat(tree.values(Tree.Order.IN_ORDER)).isEqualTo(Stream.of(7, 4, 2, 5, 1, 8, 6, 9, 3));
    }

    @Test
    public void shouldTraverseValuesUsingPostOrder() {
        assertThat(tree.values(Tree.Order.POST_ORDER)).isEqualTo(Stream.of(7, 4, 5, 2, 8, 9, 6, 3, 1));
    }

    @Test
    public void shouldTraverseValuesUsingLevelOrder() {
        assertThat(tree.values(Tree.Order.LEVEL_ORDER)).isEqualTo(Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9));
    }

    // -- unzip

    @Test
    public void shouldUnzipEmptyTree() {
        assertThat(Tree.empty().unzip(t -> Tuple.of(t, t))).isEqualTo(Tuple.of(Tree.empty(), Tree.empty()));
    }

    @Test
    public void shouldUnzipNonEmptyTree() {
        final Tree<Integer> testee = $(1, $(2), $(3));
        final Tuple2<Tree<Integer>, Tree<Integer>> actual = testee.unzip(i -> Tuple.of(i, -i));
        final Tuple2<Tree<Integer>, Tree<Integer>> expected = Tuple.of($(1, $(2), $(3)), $(-1, $(-2), $(-3)));
        assertThat(actual).isEqualTo(expected);
    }

    @Test
    public void shouldUnzip3EmptyTree() {
        assertThat(Tree.empty().unzip3(t -> Tuple.of(t, t, t))).isEqualTo(Tuple.of(Tree.empty(), Tree.empty(), Tree.empty()));
    }

    @Test
    public void shouldUnzip3NonEmptyTree() {
        final Tree<Integer> testee = $(1, $(2), $(3));
        final Tuple3<Tree<Integer>, Tree<Integer>, Tree<Integer>> actual = testee.unzip3(i -> Tuple.of(i, -i, -i - 1));
        final Tuple3<Tree<Integer>, Tree<Integer>, Tree<Integer>> expected = Tuple.of($(1, $(2), $(3)), $(-1, $(-2), $(-3)), $(-2, $(-3), $(-4)));
        assertThat(actual).isEqualTo(expected);
    }

    // equals

    @SuppressWarnings("EqualsWithItself")
    @Test
    public void shouldBeAwareThatTwoTreesOfSameInstanceAreEqual() {
        // DEV_NOTE: intentionally not called `assertThat(Tree.empty()).isEqualTo(Tree.empty())`
        assertThat(Tree.empty().equals(Tree.empty())).isTrue();
    }

    @Test
    public void shouldBeAwareOfTwoDifferentEqualTrees() {
        assertThat($(0).equals($(0))).isTrue();
    }

    @Test
    public void shouldBeAwareThatTreeNotEqualsObject() {
        assertThat($(0)).isNotEqualTo(new Object());
    }

    // hashCode

    @Test
    public void shouldBeAwareThatHashCodeOfEmptyIsOne() {
        assertThat(Tree.empty().hashCode()).isEqualTo(1);
    }

    @Test
    public void shouldBeAwareThatHashCodeOfLeafIsGreaterThanOne() {
        assertThat($(0).hashCode()).isGreaterThan(1);
    }

    // -- transform()

    @Test
    public void shouldTransform() {
        final String transformed = $(42, $(2), $(3)).transform(v -> String.valueOf(v.get()));
        assertThat(transformed).isEqualTo("42");
    }

    // toString

    @Test
    public void shouldReturnStringRepresentationOfEmpty() {
        assertThat(Tree.empty().toString()).isEqualTo("Tree()");
    }

    @Test
    public void shouldReturnLispStringRepresentationOfNode() {
        assertThat(tree.toString()).isEqualTo("Tree(1, 2, 4, 7, 5, 3, 6, 8, 9)");
    }

    // -- toLispString

    @Test
    public void shouldConvertEmptyToLispString() {
        assertThat(Tree.empty().toLispString()).isEqualTo("()");
    }

    @Test
    public void shouldConvertNonEmptyToLispString() {
        assertThat(tree.toLispString()).isEqualTo("(1 (2 (4 7) 5) (3 (6 8 9)))");
    }

    // draw

    @Test
    public void shouldReturnDrawStringOfEmpty() {
        assertThat(Tree.empty().draw()).isEqualTo("▣");
    }

    @Test
    public void shouldReturnDrawStringOfNode() {
        assertThat(tree.draw()).isEqualTo("1\n" +
                "├──2\n" +
                "│  ├──4\n" +
                "│  │  └──7\n" +
                "│  └──5\n" +
                "└──3\n" +
                "   └──6\n" +
                "      ├──8\n" +
                "      └──9");
    }

    // -- serialization

    @Test
    public void shouldSerializeDeserializeComplexTree() {
        final Object actual = Serializables.deserialize(Serializables.serialize(tree));
        assertThat(actual).isEqualTo(tree);
    }

    // -- toVector

    @Test
    public void shouldReturnSelfOnConvertToTree() {
        final Value<Integer> value = of(1, 2, 3);
        assertThat(value.toTree()).isSameAs(value);
    }

    // ~~~~~~~ DISABLED TESTS ~~~~~~~

    // -- distinctBy(Comparator)

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenDistinctByComparatorEmptyTraversable() {
        // TODO: remove this overridden method with #1826
    }

    // -- distinctBy(Function)

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenDistinctByFunctionEmptyTraversable() {
        // TODO: remove this overridden method with #1826
    }

    // -- drop

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenDropZeroCount() {
        // Tree.drop() returns a Seq
    }

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenDropNegativeCount() {
        // Tree.drop() returns a Seq
    }

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenEmptyDropOne() {
        // Tree.drop() returns a Seq
    }

    // -- dropRight

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenDropRightZeroCount() {
        // Tree.dropRight() returns a Seq
    }

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenDropRightNegativeCount() {
        // Tree.dropRight() returns a Seq
    }

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenEmptyDropRightOne() {
        // Tree.dropRight() returns a Seq
    }

    // -- dropUntil

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenEmptyDropUntil() {
        // Tree.dropUntil returns a Seq
    }

    // -- dropWhile

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenEmptyDropWhile() {
        // Tree.dropWhile returns a Seq
    }

    // -- filter

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenFilteringEmptyTraversable() {
        // TODO: remove this overridden method with #1826
    }

    // -- take

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceIfTakeAll() {
        // Tree.take returns Seq
    }

    // -- takeRight

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceIfTakeRightAll() {
        // Tree.takeRight returns Seq
    }

    // -- takeUntil

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenEmptyTakeUntil() {
        // Tree.takeUntil() returns a Seq
    }

    // -- takeWhile

    @Ignore
    @Override
    @Test
    public void shouldReturnSameInstanceWhenEmptyTakeWhile() {
        // Tree.takeWhile() returns a Seq
    }

    // -- spliterator

    @Test
    public void shouldHaveOrderedSpliterator() {
        assertThat(of(1, 2, 3).spliterator().hasCharacteristics(Spliterator.ORDERED)).isTrue();
    }

    @Test
    public void shouldNotHaveSortedSpliterator() {
        assertThat(of(1, 2, 3).spliterator().hasCharacteristics(Spliterator.SORTED)).isFalse();
    }

    @Test
    public void shouldHaveSizedSpliterator() {
        assertThat(of(1, 2, 3).spliterator().hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED)).isTrue();
    }

    @Test
    public void shouldNotHaveDistinctSpliterator() {
        assertThat(of(1, 2, 3).spliterator().hasCharacteristics(Spliterator.DISTINCT)).isFalse();
    }

    @Test
    public void shouldReturnSizeWhenSpliterator() {
        assertThat(of(1, 2, 3).spliterator().getExactSizeIfKnown()).isEqualTo(3);
    }

    // -- isSequential()

    @Test
    public void shouldReturnTrueWhenIsSequentialCalled() {
        assertThat(of(1, 2, 3).isSequential()).isTrue();
    }

}


text:
#ifndef IVW_PVMVOLUMEREADER_H
#define IVW_PVMVOLUMEREADER_H

#include <modules/pvm/pvmmoduledefine.h>
#include <inviwo/core/common/inviwo.h>
#include <inviwo/core/datastructures/volume/volume.h>
#include <inviwo/core/io/datareader.h>

namespace inviwo {

/** \brief Reader for *.pvm files
 *
 *  Format designed by Stefan Roettger
 */
class IVW_MODULE_PVM_API PVMVolumeReader : public DataReaderType<Volume> {
public:
    PVMVolumeReader();
    PVMVolumeReader(const PVMVolumeReader& rhs) = default;
    PVMVolumeReader& operator=(const PVMVolumeReader& that) = default;
    virtual PVMVolumeReader* clone() const override;
    virtual ~PVMVolumeReader() = default;

    virtual std::shared_ptr<Volume> readData(const std::string& filePath) override;
    static std::shared_ptr<Volume> readPVMData(std::string filePath);

protected:
    void printMetaInfo(const MetaDataOwner&, std::string) const;
};

}  // namespace inviwo

#endif  // IVW_PVMVOLUMEREADER_H


text:
package net.pdp7.v2f.samples.petclinic;

import javax.servlet.annotation.WebServlet;

import org.springframework.beans.factory.annotation.Autowired;

import net.pdp7.v2f.core.web.Router;
import net.pdp7.v2f.core.web.V2FServlet;
import net.pdp7.v2f.core.web.handlers.SaveHandler;

@WebServlet(urlPatterns = {"", "/pets/*", "/visits/*", "/species/*", "/vets/*", "/owners/*"})
public class PetclinicServlet extends V2FServlet {

	@Autowired
	public PetclinicServlet(Router router, SaveHandler saveHandler) {
		super(router, saveHandler);
	}

}


text:
package be.pixxis.zoufzouf.location;

/**
 * Pricing region enumerations.
 *
 * @author Gert Leenders
 */
public enum PricingRegion {

  PR_UNITED_STATES("United States"),
  PR_EUROPE("Europe"),
  PR_HONG_KONG_EO("Hong Kong and others"),
  PR_AUSTRALIA("Australia"),
  PR_SOUTH_AMERICA("South America"),
  PR_JAPAN("Japan"),
  PR_INDIA("India");

  private final String name;

  PricingRegion(final String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return name;
  }
}


text:
if [ "x$1" = x ]; then
  echo $0: need version number
  exit 1
fi
newv=$1
reldir=$HOME/release
reltar=remark-${newv}.tar.gz
reldist=${reldir}/${reltar}
wwwdir=$HOME/hawg/www/remark
wwwfile=${wwwdir}/${reltar}
if [ ! -f ${reldist} ]; then
  echo $0: no reldir ${reldir}
  exit 1
fi
echo copying ${reldist} ...
cp ${reldist} ${wwwfile}
cd ${wwwdir}
echo generating md5 ...
md5 ${reltar} > ${reltar}.md5
echo signing
gpg --detach-sign --armor ${reltar}
if [ "x$2" = x ]; then
  echo making latest
  rm remark-latest.* || exit 1
  ln -s ${reltar} remark-latest.tar.gz
  ln -s ${reltar}.md5 remark-latest.tar.gz.md5
  ln -s ${reltar}.asc remark-latest.tar.gz.asc
fi
echo marking latest
latest="`echo ${newv} | tr . _`"
rm -f LATEST_IS_*
touch LATEST_IS_${latest}
cd
echo copying back md5 and signature
cp ${wwwdir}/${reltar}.md5 ${reldir}
cp ${wwwdir}/${reltar}.asc ${reldir}
echo done.


text:
#ifndef _RANDOM_H_
#define _RANDOM_H_

#include <stdint.h>
#include <stdlib.h>

void random_init(void);
int random_bytes(uint8_t *buf, uint32_t len, uint8_t update_seed);

#endif


text:
package at.marki.Server.Main;

import at.marki.Server.Gui.ServerManagementGui;
import at.marki.Server.Server.SimpleJettyServer;

/**
 * Created by marki on 27.10.13.
 */
class Main {
    public static void main(String[] args) {

        ServerManagementGui gui = new ServerManagementGui();
        gui.startGui();

        try {
            SimpleJettyServer.startServer();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


text:
package models

import (
	"bufio"
	"fmt"
	"net"
	"WJ/models/codec"
	"strings"
	"WJ/src/github.com/astaxie/beego"
)

// 用来记录所有的客户端连接
var ConnMap map[string]*net.TCPConn

func StartLonglink()  {
	var tcpAddr *net.TCPAddr
	ConnMap = make(map[string]*net.TCPConn) //初始化
	tcpAddr,_=net.ResolveTCPAddr("tcp",beego.AppConfig.String("longdir"))

	tcpListener,_:=net.ListenTCP("tcp",tcpAddr) //开启tcp 服务
	//退出时关闭
	defer tcpListener.Close()
	fmt.Println("Long server start  ")
	for{
		tcpConn,err :=tcpListener.AcceptTCP()
		if err !=nil {
			continue
		}
		fmt.Println("A client connected : "+ tcpConn.RemoteAddr().String())
		// 新连接加入 map
		ConnMap[tcpConn.RemoteAddr().String()] = tcpConn

		go tcpPipe(tcpConn)
	}

}

//处理发送过来的消息
func tcpPipe(conn *net.TCPConn)  {
	ipStr :=conn.RemoteAddr().String()
	defer func() {
		fmt.Println("disconnected : "+ ipStr)
		conn.Close()
	}()
	//读取数据
	reader :=bufio.NewReader(conn)
	for {
		message ,err :=codec.Decode(reader)//reader.ReadString('\n')
		if err != nil {
			fmt.Println(err.Error())
			return
		}

		if(strings.Contains(message,"231231231231")){
			continue
		}
		fmt.Println("服务端收到的消息:",message)
		//这里返回消息改为广播
		boradcastMessage(conn.RemoteAddr().String()+":"+string(message))
	}
}
//广播给其它
func boradcastMessage(message string)  {
	//遍历所有客户端并发消息
	for _,conn :=range ConnMap{
		b,err :=codec.Encode(message)
		if err != nil {
			continue
		}
		conn.Write(b)
	}
}


text:
package com.intellij.xdebugger.impl.ui;

import com.intellij.debugger.ui.DebuggerContentInfo;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.executors.DefaultDebugExecutor;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.runners.ProgramRunner;
import com.intellij.execution.runners.RestartAction;
import com.intellij.execution.runners.RunContentBuilder;
import com.intellij.execution.ui.ExecutionConsole;
import com.intellij.execution.ui.RunContentDescriptor;
import com.intellij.execution.ui.actions.CloseAction;
import com.intellij.execution.ui.layout.PlaceInGrid;
import com.intellij.icons.AllIcons;
import com.intellij.ide.actions.ContextHelpAction;
import com.intellij.idea.ActionsBundle;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.project.Project;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.ui.content.Content;
import com.intellij.ui.content.tabs.PinToolwindowTabAction;
import com.intellij.xdebugger.XDebugProcess;
import com.intellij.xdebugger.XDebugSession;
import com.intellij.xdebugger.XDebuggerBundle;
import com.intellij.xdebugger.impl.XDebugSessionImpl;
import com.intellij.xdebugger.impl.actions.XDebuggerActions;
import com.intellij.xdebugger.impl.frame.XDebugViewBase;
import com.intellij.xdebugger.impl.frame.XFramesView;
import com.intellij.xdebugger.impl.frame.XVariablesView;
import com.intellij.xdebugger.impl.frame.XWatchesView;
import com.intellij.xdebugger.impl.ui.tree.actions.SortValuesToggleAction;
import com.intellij.xdebugger.ui.XDebugLayoutCustomizer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @author spleaner
 */
public class XDebugSessionTab extends DebuggerSessionTabBase {
  private XWatchesView myWatchesView;
  private final List<XDebugViewBase> myViews = new ArrayList<XDebugViewBase>();

  public XDebugSessionTab(@NotNull final Project project, @NotNull final XDebugSessionImpl session, final @Nullable Icon icon,
                          ExecutionEnvironment environment, ProgramRunner runner) {
    super(project, "Debug", session.getSessionName(), GlobalSearchScope.allScope(project));
    if (environment != null) {
      setEnvironment(environment);
    }
    myConsole = session.getConsoleView();
    XDebugProcess debugProcess = session.getDebugProcess();
    myRunContentDescriptor = new RunContentDescriptor(myConsole, debugProcess.getProcessHandler(), myUi.getComponent(), mySessionName, icon);
    attachToSession(session, runner, environment, session.getSessionData(), debugProcess);
  }

  private Content createConsoleContent() {
    Content result = myUi.createContent(DebuggerContentInfo.CONSOLE_CONTENT, myConsole.getComponent(),
                                        XDebuggerBundle.message("debugger.session.tab.console.content.name"),
                                        AllIcons.Debugger.Console,
                                        myConsole.getPreferredFocusableComponent());
    result.setCloseable(false);
    return result;
  }

  private Content createVariablesContent(final XDebugSession session) {
    final XVariablesView variablesView = new XVariablesView(session, this);
    myViews.add(variablesView);
    Content result = myUi.createContent(DebuggerContentInfo.VARIABLES_CONTENT, variablesView.getPanel(),
                                        XDebuggerBundle.message("debugger.session.tab.variables.title"),
                                        AllIcons.Debugger.Value, null);
    result.setCloseable(false);

    ActionGroup group = getCustomizedActionGroup(XDebuggerActions.VARIABLES_TREE_TOOLBAR_GROUP);
    result.setActions(group, ActionPlaces.DEBUGGER_TOOLBAR, variablesView.getTree());

    return result;
  }

  private Content createWatchesContent(final XDebugSession session, final XDebugSessionData sessionData) {
    myWatchesView = new XWatchesView(session, this, sessionData);
    myViews.add(myWatchesView);
    Content watchesContent = myUi.createContent(DebuggerContentInfo.WATCHES_CONTENT, myWatchesView.getMainPanel(),
                                         XDebuggerBundle.message("debugger.session.tab.watches.title"), AllIcons.Debugger.Watches, null);
    watchesContent.setCloseable(false);

    return watchesContent;
  }

  private Content createFramesContent(final XDebugSession session) {
    final XFramesView framesView = new XFramesView(session, this);
    myViews.add(framesView);
    Content framesContent = myUi.createContent(DebuggerContentInfo.FRAME_CONTENT, framesView.getMainPanel(),
                                               XDebuggerBundle.message("debugger.session.tab.frames.title"), AllIcons.Debugger.Frame, null);
    framesContent.setCloseable(false);

    return framesContent;
  }

  public ExecutionConsole getConsole() {
    return myConsole;
  }

  public void rebuildViews() {
    for (XDebugViewBase view : myViews) {
      view.rebuildView();
    }
  }

  public XWatchesView getWatchesView() {
    return myWatchesView;
  }

  private void attachToSession(final @NotNull XDebugSession session, final @Nullable ProgramRunner runner,
                               final @Nullable ExecutionEnvironment env, final @NotNull XDebugSessionData sessionData,
                               final @NotNull XDebugProcess debugProcess) {
    myUi.addContent(createFramesContent(session), 0, PlaceInGrid.left, false);
    myUi.addContent(createVariablesContent(session), 0, PlaceInGrid.center, false);
    myUi.addContent(createWatchesContent(session, sessionData), 0, PlaceInGrid.right, false);
    XDebugLayoutCustomizer layoutCustomizer = debugProcess.getLayoutCustomizer();
    final Content consoleContent;
    if (layoutCustomizer != null) {
      consoleContent = layoutCustomizer.registerConsoleContent(myConsole, myUi);
    }
    else {
      consoleContent = createConsoleContent();
      myUi.addContent(consoleContent, 1, PlaceInGrid.bottom, false);
    }
    attachNotificationTo(consoleContent);

    debugProcess.registerAdditionalContent(myUi);
    if (layoutCustomizer != null) {
      layoutCustomizer.registerAdditionalContent(myUi);
    }
    RunContentBuilder.addAdditionalConsoleEditorActions(myConsole, consoleContent);

    if (ApplicationManager.getApplication().isUnitTestMode()) {
      return;
    }

    DefaultActionGroup leftToolbar = new DefaultActionGroup();
    final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance();
    if (runner != null && env != null) {
      RestartAction restartAction = new RestartAction(executor, runner, myRunContentDescriptor, env);
      leftToolbar.add(restartAction);
      restartAction.registerShortcut(myUi.getComponent());
    }

    leftToolbar.addAll(getCustomizedActionGroup(XDebuggerActions.TOOL_WINDOW_LEFT_TOOLBAR_GROUP));

    //group.addSeparator();
    //addAction(group, DebuggerActions.EXPORT_THREADS);
    leftToolbar.addSeparator();

    leftToolbar.add(myUi.getOptions().getLayoutActions());
    final AnAction[] commonSettings = myUi.getOptions().getSettingsActionsList();
    final AnAction commonSettingsList = myUi.getOptions().getSettingsActions();

    final DefaultActionGroup settings = new DefaultActionGroup("DebuggerSettings", commonSettings.length > 0) {
      @Override
      public void update(AnActionEvent e) {
        e.getPresentation().setText(ActionsBundle.message("group.XDebugger.settings.text"));
        e.getPresentation().setIcon(commonSettingsList.getTemplatePresentation().getIcon());
      }

      @Override
      public boolean isDumbAware() {
        return true;
      }
    };
    for (AnAction each : commonSettings) {
      settings.add(each);
    }
    if (commonSettings.length > 0) {
      settings.addSeparator();
    }
    settings.add(new ToggleSortValuesAction(commonSettings.length == 0));

    leftToolbar.add(settings);

    leftToolbar.addSeparator();

    leftToolbar.add(PinToolwindowTabAction.getPinAction());
    leftToolbar.add(new CloseAction(executor, myRunContentDescriptor, getProject()));
    leftToolbar.add(new ContextHelpAction(executor.getHelpId()));

    DefaultActionGroup topToolbar = new DefaultActionGroup();
    topToolbar.addAll(getCustomizedActionGroup(XDebuggerActions.TOOL_WINDOW_TOP_TOOLBAR_GROUP));

    debugProcess.registerAdditionalActions(leftToolbar, topToolbar);
    myUi.getOptions().setLeftToolbar(leftToolbar, ActionPlaces.DEBUGGER_TOOLBAR);
    myUi.getOptions().setTopToolbar(topToolbar, ActionPlaces.DEBUGGER_TOOLBAR);

    if (env != null) {
      final RunProfile runConfiguration = env.getRunProfile();
      registerFileMatcher(runConfiguration);
      initLogConsoles(runConfiguration, myRunContentDescriptor.getProcessHandler(), myConsole);
    }

    rebuildViews();
  }

  @Override
  @Nullable
  public RunContentDescriptor getRunContentDescriptor() {
    return myRunContentDescriptor;
  }

  private static class ToggleSortValuesAction extends SortValuesToggleAction {
    private final boolean myShowIcon;

    private ToggleSortValuesAction(boolean showIcon) {
      copyFrom(ActionManager.getInstance().getAction(XDebuggerActions.TOGGLE_SORT_VALUES));
      myShowIcon = showIcon;
    }

    @Override
    public void update(AnActionEvent e) {
      super.update(e);
      if (!myShowIcon) {
        e.getPresentation().setIcon(null);
      }
    }
  }
}


text:
import commit

class Head(object):
    """
    A Head is a named reference to a Commit. Every Head instance contains a name
    and a Commit object.

    Examples::

        >>> repo = Repo("/path/to/repo")
        >>> head = repo.heads[0]

        >>> head.name
        'master'

        >>> head.commit
        <git.Commit "1c09f116cbc2cb4100fb6935bb162daa4723f455">

        >>> head.commit.id
        '1c09f116cbc2cb4100fb6935bb162daa4723f455'
    """

    def __init__(self, name, commit):
        """
        Initialize a newly instanced Head

        `name`
            is the name of the head

        `commit`
            is the Commit object that the head points to
        """
        self.name = name
        self.commit = commit

    @classmethod
    def find_all(cls, repo, **kwargs):
        """
        Find all Heads in the repository

        `repo`
            is the Repo

        `kwargs`
            Additional options given as keyword arguments, will be passed
            to git-for-each-ref

        Returns
            git.Head[]

            List is sorted by committerdate
        """

        options = {'sort': "committerdate",
                   'format': "%(refname)%00%(objectname)"}
        options.update(kwargs)

        output = repo.git.for_each_ref("refs/heads", **options)
        return cls.list_from_string(repo, output)

    @classmethod
    def list_from_string(cls, repo, text):
        """
        Parse out head information into a list of head objects

        ``repo``
            is the Repo
        ``text``
            is the text output from the git-for-each-ref command

        Returns
            git.Head[]
        """
        heads = []

        for line in text.splitlines():
            heads.append(cls.from_string(repo, line))

        return heads

    @classmethod
    def from_string(cls, repo, line):
        """
        Create a new Head instance from the given string.

        ``repo``
            is the Repo

        ``line``
            is the formatted head information

        Format::

            name: [a-zA-Z_/]+
            <null byte>
            id: [0-9A-Fa-f]{40}

        Returns
            git.Head
        """
        full_name, ids = line.split("\x00")

        if full_name.startswith('refs/heads/'):
            name = full_name[len('refs/heads/'):]
        else:
            name = full_name

        c = commit.Commit(repo, id=ids)
        return Head(name, c)

    def __repr__(self):
        return '<git.Head "%s">' % self.name


text:
package ru.stqa.selenium_training.tests.ui;

import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

public class CheckValidOpenPage extends BaseTests{
    class Price {
        String price;
        String[] color;
        String lineThrough;
        String fontWeight;
        double fontSize;
    }

    @Test
    public void CheckValidOpenPage() {

        String regularPriceXPath = ".//s[@class='regular-price']";
        String campaignPriceXPath = ".//strong[@class='campaign-price']";

        wd.get("http://localhost/litecart/");

        WebElement productOnHomePage = wd.findElement(By.xpath("//*[@id='box-campaigns']/div/ul/li[1]"));

        String nameProduct1 = productOnHomePage.findElement(By.xpath(".//div[@class='name']")).getText();
        System.out.println("\n----------------------------------\nnameProduct1 - " + nameProduct1);

        //Regular/Campaign price and attribute
        Price regularPrice1 = getPriceAttribute("regularPrice:", regularPriceXPath, productOnHomePage);
        Price campaignPrice1 = getPriceAttribute("campaignPrice:", campaignPriceXPath, productOnHomePage);

        //GO TO linkProductPage
        wd.get(productOnHomePage.findElement(By.xpath(".//a")).getAttribute("href"));

        WebElement productPage = wd.findElement(By.xpath("//div[@id='box-product']"));

        String nameProduct2 = productPage.findElement(By.xpath(".//h1[@itemprop='name']")).getText();
        System.out.println("\n----------------------------------\nnameProduct2 - " + nameProduct2);

        //Regular/Campaign price and attribute
        Price regularPrice2 = getPriceAttribute("regularPrice:", regularPriceXPath, productPage);
        Price campaignPrice2 = getPriceAttribute("campaignPrice:", campaignPriceXPath, productPage);

        //Check name product and price
        System.out.println(nameProduct2.equals(nameProduct1) ?
                "CHECK: " + nameProduct1 + " == " + nameProduct2 :
                "ERROR: " + nameProduct1 + " != " + nameProduct2);
        System.out.println(regularPrice2.price.equals(regularPrice1.price) ?
                "CHECK: " + regularPrice1.price + " == " + regularPrice2.price :
                "ERROR: " + regularPrice1.price + " != " + regularPrice2.price);
        System.out.println(campaignPrice2.price.equals(campaignPrice1.price) ?
                "CHECK: " + campaignPrice1.price + " == " + campaignPrice2.price :
                "ERROR: " + campaignPrice1.price + " != " + campaignPrice2.price);

        //Check color
        System.out.println(regularPrice1.color[0].equals(regularPrice1.color[1]) & regularPrice1.color[0].equals(regularPrice1.color[2]) ?
                "CHECK: regularPrice1.color == GREY" :
                "ERROR: regularPrice1.color != GREY");
        System.out.println(!campaignPrice1.color[0].equals(regularPrice1.color[1]) & regularPrice1.color[1].equals(regularPrice1.color[2]) ?
                "CHECK: campaignPrice1.color == RED" :
                "ERROR: campaignPrice1.color != RED");
        System.out.println(regularPrice2.color[0].equals(regularPrice2.color[1]) & regularPrice2.color[0].equals(regularPrice2.color[2]) ?
                "CHECK: regularPrice2.color == GREY" :
                "ERROR: regularPrice2.color != GREY");
        System.out.println(!campaignPrice2.color[0].equals(regularPrice2.color[1]) & regularPrice2.color[1].equals(regularPrice2.color[2]) ?
                "CHECK: campaignPrice2.color == RED" :
                "ERROR: campaignPrice2.color != RED");

        //Check font
        System.out.println(regularPrice1.lineThrough.equals("line-through") ?
                "CHECK: regularPrice1.lineThrough == line-through" :
                "ERROR: regularPrice1.lineThrough != line-through");
        System.out.println(campaignPrice1.fontWeight.equals("bold") ?
                "CHECK: campaignPrice1.fontWeight == bold" :
                "ERROR: campaignPrice1.fontWeight != bold");

        //Check font size for price
        System.out.println(regularPrice1.fontSize < campaignPrice1.fontSize ?
                "CHECK: regularPrice1.fontSize < campaignPrice1.fontSize == true" :
                "ERROR: regularPrice1.fontSize < campaignPrice1.fontSize == false");
        System.out.println(regularPrice2.fontSize < campaignPrice2.fontSize ?
                "CHECK: regularPrice2.fontSize < campaignPrice2.fontSize == true" :
                "ERROR: regularPrice2.fontSize < campaignPrice2.fontSize == false");
    }

    Price getPriceAttribute(String info, String priceXPath, WebElement product) {
        Price price = new Price();
        String TEMP;

        System.out.println("\n" + info + "\n-----");

        price.price = product.findElement(By.xpath(priceXPath)).getText();
        System.out.println("    |-  Price - " + price.price);

        TEMP = product.findElement(By.xpath(priceXPath)).getCssValue("color");
        price.color = TEMP.substring(TEMP.indexOf("(") + 1, TEMP.indexOf(")") ).split(",");
        System.out.println("    |-  color - " + TEMP + " ->> result: " + price.color[0] + ", " + price.color[1] + ", " + price.color[2]);

        price.lineThrough = product.findElement(By.xpath(priceXPath)).getCssValue("text-decoration-line");
        System.out.println("    |-  lineThrough - " + price.lineThrough);

        price.fontWeight = product.findElement(By.xpath(priceXPath)).getCssValue("font-weight");
        System.out.println("    |-  fontWeight - " + price.fontWeight);

        TEMP = product.findElement(By.xpath(priceXPath)).getCssValue("font-size");
        price.fontSize = Double.parseDouble(TEMP.substring(0, TEMP.indexOf("p")));
        System.out.println("    |-  fontSize - " + price.fontSize + " px");

        return price;
    }
}


text:
package org.zstack.sdk;

/**
 * Created by xing5 on 2016/12/9.
 */
public class ApiException extends RuntimeException {
    public ApiException() {
    }

    public ApiException(String message) {
        super(message);
    }

    public ApiException(String message, Throwable cause) {
        super(message, cause);
    }

    public ApiException(Throwable cause) {
        super(cause);
    }

    public ApiException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}


text:
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/dist/";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 94);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
/* globals __VUE_SSR_CONTEXT__ */

// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
// This module is a runtime utility for cleaner component module output and will
// be included in the final webpack user bundle.

function normalizeComponent (
  scriptExports,
  render,
  staticRenderFns,
  functionalTemplate,
  injectStyles,
  scopeId,
  moduleIdentifier, /* server only */
  shadowMode /* vue-cli only */
) {
  // Vue.extend constructor export interop
  var options = typeof scriptExports === 'function'
    ? scriptExports.options
    : scriptExports

  // render functions
  if (render) {
    options.render = render
    options.staticRenderFns = staticRenderFns
    options._compiled = true
  }

  // functional template
  if (functionalTemplate) {
    options.functional = true
  }

  // scopedId
  if (scopeId) {
    options._scopeId = 'data-v-' + scopeId
  }

  var hook
  if (moduleIdentifier) { // server build
    hook = function (context) {
      // 2.3 injection
      context =
        context || // cached call
        (this.$vnode && this.$vnode.ssrContext) || // stateful
        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
      // 2.2 with runInNewContext: true
      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
        context = __VUE_SSR_CONTEXT__
      }
      // inject component styles
      if (injectStyles) {
        injectStyles.call(this, context)
      }
      // register component module identifier for async chunk inferrence
      if (context && context._registeredComponents) {
        context._registeredComponents.add(moduleIdentifier)
      }
    }
    // used by ssr in case component is cached and beforeCreate
    // never gets called
    options._ssrRegister = hook
  } else if (injectStyles) {
    hook = shadowMode
      ? function () { injectStyles.call(this, this.$root.$options.shadowRoot) }
      : injectStyles
  }

  if (hook) {
    if (options.functional) {
      // for template-only hot-reload because in that case the render fn doesn't
      // go through the normalizer
      options._injectStyles = hook
      // register for functioal component in vue file
      var originalRender = options.render
      options.render = function renderWithStyleInjection (h, context) {
        hook.call(context)
        return originalRender(h, context)
      }
    } else {
      // inject component registration as beforeCreate hook
      var existing = options.beforeCreate
      options.beforeCreate = existing
        ? [].concat(existing, hook)
        : [hook]
    }
  }

  return {
    exports: scriptExports,
    options: options
  }
}

/***/ }),

/***/ 94:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/container/src/main.vue?vue&type=template&id=5bf181d4&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "section",
    { staticClass: "el-container", class: { "is-vertical": _vm.isVertical } },
    [_vm._t("default")],
    2
  )
}
var staticRenderFns = []
render._withStripped = true

// CONCATENATED MODULE: ./packages/container/src/main.vue?vue&type=template&id=5bf181d4&

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/container/src/main.vue?vue&type=script&lang=js&
//
//
//
//
//
//

/* harmony default export */ var mainvue_type_script_lang_js_ = ({
  name: 'ElContainer',

  componentName: 'ElContainer',

  props: {
    direction: String
  },

  computed: {
    isVertical: function isVertical() {
      if (this.direction === 'vertical') {
        return true;
      } else if (this.direction === 'horizontal') {
        return false;
      }
      return this.$slots && this.$slots.default ? this.$slots.default.some(function (vnode) {
        var tag = vnode.componentOptions && vnode.componentOptions.tag;
        return tag === 'el-header' || tag === 'el-footer';
      }) : false;
    }
  }
});
// CONCATENATED MODULE: ./packages/container/src/main.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_mainvue_type_script_lang_js_ = (mainvue_type_script_lang_js_);
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/container/src/main.vue

/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_mainvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null

)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/container/src/main.vue"
/* harmony default export */ var main = (component.exports);
// CONCATENATED MODULE: ./packages/container/index.js

/* istanbul ignore next */
main.install = function (Vue) {
  Vue.component(main.name, main);
};

/* harmony default export */ var container = __webpack_exports__["default"] = (main);

/***/ })

/******/ });


text:
<#
    .SYNOPSIS
    Initializes resources of a Document DB collection to support server-side bulkimport of documents.

    .DESCRIPTION
    Initialize-DocumentDbBulkImport checks for necessary resources to support server-side bulkimport of JSON documents into a Document DB collection and creates any resources that aren't present and initialized.

    .PARAMETER Database
    Specifies the database name for the collection.

    .PARAMETER Collection
    Specifies the collection name.

    .PARAMETER PartitionKeyPath
    Specifies the property to use as the key for partitioning data across a collection. Sets the PartitionKey value during collection creation.

    .PARAMETER Throughput
    Specifies the request units per second to reserve for the collection.

    .PARAMETER Uri
    Specifies the URI of the Document DB REST endpoint.

    .PARAMETER Version
    Specifies the version of the Document DB REST API.

    .PARAMETER Credential
    Specifies the credentials for accessing the Document DB REST endpoint.

    .NOTES
    Author: Jesse Davis (@secabstraction)
    License: BSD 3-Clause

    .LINK
    https://github.com/Azure/azure-documentdb-js-server
#>
function Initialize-DocumentDbBulkImport {
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]
        ${Database},

        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]
        ${Collection},

        [Parameter(ParameterSetName='Partitioned')]
        [ValidateNotNullOrEmpty()]
        [string]
        ${PartitionKeyPath} = 'ComputerName',

        [Parameter(ParameterSetName='Partitioned')]
        [ValidateRange(1000,250000)]
        [int]
        ${Throughput} = 50000,

        [int]
        ${TimeToLive} = -1,

        [ValidateNotNullOrEmpty()]
        [uri]
        ${Uri},

        [ValidateNotNullOrEmpty()]
        [string]
        ${Version},

        [ValidateNotNull()]
        [System.Management.Automation.PSCredential]
        [System.Management.Automation.CredentialAttribute()]
        ${Credential}
    )

    switch -regex ($PSBoundParameters.Key) {
        'Database|Collection|PartitionKeyPath|Throughput|TimeToLive' {
            $null = $PSBoundParameters.Remove($_) # used in this script only
        }
    }

    $PSBoundParameters['ErrorAction'] = 'SilentlyContinue'
    $PSBoundParameters['ErrorVariable'] = 'ResourceError'

    # Check for collection
    $CollectionLink = 'dbs/{0}/colls/{1}' -f $Database, $Collection
    $null = Get-DocumentDbResource -Link $CollectionLink @PSBoundParameters
    if ($ResourceError.Count) {

        if ($ResourceError[0].InnerException.Response.StatusCode -ne 'NotFound') {
            throw $ResourceError
        } else { # Create collection, but check for database first
            $ResourceError.Clear()
            $null = Get-DocumentDbResource -Link "dbs/$Database" @PSBoundParameters
            if ($ResourceError.Count) {

                if ($ResourceError[0].InnerException.Response.StatusCode -ne 'NotFound') {
                    throw $ResourceError
                } else { # Create database
                    $ResourceError.Clear()
                    $Resource = @{
                        Type = 'dbs'
                        Body = '{{"id":"{0}"}}' -f $Database
                    }

                    $null = New-DocumentDbResource @Resource @PSBoundParameters
                    if ($ResourceError.Count) {
                        throw $ResourceError
                    }
                }
            }

            $Resource = @{
                Type = 'colls'
                Link = "dbs/$Database"
                Headers = @{ 'x-ms-offer-throughput' = $Throughput }
                Body = ConvertTo-Json -Compress -InputObject @{
                    id = $Collection
                    indexingPolicy = @{
                        automatic = $true
                        indexingMode = 'Lazy' # should increase throughput
                    }
                    partitionKey = @{
                        paths = @("/$PartitionKeyPath")
                        kind = 'Hash'
                    }
                    defaultTtl = $TimeToLive
                }
            }

            $null = New-DocumentDbResource @Resource @PSBoundParameters
            if ($ResourceError.Count) {
                throw $ResourceError
            }
        }
    }

    # bulkImport stored procedure, here-string is portable
    # https://github.com/Azure/azure-documentdb-js-server/blob/master/samples/stored-procedures/BulkImport.js
    $Procedure = @'
function bulkImport(docs) {
    var count = 0;
    var collection = getContext().getCollection();
    var collectionLink = collection.getSelfLink();

    if (!docs) throw new Error("The array is undefined or null.");

    var docsLength = docs.length;

    if (docsLength == 0) {
        getContext().getResponse().setBody(0);
        return;
    }

    tryCreateDoc(docs[count], tryCreateNextDoc);

    function tryCreateDoc(doc, callback) {
        var isAccepted = collection.createDocument(collectionLink, doc, tryCreateNextDoc);
        if (!isAccepted) getContext().getResponse().setBody(count);
    }

    function tryCreateNextDoc(err, doc, options) {
        if (err) throw err;

        count++;

        if (count >= docsLength) {
            getContext().getResponse().setBody(count);
        } else {
            tryCreateDoc(docs[count], tryCreateNextDoc);
        }
    }
}
'@
    $Resource = @{
        Type = 'sprocs'
        Link = $CollectionLink
        Body = ConvertTo-Json -Compress -InputObject @{
            id = 'bulkImport'
            body = $Procedure
        }
    }

    $null = New-DocumentDbResource @Resource @PSBoundParameters
    if ($ResourceError.Count) {
        throw $ResourceError
    }
}


text:
package org.springframework.security.oauth2.client;

import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Consumer;

import org.springframework.lang.Nullable;
import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.client.registration.ClientRegistration;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

/**
 * Represents a request the {@link OAuth2AuthorizedClientManager} uses to
 * {@link OAuth2AuthorizedClientManager#authorize(OAuth2AuthorizeRequest) authorize} (or
 * re-authorize) the {@link ClientRegistration client} identified by the provided
 * {@link #getClientRegistrationId() clientRegistrationId}.
 *
 * @author Joe Grandja
 * @since 5.2
 * @see OAuth2AuthorizedClientManager
 */
public final class OAuth2AuthorizeRequest {

	private String clientRegistrationId;

	private OAuth2AuthorizedClient authorizedClient;

	private Authentication principal;

	private Map<String, Object> attributes;

	private OAuth2AuthorizeRequest() {
	}

	/**
	 * Returns the identifier for the {@link ClientRegistration client registration}.
	 * @return the identifier for the client registration
	 */
	public String getClientRegistrationId() {
		return this.clientRegistrationId;
	}

	/**
	 * Returns the {@link OAuth2AuthorizedClient authorized client} or {@code null} if it
	 * was not provided.
	 * @return the {@link OAuth2AuthorizedClient} or {@code null} if it was not provided
	 */
	@Nullable
	public OAuth2AuthorizedClient getAuthorizedClient() {
		return this.authorizedClient;
	}

	/**
	 * Returns the {@code Principal} (to be) associated to the authorized client.
	 * @return the {@code Principal} (to be) associated to the authorized client
	 */
	public Authentication getPrincipal() {
		return this.principal;
	}

	/**
	 * Returns the attributes associated to the request.
	 * @return a {@code Map} of the attributes associated to the request
	 */
	public Map<String, Object> getAttributes() {
		return this.attributes;
	}

	/**
	 * Returns the value of an attribute associated to the request or {@code null} if not
	 * available.
	 * @param name the name of the attribute
	 * @param <T> the type of the attribute
	 * @return the value of the attribute associated to the request
	 */
	@Nullable
	@SuppressWarnings("unchecked")
	public <T> T getAttribute(String name) {
		return (T) this.getAttributes().get(name);
	}

	/**
	 * Returns a new {@link Builder} initialized with the identifier for the
	 * {@link ClientRegistration client registration}.
	 * @param clientRegistrationId the identifier for the {@link ClientRegistration client
	 * registration}
	 * @return the {@link Builder}
	 */
	public static Builder withClientRegistrationId(String clientRegistrationId) {
		return new Builder(clientRegistrationId);
	}

	/**
	 * Returns a new {@link Builder} initialized with the {@link OAuth2AuthorizedClient
	 * authorized client}.
	 * @param authorizedClient the {@link OAuth2AuthorizedClient authorized client}
	 * @return the {@link Builder}
	 */
	public static Builder withAuthorizedClient(OAuth2AuthorizedClient authorizedClient) {
		return new Builder(authorizedClient);
	}

	/**
	 * A builder for {@link OAuth2AuthorizeRequest}.
	 */
	public static final class Builder {

		private String clientRegistrationId;

		private OAuth2AuthorizedClient authorizedClient;

		private Authentication principal;

		private Map<String, Object> attributes;

		private Builder(String clientRegistrationId) {
			Assert.hasText(clientRegistrationId, "clientRegistrationId cannot be empty");
			this.clientRegistrationId = clientRegistrationId;
		}

		private Builder(OAuth2AuthorizedClient authorizedClient) {
			Assert.notNull(authorizedClient, "authorizedClient cannot be null");
			this.authorizedClient = authorizedClient;
		}

		/**
		 * Sets the name of the {@code Principal} (to be) associated to the authorized
		 * client.
		 * @param principalName the name of the {@code Principal} (to be) associated to
		 * the authorized client
		 * @return the {@link Builder}
		 * @since 5.3
		 */
		public Builder principal(String principalName) {
			return principal(createAuthentication(principalName));
		}

		private static Authentication createAuthentication(final String principalName) {
			Assert.hasText(principalName, "principalName cannot be empty");
			return new AbstractAuthenticationToken(null) {

				@Override
				public Object getCredentials() {
					return "";
				}

				@Override
				public Object getPrincipal() {
					return principalName;
				}

			};
		}

		/**
		 * Sets the {@code Principal} (to be) associated to the authorized client.
		 * @param principal the {@code Principal} (to be) associated to the authorized
		 * client
		 * @return the {@link Builder}
		 */
		public Builder principal(Authentication principal) {
			this.principal = principal;
			return this;
		}

		/**
		 * Provides a {@link Consumer} access to the attributes associated to the request.
		 * @param attributesConsumer a {@link Consumer} of the attributes associated to
		 * the request
		 * @return the {@link Builder}
		 */
		public Builder attributes(Consumer<Map<String, Object>> attributesConsumer) {
			if (this.attributes == null) {
				this.attributes = new HashMap<>();
			}
			attributesConsumer.accept(this.attributes);
			return this;
		}

		/**
		 * Sets an attribute associated to the request.
		 * @param name the name of the attribute
		 * @param value the value of the attribute
		 * @return the {@link Builder}
		 */
		public Builder attribute(String name, Object value) {
			if (this.attributes == null) {
				this.attributes = new HashMap<>();
			}
			this.attributes.put(name, value);
			return this;
		}

		/**
		 * Builds a new {@link OAuth2AuthorizeRequest}.
		 * @return a {@link OAuth2AuthorizeRequest}
		 */
		public OAuth2AuthorizeRequest build() {
			Assert.notNull(this.principal, "principal cannot be null");
			OAuth2AuthorizeRequest authorizeRequest = new OAuth2AuthorizeRequest();
			if (this.authorizedClient != null) {
				authorizeRequest.clientRegistrationId = this.authorizedClient.getClientRegistration()
						.getRegistrationId();
				authorizeRequest.authorizedClient = this.authorizedClient;
			}
			else {
				authorizeRequest.clientRegistrationId = this.clientRegistrationId;
			}
			authorizeRequest.principal = this.principal;
			authorizeRequest.attributes = Collections.unmodifiableMap(CollectionUtils.isEmpty(this.attributes)
					? Collections.emptyMap() : new LinkedHashMap<>(this.attributes));
			return authorizeRequest;
		}

	}

}