text:
'use strict';

var path = require('path'),
    util = require('util'),
    inherit = require('inherit'),
    debug = require('debug'),
    wd = require('wd'),
    _ = require('lodash'),
    q = require('q'),
    chalk = require('chalk'),
    polyfillService = require('polyfill-service'),
    browserify = require('browserify'),
    Image = require('../image'),
    Actions = require('./actions'),

    ClientBridge = require('./client-bridge'),

    GeminiError = require('../errors/gemini-error'),

    OPERA_NOT_SUPPORTED = 'Not supported in OperaDriver yet';

var Browser = inherit({
    __constructor: function(config) {
        this.config = config;
        this.id = config.id;
        this._browser = wd.promiseRemote(config.gridUrl);
        this.log = debug('gemini:browser:' + this.id);

        var wdLog = debug('gemini:webdriver:' + this.id);

        this._browser.on('connection', function(code, message, error) {
            wdLog('Error: code %d, %s', code, message);
        });

        this._browser.on('status', function(info) {
            wdLog(info);
        });
        this._browser.on('command', function(eventType, command, response) {
            if (eventType === 'RESPONSE' && command === 'takeScreenshot()') {
                response = '<binary-data>';
            }
            if (typeof response !== 'string') {
                response = JSON.stringify(response);
            }
            wdLog(chalk.cyan(eventType), command, chalk.grey(response || ''));
        });
    },

    launch: function(calibrator) {
        var _this = this;
        return this.initSession()
            .then(function() {
                return _this._setDefaultSize();
            })
            .then(function() {
                //maximize is required, because default
                //windows size in phantomjs can prevent
                //some shadows from fitting in
                if (_this._shouldMaximize()) {
                    return _this._maximize();
                }
            })
            .then(function() {
                if (!_this.config.calibrate  || _this._calibration) {
                    return;
                }
                return calibrator.calibrate(_this)
                    .then(function(result) {
                        _this._calibration = result;
                    });
            })
            .then(function() {
                return _this._buildPolyfills();
            })
            .then(function() {
                return _this.buildScripts();
            })
            .then(function() {
                return _this.chooseLocator();
            })
            .fail(function(e) {
                if (e.code === 'ECONNREFUSED') {
                    return q.reject(new GeminiError(
                        'Unable to connect to ' + _this.config.gridUrl,
                        'Make sure that URL in config file is correct and selenium\nserver is running.'
                    ));
                }

                var error = new GeminiError(
                    util.format('Cannot launch browser %s:\n%s', _this.id, e.message)
                );

                error.browserId = _this.id;
                error.browserSessionId = _this.sessionId;
                // sadly, selenium does not provide a way to distinguish different
                // reasons of failure
                return q.reject(error);
            });
    },

    initSession: function() {
        var _this = this;

        return this._browser
            .configureHttp({
                retries: 'never',
                timeout: this.config.httpTimeout
            })
            .then(function() {
                return _this._browser.init(_this.capabilities);
            })
            .spread(function(sessionId, actualCapabilities) {
                _this.sessionId = sessionId;
                _this.log('launched session %o', _this);
            });
    },

    _setDefaultSize: function() {
        var size = this.config.windowSize;
        if (!size) {
            return;
        }
        return this._browser.setWindowSize(size.width, size.height)
            .fail(function(e) {
                // Its the only reliable way to detect not supported operation
                // in legacy operadriver.
                var message = e.cause && e.cause.value && e.cause.value.message;
                if (message === OPERA_NOT_SUPPORTED) {
                    console.warn(chalk.yellow('WARNING!'));
                    console.warn('Legacy Opera Driver does not support window resizing');
                    console.warn('windowSize setting will be ignored.');
                    return;
                }
                return q.reject(e);
            });
    },

    _buildPolyfills: function() {
        /*jshint evil:true*/
        //polyfills are needed for older browsers, namely, IE8

        var _this = this;
        return _this._browser.eval('navigator.userAgent')
            .then(function(ua) {
                return polyfillService.getPolyfillString({
                    uaString: ua,
                    minify: true,
                    features: {
                        'getComputedStyle': {flags: ['gated']},
                        'matchMedia': {flags: ['gated']},
                        'document.querySelector': {flags: ['gated']},
                        'String.prototype.trim': {flags: ['gated']}
                    }
                });
            })
            .then(function(polyfill) {
                _this._polyfill = polyfill;
            });
    },

    openRelative: function(relativeURL) {
        return this.open(this.config.getAbsoluteUrl(relativeURL));
    },

    open: function(url) {
        return this._browser.get(url);
    },

    injectScript: function(script) {
        return this._browser.execute(script);
    },

    evalScript: function(script) {
        /*jshint evil:true*/
        return this._browser.eval(script);
    },

    buildScripts: function() {
        var script = browserify({
                entries: './gemini',
                basedir: path.join(__dirname, 'client-scripts')
            });

        if (!this.config.system.coverage.enabled) {
            script.exclude('./gemini.coverage');
        }

        script.transform({sourcemap: false, global: true}, 'uglifyify');
        var queryLib = this._needsSizzle? './query.sizzle.js' : './query.native.js';
        script.transform({
            aliases: {
                './query': {relative: queryLib}
            },
            verbose: false
        }, 'aliasify');

        var _this = this;

        return q.nfcall(script.bundle.bind(script))
            .then(function(buf) {
                var scripts = _this._polyfill + '\n' + buf.toString();
                _this._clientBridge = new ClientBridge(_this, scripts);
                return scripts;
            });
    },

    get _needsSizzle() {
        return this._calibration && !this._calibration.hasCSS3Selectors;
    },

    chooseLocator: function() {
        this.findElement = this._needsSizzle? this._findElementScript : this._findElementWd;
    },

    reset: function() {
        var _this = this;
        // We can't use findElement here because it requires page with body tag
        return this.evalScript('document.body')
            .then(function(body) {
                // Selenium IEDriver doesn't move cursor to (0, 0) first time
                // https://github.com/SeleniumHQ/selenium/issues/672
                // So we do it in two steps: -> (1, 1) -> (0, 0)
                return _this._browser.moveTo(body, 1, 1)
                    .then(_this._browser.moveTo.bind(_this._browser, body, 0, 0));
            })
            .fail(function(e) {
                return q.reject(_.extend(e || {}, {
                    browserId: _this.id,
                    sessionId: _this.sessionId
                }));
            });
    },

    get browserName() {
        return this.capabilities.browserName;
    },

    get version() {
        return this.capabilities.version;
    },

    get capabilities() {
        return this.config.desiredCapabilities;
    },

    _shouldMaximize: function() {
        if (this.config.windowSize) {
            return false;
        }

        return this.browserName === 'phantomjs';
    },

    _maximize: function() {
        var _this = this;
        return _this._browser.windowHandle()
            .then(function(handle) {
                return _this._browser.maximize(handle);
            });
    },

    findElement: function(selector) {
        throw new Error('findElement is called before appropriate locator is chosen');
    },

    _findElementWd: function(selector) {
        return this._browser.elementByCssSelector(selector)
            .fail(function(error) {
                if (error.status === Browser.ELEMENT_NOT_FOUND) {
                    error.selector = selector;
                }
                return q.reject(error);
            });
    },

    _findElementScript: function(selector) {
        return this._clientBridge.call('query.first', [selector])
            .then(function(element) {
                if (element) {
                    return element;
                }

                var error = new Error('Unable to find element');
                error.status = Browser.ELEMENT_NOT_FOUND;
                error.selector = selector;
                return q.reject(error);
            });
    },

    prepareScreenshot: function(selectors, opts) {
        return this._clientBridge.call('prepareScreenshot', [selectors, opts || {}]);
    },

    captureFullscreenImage: function() {
        var _this = this;
        return this._tryScreenshotMethod('_takeScreenshot')
            .fail(function(originalError) {
                return _this._tryScreenshotMethod('_takeScreenshotWithNativeContext')
                    .fail(function() {
                        // if _takeScreenshotWithNativeContext fails too, the original error
                        // most likely was not related to the different Appium contexts and
                        // it is more useful to report it instead of second one
                        return q.reject(originalError);
                    });
            });
    },

    _tryScreenshotMethod: function(method) {
        var _this = this;
        return this[method]()
            .then(function(screenshot) {
                _this.captureFullscreenImage = _this[method];
                return screenshot;
            });
    },

    _takeScreenshot: function() {
        var _this = this;
        return this._browser.takeScreenshot()
            .then(function(base64) {
                var image = new Image(new Buffer(base64, 'base64'));
                if (_this._calibration) {
                    image = image.crop({
                        left: _this._calibration.left,
                        top: _this._calibration.top,
                        width: image.getSize().width - _this._calibration.left,
                        height: image.getSize().height - _this._calibration.top
                    });
                }

                return image;
            });
    },

    _takeScreenshotWithNativeContext: function() {
        var _this = this;
        return this._browser.currentContext()
            .then(function(oldContext) {
                return _this._browser.context('NATIVE_APP')
                    .then(_this._takeScreenshot.bind(_this))
                    .fin(function() {
                        return _this._browser.context(oldContext);
                    });
            });
    },

    get usePixelRatio() {
        return this._calibration && this._calibration.usePixelRatio;
    },

    quit: function() {
        if (!this.sessionId) {
            return q();
        }

        var _this = this;
        return this._browser
            .quit()
            .then(function() {
                _this.log('kill browser %o', _this);
            });
    },

    createActionSequence: function() {
        return new Actions(this);
    },

    inspect: function() {
        return util.format('[%s (%s)]', this.id, this.sessionId);
    }

}, {
    ELEMENT_NOT_FOUND: 7
});

module.exports = Browser;


text:
package net.smalinuxer.netty.front;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

import net.smalinuxer.lucene.utils.MMSegAnalyzer;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.index.Term;

@Deprecated
public class InputToken {

	public List<String> iteratorToken(String str , Analyzer analyzer) {
		TokenStream stream = null;
		List<String> list = new ArrayList<String>();
		try{
			stream = analyzer.tokenStream("Null", new StringReader(str));
			CharTermAttribute attr = stream.addAttribute(CharTermAttribute.class);
			//http://tharindu-rusira.blogspot.com/2013/12/apache-lucene-46-tokenstream-contract.html
			//stream.reset();
			while(stream.incrementToken()){
				System.out.print("[" + attr.toString() + "]  ");
				list.add(attr.toString());
			}
			//stream.end();
		}catch(IOException e){
			e.printStackTrace();
		} finally{
			try{
				if(stream != null){
					stream.close();
					stream = null;
				}
			} catch(IOException e){
			}
		}
		return list;
	}

	public List<String> iteratorToken(String str) {
		return iteratorToken(str,new MMSegAnalyzer());
	}

/*	public static void main(String[] args) {
		String str = "你好啊 今天天气不错啊 ";
		new InputToken().iteratorToken(str, new MMSegAnalyzer());
	}*/
}

redpajama_set_name: RedPajamaGithub


text:
package ch.softappeal.yass.core.remote.session;

/**
 * Is thrown if there is communication on a closed session.
 */
public final class SessionClosedException extends RuntimeException {

    private static final long serialVersionUID = 1L;

}


text:
package mk.ukim.finki.wp.service.db;

import mk.ukim.finki.wp.model.db.VehicleColor;
import mk.ukim.finki.wp.service.BaseEntityCrudService;

public interface VehicleColorService extends BaseEntityCrudService<VehicleColor> {

}


text:
<?php
use yii\helpers\Html;

?>

                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
                    Toggle navigation

                </button>

                       <?php echo Html::a('Menu of Week', ['dashboard/resturantmenu']);?>

                        Contact

Restaurant Logo

<?php echo date('D', strtotime('Monday')); ?>

<?php echo date('M j', strtotime('Monday')); ?>

<?php echo date('D', strtotime('Tuesday')); ?>

<?php echo date('M j', strtotime('Tuesday')); ?>

<?php echo date('D', strtotime('Wednesday')); ?>

<?php echo date('M j', strtotime('Wednesday')); ?>

<?php echo date('D', strtotime('Thursday')); ?>

<?php echo date('M j', strtotime('Thursday')); ?>

<?php echo date('D', strtotime('Friday')); ?>

<?php echo date('M j', strtotime('Friday')); ?>


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System.Collections.Generic;
using Azure.Core;

namespace Azure.Analytics.Synapse.Artifacts.Models
{
    /// <summary> Request body structure for data flow statistics. </summary>
    public partial class DataFlowDebugStatisticsRequest
    {
        /// <summary> Initializes a new instance of DataFlowDebugStatisticsRequest. </summary>
        public DataFlowDebugStatisticsRequest()
        {
            Columns = new ChangeTrackingList<string>();
        }
    }
}


text:
using System.Collections.Generic;
using CaboodleES.Interface;
using System;

namespace CaboodleES
{
    public class EventManager : CManager
    {
        private HashSet<global::System.Type> genTypes;

        public void AddHandler<E>(Action<E> handler) where E : IEvent
        {
            if (!genTypes.Contains(typeof(E)))
                genTypes.Add(typeof(E));

            EventsRepository<E>.AddHandler(caboodle.Id, handler);
        }

        public void AddEvent<E>(E @event) where E : IEvent
        {
            if (!genTypes.Contains(typeof(E)))
                genTypes.Add(typeof(E));

            EventsRepository<E>.AddEvent(caboodle.Id, @event);
        }

        internal void Invoke()
        {
            var nonGenType = typeof(EventsRepository<>);

            foreach (var qualType in genTypes)
            {
                var genType = nonGenType.MakeGenericType(qualType);
                var mthd = genType.GetMethod("Invoke");

                mthd.Invoke(null, new object[] { caboodle.Id });
            }
        }

        public EventManager(Caboodle caboodle) : base(caboodle)
        {
            this.genTypes = new HashSet<Type>();
        }
    }

    public static class EventsRepository<E> where E : IEvent
    {
        private static Dictionary<int, EventCollection<E>> eventDictionary =
            new Dictionary<int, EventCollection<E>>();

        public static void AddHandler(int set, Action<E> handler)
        {
            EventCollection<E> events;

            if (!eventDictionary.TryGetValue(set, out events))
                eventDictionary.Add(set, events = new EventCollection<E>());

            events.AddHandler(handler);
        }

        public static void AddEvent(int set, E @event)
        {
            EventCollection<E> events;

            if (!eventDictionary.TryGetValue(set, out events))
                eventDictionary.Add(set, events = new EventCollection<E>());

            events.AddEvent(@event);
        }

        public static void Invoke(int set)
        {
            EventCollection<E> events;

            if (!eventDictionary.TryGetValue(set, out events))
                eventDictionary.Add(set, events = new EventCollection<E>());

            events.Invoke();
        }
    }

    public class EventCollection<E> : IEventCollection
        where E : IEvent
    {
        private List<Action<E>> handlers;
        private List<E> events;

        public EventCollection()
        {
            this.handlers = new List<Action<E>>();
            this.events = new List<E>();
        }

        public void AddHandler(Action<E> handler)
        {
            this.handlers.Add(handler);
        }

        public void AddEvent(E @event)
        {
            events.Add(@event);
        }

        public void Invoke()
        {
            foreach(var @event in events)
                foreach(var handler in handlers)
                    handler(@event);

            events.Clear();
        }
    }
}


text:
Collection of deeplabv3 + mobilenet-edgetpu-v2 based semantic segmentation
models trained on ADE20K dataset and optimized for Pixel 6.

## Overview

We present segmentation models based on
[MobilenetEdgeTPUV2](https://tfhub.dev/google/collections/mobilenet-edgetpu-v2/1)
backbone and [DeepLab](https://arxiv.org/pdf/1802.02611) v3 plus decoder and
head. These models are optimized for the next generation Edge TPU accelerators
featured in Pixel 6 phones and improve the latency-accuracy pareto-frontier
compared to the their predecessor based on MobileNetV2 and DeepLabV3+.

The segmentation model is built using the pretrained MobilenetEdgeTPUV2 as a
feature encoder and ASPP decoder in conjunction with a Deeplab V3 Plus head.
Separable convolutions used to reduce the size of the model.

We further apply Argmax fusion to improve segmentation model latency. The last
two levels of the model (bilinear resizing and Argmax) contribute significantly
to latency on the device model. This is due to the large activation size between
these layers (512 x 512 x Number of classes). These layers can be merged without
significantly impacting quality scores by making Argmax smaller and scaling the
classes to the desired size with nearest neighbor.

### Source Code

The model implementation is available in
[TF Model Garden EdgeTPU repository](https://github.com/tensorflow/models/tree/master/official/projects/edgetpu/vision).

### Models

Models with default argmax.

Model                                                                             | mIOU on ADE20K-32classes (int8) | Pixel 6 Edge TPU Latency (ms)
--------------------------------------------------------------------------------- | :-----------------------------: | :---------------------------:
[XS](https://tfhub.dev/google/edgetpu/vision/deeplab-edgetpu/default_argmax/xs/1) | 56.02%                          | 5.2
[S](https://tfhub.dev/google/edgetpu/vision/deeplab-edgetpu/default_argmax/s/1)   | 59.43%                          | 5.9
[M](https://tfhub.dev/google/edgetpu/vision/deeplab-edgetpu/default_argmax/m/1)   | 59.81%                          | 7.2

Models with optimized fused argmax.

Model                                                                           | mIOU on ADE20K-32classes (int8) | Pixel 6 Edge TPU Latency (ms)
------------------------------------------------------------------------------- | :-----------------------------: | :---------------------------:
[XS](https://tfhub.dev/google/edgetpu/vision/deeplab-edgetpu/fused_argmax/xs/1) | 56%                             | 3.4
[S](https://tfhub.dev/google/edgetpu/vision/deeplab-edgetpu/fused_argmax/s/1)   | 59.41%                          | 4.2
[M](https://tfhub.dev/google/edgetpu/vision/deeplab-edgetpu/fused_argmax/m/1)   | 59.79%                          | 5.5


text:
AngelHack 2016 Manipal

This web-app was made as a part of AngelHack Manipal 2016.

The web-app, 'Optio' uses data obtained from croudsourcing about the various sectors of a city.
Based on the reviews the app creates various charts/graphs and draws comparison between the sectors based on different criterias, and provides an infographic representation of the data obtained so that its easy to access and analyse.

--Note for the person checking our submission
This was made by the following people

Ishan Handa
Raamish Malik
Utkarsh Kashyap
Vrushank Upadhyay


text:
package com.example.android.wifirttscan;

import android.Manifest;
import android.Manifest.permission;
import android.content.pm.PackageManager;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.appcompat.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

/**
 * This is a simple splash screen (activity) for giving more details on why the user should approve
 * fine location permissions. If they choose to move forward, the permission screen is brought up.
 * Either way (approve or disapprove), this will exit to the MainActivity after they are finished
 * with their final decision.
 */
public class LocationPermissionRequestActivity extends AppCompatActivity
        implements ActivityCompat.OnRequestPermissionsResultCallback {

    private static final String TAG = "LocationPermission";

    /* Id to identify Location permission request. */
    private static final int PERMISSION_REQUEST_FINE_LOCATION = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // If permissions granted, we start the main activity (shut this activity down).
        if (ActivityCompat.checkSelfPermission(this, permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
            finish();
        }

        setContentView(R.layout.activity_location_permission_request);
    }

    public void onClickApprovePermissionRequest(View view) {
        Log.d(TAG, "onClickApprovePermissionRequest()");

        // On 23+ (M+) devices, fine location permission not granted. Request permission.
        ActivityCompat.requestPermissions(
                this,
                new String[] {Manifest.permission.ACCESS_FINE_LOCATION},
                PERMISSION_REQUEST_FINE_LOCATION);
    }

    public void onClickDenyPermissionRequest(View view) {
        Log.d(TAG, "onClickDenyPermissionRequest()");
        finish();
    }

    /*
     * Callback received when a permissions request has been completed.
     */
    @Override
    public void onRequestPermissionsResult(
            int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {

        String permissionResult =
                "Request code: "
                        + requestCode
                        + ", Permissions: "
                        + permissions
                        + ", Results: "
                        + grantResults;
        Log.d(TAG, "onRequestPermissionsResult(): " + permissionResult);

        if (requestCode == PERMISSION_REQUEST_FINE_LOCATION) {
            // Close activity regardless of user's decision (decision picked up in main activity).
            finish();
        }
    }
}


text:
package com.craftmend.openaudiomc.velocity.utils;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

public enum VelocityChatColor {
    BLACK('0', "black"),
    DARK_BLUE('1', "dark_blue"),
    DARK_GREEN('2', "dark_green"),
    DARK_AQUA('3', "dark_aqua"),
    DARK_RED('4', "dark_red"),
    DARK_PURPLE('5', "dark_purple"),
    GOLD('6', "gold"),
    GRAY('7', "gray"),
    DARK_GRAY('8', "dark_gray"),
    BLUE('9', "blue"),
    GREEN('a', "green"),
    AQUA('b', "aqua"),
    RED('c', "red"),
    LIGHT_PURPLE('d', "light_purple"),
    YELLOW('e', "yellow"),
    WHITE('f', "white"),
    MAGIC('k', "obfuscated"),
    BOLD('l', "bold"),
    STRIKETHROUGH('m', "strikethrough"),
    UNDERLINE('n', "underline"),
    ITALIC('o', "italic"),
    RESET('r', "reset");

    public static final char COLOR_CHAR = '§';
    public static final String ALL_CODES = "0123456789AaBbCcDdEeFfKkLlMmNnOoRr";
    public static final Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)" + String.valueOf('§') + "[0-9A-FK-OR]");
    private static final Map<Character, VelocityChatColor> BY_CHAR = new HashMap();

    static {
        VelocityChatColor[] var0 = values();
        int var1 = var0.length;

        for (int var2 = 0; var2 < var1; ++var2) {
            VelocityChatColor colour = var0[var2];
            BY_CHAR.put(colour.code, colour);
        }

    }

    private final char code;
    private final String toString;
    private final String name;

    private VelocityChatColor(char code, String name) {
        this.code = code;
        this.name = name;
        this.toString = new String(new char[]{'§', code});
    }

    public static String stripColor(String input) {
        return input == null ? null : STRIP_COLOR_PATTERN.matcher(input).replaceAll("");
    }

    public static String translateAlternateColorCodes(char altColorChar, String textToTranslate) {
        char[] b = textToTranslate.toCharArray();

        for (int i = 0; i < b.length - 1; ++i) {
            if (b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i + 1]) > -1) {
                b[i] = 167;
                b[i + 1] = Character.toLowerCase(b[i + 1]);
            }
        }

        return new String(b);
    }

    public static VelocityChatColor getByChar(char code) {
        return BY_CHAR.get(code);
    }

    public String toString() {
        return this.toString;
    }

    public String getName() {
        return this.name;
    }
}


text:
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;

namespace osu.Game.Overlays.Options.Sections.Input
{
    public class OtherInputOptions : OptionsSubsection
    {
        protected override string Header => "Other";

        [BackgroundDependencyLoader]
        private void load(OsuConfigManager config)
        {
            Children = new Drawable[]
            {
                new OsuCheckbox
                {
                    LabelText = "OS TabletPC support",
                    Bindable = config.GetBindable<bool>(OsuConfig.Tablet)
                },
                new OsuCheckbox
                {
                    LabelText = "Wiimote/TaTaCon Drum Support",
                    Bindable = config.GetBindable<bool>(OsuConfig.Wiimote)
                },
            };
        }
    }
}


text:
<!doctype html>

		<meta charset="utf-8" />
		<title>jQuery UI Accordion - Default functionality</title>
		<link rel="stylesheet" href="http://code.jquery.com/ui/1.9.1/themes/base/jquery-ui.css" />

		<link rel="stylesheet" href="/resources/demos/style.css" />

One

Two

Three

First tab is active by default:

$( "#tabs" ).tabs();

				Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.
				Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.

				Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.
				Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.
				Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.


text:
<!DOCTYPE html>
<html>
<head>
  <link type="text/css" rel="stylesheet" href="../bower_components/video.js/dist/video-js/video-js.css" />
  <script src="../bower_components/video.js/dist/video-js/video.js"></script>
  <script src="../src/youtube.js"></script>
</head>
<body>
  <video id="vid1" src="" class="video-js vjs-default-skin" controls preload="auto" width="640" height="360" data-setup='{ "techOrder": ["youtube"], "quality": "720p", "src": "http://www.youtube.com/watch?v=xjS6SftYQaQ" }'>
  </video>
</body>
</html>


text:
#if VOUCHERIFYSERVER || VOUCHERIFYCLIENT
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using Voucherify.Core.Extensions;

namespace Voucherify.DataModel
{
    [JsonObject]
    public class OrderRedemption
    {
        [JsonProperty(PropertyName = "date")]
        public DateTime? Date { get; private set; }

        [JsonProperty("related_object_id")]
        public string RelatedObjectId { get; private set; }

        [JsonProperty("related_object_type")]
        public string RelatedObjectType { get; private set; }

        [JsonProperty("stacked")]
        public List<string> Stacked { get; private set; }

        public OrderRedemption()
        {
            this.Stacked = new List<string>();
        }

        public override string ToString()
        {
            return string.Format("OrderRedemption(Date={0},RelatedObjectId={1},RelatedObjectType={2},Stacked={3})", this.Date, this.RelatedObjectId, this.RelatedObjectType, ListExtensions.ToString(this.Stacked));
        }
    }
}
#endif


text:
function run() {
  return "This is a test test.";
}


text:
<resources>
    <string name="app_name">E_CommercePizza</string>
    <string name="navigation_drawer_open">Open navigation drawer</string>
    <string name="navigation_drawer_close">Close navigation drawer</string>

    <string name="action_settings">Settings</string>
</resources>


text:
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android" >
    <item android:drawable="@drawable/bdp_btn_pay_order_list_gray2" android:state_pressed="true"/>
	<item android:drawable="@drawable/bdp_btn_pay_order_list_gray1" />
</selector>


text:
<!DOCTYPE html>

  <title>SpiceHours Admin UI</title>

  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />

  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous">
  <link href="./app.css" rel='stylesheet' type='text/css'>

Loading JavaScript...


text:
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:id="@+id/activity_main_container"
    android:layout_height="match_parent"
    >

</FrameLayout>


text:
/**
 * Instantiates a new builder for the 'tweenFrom' animation type.
 *
 * @class BuilderTweenFrom
 * @constructor
 * @extends Builder
 */
function BuilderTweenFrom()
{

}

Class.extend( BuilderTweenFrom, Builder,
{
  parse: function( animation, options, attrimatorMap, helper )
  {
    // 1. Starting values are all true which signals to Animator to replace those points with the animator's current values.

    var factory    = $factory( animation.factory, helper.forObject );
    var tweenFrom  = animation.tweenFrom;

    for (var attr in tweenFrom)
    {
      var attribute  = factory.attribute( attr );
      var value      = attribute.parse( tweenFrom[ attr ] );
      var path       = new Tween( attr, attribute.calculator, value, computed.current );
      var event      = helper.parseEvent( attr, path, this, true );

      attrimatorMap.put( attr, event );
    }
  }
});


text:
module LocaleSetter
  module Generic

    def self.set_locale(i18n, options = {:params => nil,
                                         :user   => nil,
                                         :domain => nil,
                                         :env    => nil})

      i18n.locale = from_params(options[:params], available(i18n)) ||
                    from_user(options[:user], available(i18n))     ||
                    from_domain(options[:domain], available(i18n)) ||
                    from_http(options[:env], available(i18n))      ||
                    i18n.default_locale
    end

    def self.available(i18n)
      i18n.available_locales.map(&:to_s)
    end

    def self.from_user(user, available)
      LocaleSetter::User.for(user, available)
    end

    def self.from_http(env, available)
      if env && env[HTTP_HEADER]
        LocaleSetter::HTTP.for(env[HTTP_HEADER], available)
      end
    end

    def self.from_domain(domain, available)
      LocaleSetter::Domain.for(domain, available)
    end

    def self.from_params(params, available)
      if params && params[LocaleSetter.config.url_param]
        LocaleSetter::Param.for(params[LocaleSetter.config.url_param], available)
      end
    end
  end
end


text:
See separate Final Project repository:
[Final Project](https://github.com/donald-pinckney/Final-Project)


text:
/**visor
* Angular authentication and authorization library
* @version v0.1.1
* @link  https://github.com/illniyar/visor.git
* @license MIT License, http://www.opensource.org/licenses/MIT
*/
if (typeof module !== 'undefined' && typeof exports !== 'undefined' && module.exports === exports){
 module.exports = 'visor';
}

(function (window, angular, undefined) {
(function () {
    "use strict";

    /**
     * @ngdoc overview
     * @name delayLocationChange
     * @description
     *
     * # delayLocationChange
     *
     * `delayLocationChange` module contains the {@link delayLocationChange.delayLocationChange `delayLocationChange`} service.
     *
     */
    angular.module("delayLocationChange", [])

        .service("delayLocationChange", ["$rootScope", "$q", "$timeout", "$location", "$injector",
            function ($rootScope, $q, $timeout, $location, $injector) {

                /**
                 * @ngdoc service
                 * @name delayLocationChange.delayLocationChange
                 * @description
                 *
                 * # delayLocationChange
                 *
                 * `delayLocationChange` allows multiple services to stop the first location change (I.E. the rendering of the first page) until a promise is complete.
                 *
                 *
                 * @param {promise|function()} waitFor - if a promise, will delay until promise is resolved
                 * , if a function, will delay until the result of running the function, which must return a promise, will be resolved.
                 *
                 * @example
                 *
                 *

                 *   angular.module("myModule",["delayLocationChange"])
                 *   .run(function(delayLocationChange){
      *     delayLocationChange(function($http){
      *       return $http.get("/something/that/is/needed")
      *       .then(function(result){
      *         //do something with result that you need before rendering the first time
      *       })
      *     });
      *   };
                 *

                 */
                var service = function (arg) {
                    if (arg.then) {
                        //handles a promise
                        addPromise(arg);
                    } else {
                        //assume it's a function
                        if (changeStarted) {
                            addPromise($injector.invoke(fn));
                        } else {
                            //need to wait until angular started the locationChange, otherwise
                            //something might start running before it's should
                            waitingFunctions.push(arg);
                        }
                    }
                };

                // we make sure that all promises finish by counting the number of promises
                //we recieved
                var unfinishedPromises = 0;
                var waitingFunctions = [];
                var changeStarted = false, _toUrl, _fromUrl, nextUrl;

                //checkPromises both determines if all promises were resolved and initiates
                //the delayed location change if no more promises remain
                function checkPromises() {
                    unfinishedPromises--;
                    if (changeStarted && unfinishedPromises <= 0) {
                        reloadChange();
                    }
                }

                function reloadChange() {
                    if ($location.absUrl() === _toUrl) {
                        //we are running on the assumption (that might prove false at some point)
                        //that nothing happens between canceling $locationChangeStart and emitting
                        //$locationChangeSuccess
                        $rootScope.$broadcast("$locationChangeSuccess", _toUrl, _fromUrl);
                    } else {
                        $location.url(nextUrl);
                    }
                }

                function addPromise(promise) {
                    unfinishedPromises++;
                    //to access using array notation because finally is a reserved word
                    promise['finally'](checkPromises);
                }

                var unlisten = $rootScope.$on("$locationChangeStart", function (e, toUrl, fromUrl) {
                    changeStarted = true;
                    nextUrl = $location.url();
                    unlisten();
                    //We are relying on the fact that since the url never actually changed,
                    //the fact that angular will return to the previous ulr when doing preventDefault, will not
                    // have any effect
                    e.preventDefault();
                    waitingFunctions.forEach(function (fn) {
                        addPromise($injector.invoke(fn))
                    });

                    if (unfinishedPromises === 0 && !_toUrl) { //firstCall and no promises
                        //we need to let at least one run through to verify
                        //no promises will be added
                        unfinishedPromises++;
                        $timeout(checkPromises, 1);
                    }
                    _toUrl = toUrl;
                    _fromUrl = fromUrl;
                });

                return service;
            }]);
})();
(function () {
    "use strict";

    /**
     * @ngdoc overview
     * @name visor.allowed
     * @description
     *
     * # Visor.Allowed
     *
     * `Visor.Allowed` contains directives that change elements based on weather a route is allowed or not.
     *
     */
    angular.module("visor.allowed", ["visor.permissions"])
    /**
     * @ngdoc directive
     * @name visor.allowed.showIfAllowed
     *
     * @description
     *
     * the `showIfAllowed` directive shows or hides the given HTML element based on whether the expression
     * provided to `showIfAllowed` resolve to a route (url or state name) that can be accessed.
     * `showIfAllowed` directive acts similar to `ngHide` directive - it adds an 'ng-hide' class to the element.
     *
     * @animations
     * addClass: `.ng-hide` - happens when the `showIfAllowed` evaluates to a route that is restricted or when the
     *  route becomes restricted
     * removeClass: `.ng-hide` - happens when the `showIfAllowed` evaluates to a route that is not restricted or
     *  when the route is no longer restricted
     *
     * @element ANY
     * @param {expression} showIfAllowed If the {@link guide/expression expression} resolves to a route that
     * is currently available then the element is shown.
     */
        .directive("showIfAllowed", ["visorPermissions", "$animate", function (visorPermissions, $animate) {
            return {
                restrict: 'A',
                link: function (scope, element, attr) {
                    var unListen = visorPermissions.notifyOnCacheClear(function () {
                        syncElement(attr.showIfAllowed);
                    })

                    function syncElement(value) {
                        // Copied from ngHideDirective (v1.3.13)
                        var allowed = visorPermissions.checkPermissionsForRoute(value);
                        $animate[allowed ? 'removeClass' : 'addClass'](element, "ng-hide", {
                            tempClasses: "ng-hide-animate"
                        });
                    }

                    attr.$observe('showIfAllowed', syncElement);
                    scope.$on('$destroy', unListen);
                }
            };
        }])
    /**
     * @ngdoc directive
     * @name visor.allowed.classIfRestricted
     *
     * @description
     *
     * the `classIfRestricted` directive adds a class to the given HTML element based on whether the expression
     * provided to `classIfRestricted` resolve to a route (url or state name) that is restricted.
     *
     * @animations
     * addClass: `.visor-restricted` - happens when the `classIfRestricted` evaluates to a route that is restricted or when the
     *  route becomes restricted
     * removeClass: `.visor-restricted` - happens when the `classIfRestricted` evaluates to a route that is not restricted or
     *  when the route is no longer restricted
     *
     * @element ANY
     * @param {expression} showIfAllowed If the {@link guide/expression expression} resolves to a route that
     * is currently available then the element is shown.
     *
     * @param {string} restrictedClass the class to add to the element. Defaults to 'visor-restricted'
     */
        .directive("classIfRestricted", ["visorPermissions", "$animate", function (visorPermissions, $animate) {
            return {
                restrict: 'A',
                link: function (scope, element, attr) {
                    //internal mechanism - cache clear is the only way in which a permission value can change
                    var unListen = visorPermissions.notifyOnCacheClear(function () {
                        syncElement(attr.classIfRestricted);
                    })

                    function syncElement(value) {
                        var allowed = visorPermissions.checkPermissionsForRoute(value);
                        $animate[!allowed ? 'addClass' : 'removeClass'](element, attr.restrictedClass || 'visor-restricted');
                    };
                    attr.$observe('classIfRestricted', syncElement);
                    scope.$on('$destroy', unListen);
                }
            };
        }])
})();
(function () {
    "use strict";

    /**
     * @ngdoc overview
     * @name visor
     * @description
     *
     * # Visor
     *
     * `Visor` is an authentication and authorization module.
     *
     *

     *
     * See {@link visor.visor `visor`} for usage.
     */
    angular.module("visor", ["visor.permissions", "visor.ui-router", "visor.ngRoute", "delayLocationChange", "visor.allowed"])

    /**
     * @ngdoc service
     * @name visor.authenticatedOnly
     * @description
     *
     * # authenticatedOnly
     *
     * `authenticatedOnly` is a restrict function that only allows authenticated users access to a route.
     *
     * @example
     *
     *

     *   angular.moudle("myModule",["visor"])
     *   .config(function($stateProvider,authenticatedOnly){
   *     $stateProvider.state("private",{
   *       restrict: authenticatedOnly
   *     })
   *   }
     *

     */
        .constant("authenticatedOnly", function (authData) {
            return !!authData;
        })

    /**
     * @ngdoc service
     * @name visor.notForAuthenticated
     * @description
     *
     * # notForAuthenticated
     *
     * `notForAuthenticated` is a restrict function that does not allow authenticated users access to a route.
     *
     * @example
     *
     *

     *   angular.moudle("myModule",["visor"])
     *   .config(function($stateProvider,notForAuthenticated){
   *     $stateProvider.state("private",{
   *       restrict: notForAuthenticated
   *     })
   *   }
     *

     */
        .constant("notForAuthenticated", function (authData) {
            return authData === undefined;
        })

    /**
     * @ngdoc service
     * @name visor.visorProvider
     * @description
     *
     * @requires visor.visorPermissions
     * @requires visor.delayLocationChange
     *
     * @description
     *
     * `visorProvider` provides configuration options to define how authentication and authorization works.
     *
     * The only required configuration is {@link visor.visorProvider#authenticate `visorProvider.authenticate`}.
     *
     * @example
     *
     *

     *   angular.moudle("myModule",["visor"])
     *   .config(function(visorProvider){
   *     visorProvider.authenticate = function($http){
   *      return $http.get("/api/user/me").then(function(res){
   *        return res.data;
   *      })
   *     };
   *   }
     *

     */
        .provider("visor", [function () {
            function addNextToUrl(url, $location, restrictedUrl) {
                if (config.shouldAddNext) {
                    if (url.indexOf("?") >= 0) {
                        return url.replace(/\?/, "?next=" + encodeURIComponent(restrictedUrl) + "&");
                    }
                    return url + "?next=" + encodeURIComponent(restrictedUrl);
                } else {
                    return url;
                }
            }

            var config = this;
            /**
             * @ngdoc property
             * @name visor.visorProvider#authenticateOnStartup
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * If `true` visor will try to authenticate before any route is accessed (it will stop the routing until the authentication promise is resolved).
             * If `false` will only authenticate when a user tries to access a route with restriction.
             *
             * Defaults to `true`
             */
            config.authenticateOnStartup = true;
            /**
             * @ngdoc property
             * @name visor.visorProvider#loginRoute
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * The route to go to after an unauthenticated user tries to access a restricted url.
             * Only meaningful when using the default {@link visor.visorProvider#doOnNotAuthenticated `visorProvider.doOnNotAuthenticated`} function.
             *
             * Defaults to `/login`
             */
            config.loginRoute = "/login";
            /**
             * @ngdoc property
             * @name visor.visorProvider#homeRoute
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * The route to go to after manual authentication.
             * Only meaningful when using the default {@link visor.visorProvider#doAfterManualAuthentication `visorProvider.doAfterManualAuthentication`} function.
             *
             * Defaults to `/`
             */
            config.homeRoute = "/";
            /**
             * @ngdoc property
             * @name visor.visorProvider#notAuthorizedRoute
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * The route to go to after an authenticated user tries to access a restricted url.
             * Only meaningful when using the default {@link visor.visorProvider#doOnNotAuthorized `visorProvider.doOnNotAuthorized`} function.
             *
             * Defaults to `/access_denied`
             */
            config.notAuthorizedRoute = "/access_denied";
            /**
             * @ngdoc property
             * @name visor.visorProvider#shouldAddNext
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * When using the default {@link visor.visorProvider#doOnNotAuthenticated `visorProvider.doOnNotAuthenticated`} function, visor adds a `next` parameter to the login url provided in {@link visor.visorProvider#loginRoute `loginRoute`}.
             * Once  a user manually authenticates, that route is used to redirect back to the original requested url.
             *
             * If `false` will not add the next url in {@link visor.visorProvider#doOnNotAuthenticated `visorProvider.doOnNotAuthenticated`}.
             *
             * Defaults to `true`
             */
            config.shouldAddNext = true;

            /**
             * @ngdoc function
             * @name visor.visorProvider#authenticate
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * This function needs to be configured in order to use visor.
             *
             * `visorProvider.authentication` defines the authentication function that will be called to provide
             * the authentication info at startup.
             * It must return a promise that will resolve to an object if the user is authenticated or rejected if
             * the user isn't authenticated.
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor"])
             *   .config(function(visorProvider,$stateProvider){
       *     visorProvider.authenticate = function($http){
       *      return $http.get("/api/user/me").then(function(res){
       *        return res.data;
       *      });
       *     };
       *   });
             *

             */
            config.authenticate = function () {
                throw new Error("visorProvider.authenticate must be defined to use visor");
            };
            /**
             * @ngdoc function
             * @name visor.visorProvider#doOnNotAuthenticated
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * The action to take when a user tries to access a restricted route but is not authenticated.
             * By default it redirect to {@link visor.visorProvider#loginRoute `loginRoute`}.
             * If {@link visor.visorProvider#shouldAddNext `shouldAddNext`} is enabled, a `next` parameter with the restricted url is added to the login url.
             *
             * The url that was restricted is provided by an injected argument named `restrictedUrl`
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor"])
             *   .config(function(visorProvider,$stateProvider){
       *    //redirect to an error page instead of login
       *     visorProvider.doOnNotAuthenticated = function(restrictedUrl,$state){
       *      $state.go("error",{
       *        message: "you need to be logged in to access " + restrictedUrl
       *      })
       *     };
       *   });
             *

             */
            config.doOnNotAuthenticated = ["$location", "restrictedUrl", function ($location, restrictedUrl) {
                $location.url(addNextToUrl(config.loginRoute, $location, restrictedUrl))
            }];
            /**
             * @ngdoc function
             * @name visor.visorProvider#doAfterManualAuthentication
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * The action to take after a user is authenticated using {@link visor.visor#setAuthenticated `visor.setAuthenticated`}.
             * By default it redirect to next parameter if exists or to {@link visor.visorProvider#homeRoute `homeRoute`}.
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor"])
             *   .config(function(visorProvider,$stateProvider){
       *     //redirect to a new user welcome page
       *     visorProvider.doAfterManualAuthentication = function($state){
       *      $state.go("new_user.welcome")
       *     };
       *   });
             *

             */
            config.doAfterManualAuthentication = ["$location", function ($location) {
                $location.url($location.search().next || config.homeRoute);
            }];
            /**
             * @ngdoc function
             * @name visor.visorProvider#doOnNotAuthorized
             * @propertyOf visor.visorProvider
             *
             * @description
             *
             * The action taken when an already authenticated user tries to access a route he is not allowed to view.
             * By default it redirect to {@link visor.visorProvider#notAuthorizedRoute `notAuthorizedRoute`}.
             *
             * The url that was restricted is provided by an injected argument named `restrictedUrl`
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor"])
             *   .config(function(visorProvider,$stateProvider){
       *    //redirect to an error page with the restricted url message
       *     visorProvider.doOnNotAuthorized = function(restrictedUrl,$state){
       *      $state.go("error",{
       *        message: "you are not allowed to access " + restrictedUrl
       *      })
       *     };
       *   });
             *

             */
            config.doOnNotAuthorized = ["$location", function ($location) {
                $location.url(config.notAuthorizedRoute)
            }];

            /**
             * @ngdoc service
             * @name visor.visor
             * @description
             *
             * @requires visor.visorPermissions
             * @requires visor.delayLocationChange
             *
             * @description
             *
             * `visor` is an authentication and authorization service to be used alongside ngRoute or ui-router.
             *
             * It handles authentication while {@link visor.permissions.visorPermissions `visorPermissions`} handles routing and
             * restrciting access.
             *
             * To use first define how visor is to authenticate by setting `visor.authenticate`, and then add
             * restriction functions to routes/states.
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor"])
             *   .config(function(visorProvider,$stateProvider){
       *     visorProvider.authenticate = function($http){
       *      return $http.get("/api/user/me").then(function(res){
       *        return res.data;
       *      })
       *     };
       *     $stateProvider.state("private",{
       *       restrict: function(user){ return user && user.can_see_private;}
       *     })
       *   }
             *

             */

            this.$get = ["$injector", "$q", "$rootScope", "$location", "visorPermissions", function ($injector, $q, $rootScope, $location, visorPermissions) {
                // keeps the original auth promise so we won't call authenticate twice.
                var _authenticationPromise = false;

                function onAuthenticationSuccess(authData) {
                    Visor.authData = authData;
                    visorPermissions.invokeParameters = [Visor.authData];
                    visorPermissions.clearPermissionCache();
                }

                function onAuthenticationFailed() {
                    Visor.authData = undefined;
                    visorPermissions.invokeParameters = [];
                    visorPermissions.clearPermissionCache();
                }

                var Visor = {
                    /**
                     *
                     * Authenticate with visor.
                     *
                     * **Note**: This function was intended for internal use.
                     *
                     *
                     * @param {boolean} retry If true, will force reauthentication. Otherwise, the second call to authenticate will
                     *    return the result of the previous authentication call.
                     *
                     * @returns {promise} Promise that will always resolve as true, with the value returned from {@link visor.visorProvider#authenticate `visorProvider.authenticate`}.
                     *    If {@link visor.visorProvider#authenticate `visorProvider.authenticate`} failed, the promise will resolve with `undefined`.
                     */
                    authenticate: function (retry) {
                        if (_authenticationPromise && !retry) {
                            return _authenticationPromise;
                        }
                        var deferred = $q.defer();
                        _authenticationPromise = deferred.promise;
                        $injector.invoke(config.authenticate)
                            .then(onAuthenticationSuccess, onAuthenticationFailed)
                            ['finally'](function () {
                            deferred.resolve(Visor.authData)
                        });
                        return deferred.promise;
                    },
                    /**
                     * @ngdoc function
                     * @name visor.visor#setAuthenticated
                     * @methodOf visor.visor
                     *
                     * @description
                     *
                     *
                     * Notify `visor` that an authentication was successful.
                     *
                     * Typical use is to call this function after a use logs in to the system.
                     *
                     *

                     * **Note**: `authData` should be the identical to the result of the promise returned from {@link visor.visorProvider#authenticate `visorProvider.authenticate`}.
                     *

                     *
                     *
                     * @param {Any} authData The authentication data to be used in future restrict functions.
                     */
                    setAuthenticated: function (authData) {
                        onAuthenticationSuccess(authData);
                        _authenticationPromise = $q.when(authData);
                        $injector.invoke(config.doAfterManualAuthentication, null, {authData: authData});
                    },
                    /**
                     * @ngdoc function
                     * @name visor.visor#isAuthenticated
                     * @methodOf visor.visor
                     *
                     * @description
                     *
                     * Determine if user was successfuly authenticated.
                     *
                     *
                     * @returns {boolean} True if the user was authenticated. False otherwise.
                     */
                    isAuthenticated: function () {
                        return !!Visor.authData;
                    },
                    /**
                     *
                     * Notify visor that a use tried to access a url that is restricted to it.
                     *
                     * **Note**: This function was intended for internal use.
                     *
                     *
                     * @param {string} restrictedUrl The url that the user was restricted access to.
                     *
                     */
                    onNotAllowed: function (restrictedUrl) {
                        if (Visor.isAuthenticated()) {
                            $injector.invoke(config.doOnNotAuthorized, null, {restrictedUrl: restrictedUrl});
                        } else {
                            $injector.invoke(config.doOnNotAuthenticated, null, {restrictedUrl: restrictedUrl});
                        }
                    },
                    /**
                     * @ngdoc function
                     * @name visor.visor#setUnauthenticated
                     * @methodOf visor.visor
                     *
                     * @description
                     *
                     *
                     * Notify `visor` that a user is no longer authenticated.
                     *
                     * Typical use is to call this function after a user logs out of the system.
                     */
                    setUnauthenticated: function () {
                        onAuthenticationFailed()
                    },
                    config: config
                };
                return Visor;
            }]
        }])
        .run(["visor", "delayLocationChange", function (visor, delayLocationChange) {
            if (visor.config.authenticateOnStartup) {
                delayLocationChange(visor.authenticate())
            }
        }])
        .config(["visorPermissionsProvider", function (visorPermissionsProvider) {
            visorPermissionsProvider.doBeforeFirstCheck.push(["visor", function (Visor) {
                return Visor.authenticate();
            }]);
            visorPermissionsProvider.onNotAllowed = ["visor", "restrictedUrl", function (Visor, restrictedUrl) {
                Visor.onNotAllowed(restrictedUrl);
            }]
        }])
})();
(function () {

    /**
     * @ngdoc overview
     * @name visor.ngRoute
     * @description
     *
     * # Visor.ngRoute
     *
     * `Visor.ngRoute` automatically add supports for permissions in ngRoute, if ngRoute exists.
     *
     */
    angular.module('visor.ngRoute', ['visor.permissions'])
        .run(['$rootScope', 'visorPermissions', '$injector', function ($rootScope, visorPermissions, $injector) {
            var ngRouteModuleExists = false;
            var $route = null;
            try {
                $route = $injector.get("$route");
                ngRouteModuleExists = true;
            } catch (e) {
            }
            if (ngRouteModuleExists) {
                visorPermissions.getRoute = function (routeId) {
                    for (var path in $route.routes) {
                        var route = $route.routes[path];
                        if (route.regexp.exec(routeId)) {
                            return route;
                        }
                    }
                    return null;
                };
                $rootScope.$on('$routeChangeStart', function (e, next) {
                    next.resolve = next.resolve || {};
                    visorPermissions.onRouteChange(next, function delayChange(promise) {
                        next.resolve._visorDelay = function () {
                            return promise;
                        };
                    });
                });
            }
        }])
})();
(function () {
    /**
     * @ngdoc overview
     * @name visor.permissions
     * @description
     *
     * # Visor.Permissions
     *
     * `Visor.Permissions` provides support for handling permissions and restricting access to routes based
     * on those restrictions.
     *
     *
     * See {@link visor.permissions.visorPermissions `visorPermissions service`} for usage.
     */

    angular.module("visor.permissions", [])

    /**
     * @ngdoc service
     * @name visor.permissions.visorPermissionsProvider
     *
     * @description
     *
     * `visorPermissionsProvider` provides a pluggable configuration to adjust how `visor.permissions`
     *  will handle route changes.
     *
     * Some of the api in the configuration is for use in plugins to allow support for multiple routing modules.\
     * Others are for use with clients ( such as {@link visor.visor `visor`} ).
     *
     * For examples of using the various plugin methods see the {@link visor.ngRoute visor.ngRoute}
     * and {@link visor.ui-router visor.ui-router} source codes.
     *
     */
        .provider("visorPermissions", [function () {
            var config = this;
            /**
             * @ngdoc property
             * @name visor.permissions.visorPermissionsProvider#getPermissionsFromNext
             * @propertyOf visor.permissions.visorPermissionsProvider
             *
             * @description
             *
             *

             *  NOTE: should only be changed by routing module plugins
             *

             *
             * A function that determines how permissions should be resolved from a route object.
             * It receives the `next` route object as the only parameter and must return a `permission function`,
             * or an Array of `permission functions`.
             *
             * A route object is an object that is sent to
             * {@link visor.permissions.visorPermissions#onRouteChange onRouteChange }.
             * This configuration should be set by the same plugin that calls
             * {@link visor.permissions.visorPermissions#onRouteChange onRouteChange } to guarantee compatibility.
             *
             * A `permission function` is a function that receives {@link visor.permissions.VisorPermissions.invokeParameters}
             * and returns a boolean indicating whether a route change should occur (I.E. the user has permission to access
             * the route)
             *
             * Default: a function that returns the permission function that is in the `next` route object's `restrict`
             * attribute (if any).
             *
             * Can also be changed at runtime by changing {@link visor.permissions.visorPermissions#getPermissionsFromNext}
             * @example
             *
             *

             *   // a plugin module that will allow all paths to go through
             *   angular.moudle("myModule",["visor.permissions"])
             *   .config(function(visorPermissionsProvider){
         *      visorPermissionsProvider.getPermissionsFromNext = function(next){
         *        return function(){
         *          return true;
         *        }
         *      }
         *   });
             *

             */
            config.getPermissionsFromNext = function (next) {
                return next.restrict ? [next.restrict] : [];
            };

            /**
             * @ngdoc property
             * @name visor.permissions.visorPermissionsProvider#doBeforeFirstCheck
             * @propertyOf visor.permissions.visorPermissionsProvider
             *
             * @description
             *
             *
             * A list of functions to run before the first permission check is performed (I.E. the first time a route that
             * requires permissions is navigated to).
             * These functions must return a promise.
             *
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor.permissions"])
             *   .config(function(visorPermissionsProvider){
         *      visorPermissionsProvider.doBeforeFirstCheck.push(["$http",function($http){
         *        return $http.get("/do/something");
         *      }]);
         *   });
             *

             */
            config.doBeforeFirstCheck = [];
            /**
             * @ngdoc property
             * @name visor.permissions.visorPermissionsProvider#onNotAllowed
             * @propertyOf visor.permissions.visorPermissionsProvider
             *
             * @description
             *
             *

             *  NOTE: should only be changed by routing module plugins
             *

             *
             * function to call when a permission failed to validate.
             *
             * The function is injected, with local `restrictedUrl` containing the url navigated to.
             *
             */
            config.onNotAllowed = function () {
            };

            /**
             * @ngdoc property
             * @name visor.permissions.visorPermissionsProvider#invokeParameters
             * @propertyOf visor.permissions.visorPermissionsProvider
             *
             * @description
             *
             * a list of values to send to each `permission function` to be used to determine if a route is allowed.
             *
             * Can also be changed at runtime by changing {@link visor.permissions.visorPermissions#invokeParameters}
             *
             * @example
             *
             *

             *   angular.moudle("myModule",["visor.permissions"])
             *   .config(function(visorPermissionsProvider){
         *      var userInfo = {username:"theUser",isAdmin:false};
         *      visorPermissionsProvider.invokeParameters.push(userInfo);
         *   });
             *

             */
            config.invokeParameters = [];
            /**
             * @ngdoc property
             * @name visor.permissions.visorPermissionsProvider#getRoute
             * @propertyOf visor.permissions.visorPermissionsProvider
             *
             * @description
             *
             *

             *  NOTE: should only be changed by routing module plugins
             *

             *
             * function that transforms a routeId to a route object that can be used in getPermissionsFromNext
             *
             */
            config.getRoute = function (routeId) {
                throw new Error("method not implemented");
            }
            var finishedBeforeCheck = false;

            /**
             * @ngdoc service
             * @name visor.permissions.visorPermissions
             *
             * @description
             *
             * `visorPermissions` checks for permissions and notifies when a routes that isn't allowed is requested.
             *
             * In order to work, routing module plugins (such as the provided {@link visor.ngRoute visor.ngRoute} and
             * {@link visor.ui-router visor.ui-router} must configure `visorPermissions` and call
             * {@link visor.permissions.visorPermissions#onRouteChange onRouteChange} when a route has changed.
             *
             */
            this.$get = ["$q", "$injector", "$location", function ($q, $injector, $location) {

                function checkPermissions(permissions) {
                    if (!permissions || permissions.length === 0) {
                        return true;
                    }
                    if (!angular.isArray(permissions)) {
                        permissions = [permissions];
                    }
                    var isAllowed = true;
                    permissions.forEach(function (permission) {
                        isAllowed = isAllowed && permission.apply(null, VisorPermissions.invokeParameters);
                    });
                    return isAllowed;
                }

                function handlePermission(next, permissions) {
                    var isAllowed = checkPermissions(permissions);
                    if (isAllowed) {
                        return true;
                    } else {
                        VisorPermissions.invokeNotAllowed(config.onNotAllowed);
                        return false;
                    }
                }

                var onCacheClearListeners = [];

                var cachedRoutes = {};
                var VisorPermissions = {

                    /**
                     * @ngdoc function
                     * @name visor.permissions.visorPermissions#onRouteChange
                     * @methodOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     *

                     *  NOTE: should only be called by routing module plugins
                     *

                     *
                     * A function to be called when a route changes, triggers the route permission checks.
                     *
                     * @param {*} next route object to be sent to `permission functions`.
                     *
                     * @param {function} delayChange a function to be called if visorPermissions requires that the route
                     *  change be delayed. in such case the delayChange function will be called with a promise that will be
                     *  resolved or rejected depending on whether the route is allowed.
                     *
                     * @returns {Any} true if next is allowed, false if not allowed. a string containing "delayed" if
                     *  the check is delayed.
                     */
                    onRouteChange: function (next, delayChange) {
                        var permissions = VisorPermissions.getPermissionsFromNext(next);
                        if (!permissions || permissions.length == 0) {
                            return true; // don't do beforeChecks without permissions
                        }
                        if (!finishedBeforeCheck) {
                            var waitForMe = $q.defer();
                            delayChange(waitForMe.promise);
                            $q.all(config.doBeforeFirstCheck.map(function (cb) {
                                return $injector.invoke(cb)
                            }))
                                ['finally'](function () {
                                finishedBeforeCheck = true;
                                if (handlePermission(next, permissions)) {
                                    waitForMe.resolve(true);
                                } else {
                                    waitForMe.reject(false);
                                }
                            });
                            return "delayed";
                        } else {
                            return handlePermission(next, permissions)
                        }
                    },
                    /**
                     * @ngdoc property
                     * @name visor.permissions.visorPermissions#getPermissionsFromNext
                     * @propertyOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     * runtime configuration for {@link visor.permissions.visorPermissionsProvider#getPermissionsFromNext getPermissionsFromNext}.
                     */
                    getPermissionsFromNext: config.getPermissionsFromNext,

                    /**
                     * @ngdoc function
                     * @name visor.permissions.visorPermissions#checkPermissionsForRoute
                     * @methodOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     * A function to check if a route is currently allowed or restricted
                     *
                     * Heavily uses caching
                     *
                     * @param {*} routeId an identifier for a route (depending on the routing module, could be a string,
                     *      regex or some kind of object)
                     *
                     * @returns {Boolean|undefined} true if route is allowed
                     */
                    checkPermissionsForRoute: function (routeId) {
                        var result = cachedRoutes[routeId];
                        if (result !== undefined) {
                            return result;
                        }
                        var route = VisorPermissions.getRoute(routeId);
                        if (!route) {
                            return undefined;
                        }
                        var permissions = VisorPermissions.getPermissionsFromNext(route);
                        result = checkPermissions(permissions);
                        cachedRoutes[routeId] = result;
                        return result;
                    },
                    /**
                     * @ngdoc function
                     * @name visor.permissions.visorPermissions#clearPermissionCache
                     * @methodOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     * Clears the cache used by checkPermissionsForRoute - should be called when
                     * the permission context changes (I.E. after authentication)
                     */
                    clearPermissionCache: function () {
                        cachedRoutes = {}
                        onCacheClearListeners.forEach(function (handler) {
                            handler && handler();
                        });
                    },
                    /**
                     * @ngdoc function
                     * @name visor.permissions.visorPermissions#notifyOnCacheClear
                     * @methodOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     * Notify handler when the permission cache used by checkPermissionsForRoute is cleared
                     *
                     * @param {function} handler the handler function to call
                     *
                     * @returns {function} a dereigster function
                     */
                    notifyOnCacheClear: function (handler) {
                        onCacheClearListeners.push(handler);
                        return function () {
                            var i = onCacheClearListeners.indexOf(handler);
                            if (i != -1) {
                                onCacheClearListeners.splice(i, 1);
                            }
                        }
                    },
                    /**
                     * @ngdoc property
                     * @name visor.permissions.visorPermissions#getRoute
                     * @propertyOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     * runtime configuration for {@link visor.permissions.visorPermissionsProvider#getRoute getRoute}.
                     */
                    getRoute: config.getRoute,
                    /**
                     * @ngdoc property
                     * @name visor.permissions.visorPermissions#invokeParameters
                     * @propertyOf visor.permissions.visorPermissions
                     *
                     * @description
                     *
                     * runtime configuration for {@link visor.permissions.invokeParameters#getPermissionsFromNext getPermissionsFromNext}.
                     */
                    invokeParameters: config.invokeParameters,
                    invokeNotAllowed: function (notAllowedFn) {
                        $injector.invoke(notAllowedFn, null, {restrictedUrl: $location.url()})
                    }
                };
                return VisorPermissions;
            }]
        }])
})();
(function () {
    /**
     * @ngdoc overview
     * @name visor.ui-router
     * @description
     *
     * # Visor.ui-router
     *
     * `Visor.ui-router` automatically add supports for permissions in ui-router, if ui-router exists.
     *
     */
    angular.module('visor.ui-router', ['visor.permissions'])
        .run(['$rootScope', 'visorPermissions', '$injector', '$timeout', '$location', function ($rootScope, visorPermissions, $injector, $timeout, $location) {
            var uiModuleExists = false;
            try {
                $injector.get('$state');
                uiModuleExists = true;
            } catch (e) {
            }
            if (uiModuleExists) {
                $injector.invoke(['$state', function ($state) {
                    // we need to check parent states for permissions as well
                    visorPermissions.getPermissionsFromNext = function (next) {
                        var perms = [];
                        while (next) {
                            if (next.restrict) perms.unshift(next.restrict);
                            if (next.parent) {
                                next = $state.get(next.parent)
                            } else if (next.name.indexOf('.') > 0) {
                                var chain = next.name.split('.');
                                chain.pop(); //remove the leftmost
                                var parent = chain.join('.');
                                next = $state.get(parent);
                            } else {
                                next = null;
                            }
                        }
                        return perms;
                    };
                    var $urlRouter = $injector.get('$urlRouter');
                    var toUrl = null;
                    var bypass = false;
                    $rootScope.$on('$stateChangeStart', function (e, toState, toParams) {
                        if (bypass) {
                            bypass = false;
                            return;
                        }
                        toUrl = $state.href(toState, toParams).replace(/^#/, '');
                        var shouldContinue = visorPermissions.onRouteChange(toState, function delayChange(promise) {
                            promise.then(function () {
                                bypass = true;
                                $state.go(toState, toParams);
                            })
                        });
                        if (!shouldContinue || shouldContinue === 'delayed') {
                            e.preventDefault();
                        }
                    });
                    visorPermissions.invokeNotAllowed = function (notAllowed) {

                        //timeout is required because when using preventDefault on $stateChangeStart, the url is
                        //reverted to it's original location, and no change at this time will override this.
                        $timeout(function () {
                            $injector.invoke(notAllowed, null, {restrictedUrl: toUrl})
                        }, 0);
                    }
                    visorPermissions.getRoute = function (routeId) {
                        return $state.get(routeId);
                    };
                }]);

            }
        }])
})();})(window, window.angular);


text:
package org.apache.ignite.testsuites;

import java.util.Set;
import junit.framework.TestSuite;
import org.apache.ignite.GridSuppressedExceptionSelfTest;
import org.apache.ignite.internal.ClusterGroupHostsSelfTest;
import org.apache.ignite.internal.ClusterGroupSelfTest;
import org.apache.ignite.internal.GridFailFastNodeFailureDetectionSelfTest;
import org.apache.ignite.internal.GridLifecycleAwareSelfTest;
import org.apache.ignite.internal.GridLifecycleBeanSelfTest;
import org.apache.ignite.internal.GridNodeMetricsLogSelfTest;
import org.apache.ignite.internal.GridProjectionForCachesSelfTest;
import org.apache.ignite.internal.GridReduceSelfTest;
import org.apache.ignite.internal.GridReleaseTypeSelfTest;
import org.apache.ignite.internal.GridSelfTest;
import org.apache.ignite.internal.GridStartStopSelfTest;
import org.apache.ignite.internal.GridStopWithCancelSelfTest;
import org.apache.ignite.internal.IgniteLocalNodeMapBeforeStartTest;
import org.apache.ignite.internal.IgniteSlowClientDetectionSelfTest;
import org.apache.ignite.internal.MarshallerContextLockingSelfTest;
import org.apache.ignite.internal.managers.IgniteDiagnosticMessagesTest;
import org.apache.ignite.internal.processors.affinity.GridAffinityProcessorRendezvousSelfTest;
import org.apache.ignite.internal.processors.cache.GridLocalIgniteSerializationTest;
import org.apache.ignite.internal.processors.cache.GridProjectionForCachesOnDaemonNodeSelfTest;
import org.apache.ignite.internal.processors.cache.IgniteDaemonNodeMarshallerCacheTest;
import org.apache.ignite.internal.processors.cache.IgniteMarshallerCacheClassNameConflictTest;
import org.apache.ignite.internal.processors.cache.IgniteMarshallerCacheClientRequestsMappingOnMissTest;
import org.apache.ignite.internal.processors.cache.IgniteMarshallerCacheConcurrentReadWriteTest;
import org.apache.ignite.internal.processors.cache.IgniteMarshallerCacheFSRestoreTest;
import org.apache.ignite.internal.processors.cache.distributed.IgniteRejectConnectOnNodeStopTest;
import org.apache.ignite.internal.processors.closure.GridClosureProcessorRemoteTest;
import org.apache.ignite.internal.processors.closure.GridClosureProcessorSelfTest;
import org.apache.ignite.internal.processors.closure.GridClosureSerializationTest;
import org.apache.ignite.internal.processors.continuous.GridEventConsumeSelfTest;
import org.apache.ignite.internal.processors.continuous.GridMessageListenSelfTest;
import org.apache.ignite.internal.processors.database.BPlusTreeFakeReuseSelfTest;
import org.apache.ignite.internal.processors.database.BPlusTreeReuseSelfTest;
import org.apache.ignite.internal.processors.database.BPlusTreeSelfTest;
import org.apache.ignite.internal.processors.database.FreeListImplSelfTest;
import org.apache.ignite.internal.processors.database.DataRegionMetricsSelfTest;
import org.apache.ignite.internal.processors.database.MetadataStorageSelfTest;
import org.apache.ignite.internal.processors.database.SwapPathConstructionSelfTest;
import org.apache.ignite.internal.processors.odbc.OdbcConfigurationValidationSelfTest;
import org.apache.ignite.internal.processors.odbc.OdbcEscapeSequenceSelfTest;
import org.apache.ignite.internal.processors.service.ClosureServiceClientsNodesTest;
import org.apache.ignite.internal.product.GridProductVersionSelfTest;
import org.apache.ignite.internal.util.nio.IgniteExceptionInNioWorkerSelfTest;
import org.apache.ignite.internal.util.typedef.internal.U;
import org.apache.ignite.marshaller.DynamicProxySerializationMultiJvmSelfTest;
import org.apache.ignite.marshaller.MarshallerContextSelfTest;
import org.apache.ignite.messaging.GridMessagingNoPeerClassLoadingSelfTest;
import org.apache.ignite.messaging.GridMessagingSelfTest;
import org.apache.ignite.messaging.IgniteMessagingSendAsyncTest;
import org.apache.ignite.messaging.IgniteMessagingWithClientTest;
import org.apache.ignite.plugin.security.SecurityPermissionSetBuilderTest;
import org.apache.ignite.spi.GridSpiLocalHostInjectionTest;
import org.apache.ignite.startup.properties.NotStringSystemPropertyTest;
import org.apache.ignite.testframework.GridTestUtils;
import org.apache.ignite.testframework.test.ConfigVariationsTestSuiteBuilderTest;
import org.apache.ignite.testframework.test.ParametersTest;
import org.apache.ignite.testframework.test.VariationsIteratorTest;
import org.apache.ignite.util.AttributeNodeFilterSelfTest;
import org.jetbrains.annotations.Nullable;

/**
 * Basic test suite.
 */
public class IgniteBasicTestSuite extends TestSuite {
    /**
     * @return Test suite.
     * @throws Exception Thrown in case of the failure.
     */
    public static TestSuite suite() throws Exception {
        return suite(null);
    }

    /**
     * @param ignoredTests Tests don't include in the execution. Providing null means nothing to exclude.
     * @return Test suite.
     * @throws Exception Thrown in case of the failure.
     */
    public static TestSuite suite(@Nullable final Set<Class> ignoredTests) throws Exception {
        TestSuite suite = new TestSuite("Ignite Basic Test Suite");

        suite.addTest(IgniteMarshallerSelfTestSuite.suite(ignoredTests));
        suite.addTest(IgniteLangSelfTestSuite.suite());
        suite.addTest(IgniteUtilSelfTestSuite.suite(ignoredTests));

        suite.addTest(IgniteKernalSelfTestSuite.suite(ignoredTests));
        suite.addTest(IgniteStartUpTestSuite.suite());
        suite.addTest(IgniteExternalizableSelfTestSuite.suite());
        suite.addTest(IgniteP2PSelfTestSuite.suite(ignoredTests));
        suite.addTest(IgniteCacheP2pUnmarshallingErrorTestSuite.suite(ignoredTests));
        suite.addTest(IgniteStreamSelfTestSuite.suite());

        suite.addTest(IgnitePlatformsTestSuite.suite());

        suite.addTest(new TestSuite(GridSelfTest.class));
        suite.addTest(new TestSuite(ClusterGroupHostsSelfTest.class));
        suite.addTest(new TestSuite(IgniteMessagingWithClientTest.class));
        suite.addTest(new TestSuite(IgniteMessagingSendAsyncTest.class));

        GridTestUtils.addTestIfNeeded(suite, ClusterGroupSelfTest.class, ignoredTests);
        GridTestUtils.addTestIfNeeded(suite, GridMessagingSelfTest.class, ignoredTests);
        GridTestUtils.addTestIfNeeded(suite, GridMessagingNoPeerClassLoadingSelfTest.class, ignoredTests);

        if (U.isLinux() || U.isMacOs())
            suite.addTest(IgniteIpcSharedMemorySelfTestSuite.suite());

        GridTestUtils.addTestIfNeeded(suite, GridReleaseTypeSelfTest.class, ignoredTests);
        suite.addTestSuite(GridProductVersionSelfTest.class);
        suite.addTestSuite(GridAffinityProcessorRendezvousSelfTest.class);
        suite.addTestSuite(GridClosureProcessorSelfTest.class);
        suite.addTestSuite(GridClosureProcessorRemoteTest.class);
        suite.addTestSuite(GridClosureSerializationTest.class);
        suite.addTestSuite(ClosureServiceClientsNodesTest.class);
        suite.addTestSuite(GridStartStopSelfTest.class);
        suite.addTestSuite(GridProjectionForCachesSelfTest.class);
        suite.addTestSuite(GridProjectionForCachesOnDaemonNodeSelfTest.class);
        suite.addTestSuite(GridSpiLocalHostInjectionTest.class);
        suite.addTestSuite(GridLifecycleBeanSelfTest.class);
        suite.addTestSuite(GridStopWithCancelSelfTest.class);
        suite.addTestSuite(GridReduceSelfTest.class);
        suite.addTestSuite(GridEventConsumeSelfTest.class);
        suite.addTestSuite(GridSuppressedExceptionSelfTest.class);
        suite.addTestSuite(GridLifecycleAwareSelfTest.class);
        suite.addTestSuite(GridMessageListenSelfTest.class);
        suite.addTestSuite(GridFailFastNodeFailureDetectionSelfTest.class);
        suite.addTestSuite(IgniteSlowClientDetectionSelfTest.class);
        GridTestUtils.addTestIfNeeded(suite, IgniteDaemonNodeMarshallerCacheTest.class, ignoredTests);
        suite.addTestSuite(IgniteMarshallerCacheConcurrentReadWriteTest.class);
        suite.addTestSuite(GridNodeMetricsLogSelfTest.class);
        suite.addTestSuite(GridLocalIgniteSerializationTest.class);

        suite.addTestSuite(IgniteExceptionInNioWorkerSelfTest.class);
        suite.addTestSuite(IgniteLocalNodeMapBeforeStartTest.class);
        suite.addTestSuite(OdbcConfigurationValidationSelfTest.class);
        suite.addTestSuite(OdbcEscapeSequenceSelfTest.class);

        GridTestUtils.addTestIfNeeded(suite, DynamicProxySerializationMultiJvmSelfTest.class, ignoredTests);

        // Tests against configuration variations framework.
        suite.addTestSuite(ParametersTest.class);
        suite.addTestSuite(VariationsIteratorTest.class);
        suite.addTestSuite(ConfigVariationsTestSuiteBuilderTest.class);
        suite.addTestSuite(NotStringSystemPropertyTest.class);

        suite.addTestSuite(MarshallerContextLockingSelfTest.class);
        suite.addTestSuite(MarshallerContextSelfTest.class);

        suite.addTestSuite(SecurityPermissionSetBuilderTest.class);

        suite.addTestSuite(AttributeNodeFilterSelfTest.class);

        // Basic DB data structures.
        suite.addTestSuite(BPlusTreeSelfTest.class);
        suite.addTestSuite(BPlusTreeFakeReuseSelfTest.class);
        suite.addTestSuite(BPlusTreeReuseSelfTest.class);
        suite.addTestSuite(MetadataStorageSelfTest.class);
        suite.addTestSuite(FreeListImplSelfTest.class);
        suite.addTestSuite(DataRegionMetricsSelfTest.class);
        suite.addTestSuite(SwapPathConstructionSelfTest.class);

        suite.addTestSuite(IgniteMarshallerCacheFSRestoreTest.class);
        suite.addTestSuite(IgniteMarshallerCacheClassNameConflictTest.class);
        suite.addTestSuite(IgniteMarshallerCacheClientRequestsMappingOnMissTest.class);

        suite.addTestSuite(IgniteDiagnosticMessagesTest.class);

        suite.addTestSuite(IgniteRejectConnectOnNodeStopTest.class);

        return suite;
    }
}


text:
from setuptools import setup, find_packages

setup(
    name='coinrun',
    packages=find_packages(),
    version='0.0.1',
)


text:
<!doctype html>

    <meta charset="utf-8"/>
    <title>Boxer.js login example</title>
    <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="loginbox.css" media="screen"/>

You can find more on github.

Try clicking the buttons to rotate the box!

                                <form class="form-body" id="login-form">

Please sign in

                                    Email address
                                    <input id="inputUsername" class="form-control" placeholder="username" autofocus>
                                    Password
                                    <input type="password" id="inputPassword" class="form-control"
                                           placeholder="Password">

                                            <input type="checkbox" value="remember-me"> Remember me

                                    <button id="signin-button" class="btn btn-lg btn-primary btn-block" type="submit">
                                        Sign in
                                    </button>
                                    Forgot password?
                                </form>

                                <form class="form-body">

Forgot Password?

                                    <fieldset>

                                                <input placeholder="email address"
                                                       class="form-control" type="email">

                                            <input id="password-reset" class="btn btn-lg btn-primary btn-block"
                                                   value="Reset my password!" type="submit">

                                    </fieldset>
                                </form>

An e-mail has been sent to you to reset your password.

                                    <button id="proceed-to-sign-in" class="btn btn-lg btn-primary btn-block">
                                        Proceed to sign in...
                                    </button>

Welcome !

You are logged in.

                                    <button id="view-profile" class="btn btn-lg btn-primary btn-block">
                                        View profile
                                    </button>
                                    <button id="log-out" class="btn btn-lg btn-primary btn-block">
                                        Log out
                                    </button>

You are logged out.

                                    <button id="sign-in-from-logout" class="btn btn-lg btn-primary btn-block">
                                        Sign in
                                    </button>

This is your profile

                                    <button id="back" class="btn btn-lg btn-primary btn-block">
                                        Back
                                    </button>