text:
package org.chocosolver.docs;

import org.chocosolver.solver.Solver;
import org.chocosolver.solver.constraints.ICF;
import org.chocosolver.solver.constraints.extension.Tuples;
import org.chocosolver.solver.constraints.nary.automata.FA.CostAutomaton;
import org.chocosolver.solver.constraints.nary.automata.FA.FiniteAutomaton;
import org.chocosolver.solver.constraints.nary.circuit.CircuitConf;
import org.chocosolver.solver.trace.Chatterbox;
import org.chocosolver.solver.variables.BoolVar;
import org.chocosolver.solver.variables.IntVar;
import org.chocosolver.solver.variables.Task;
import org.chocosolver.solver.variables.VF;
import org.testng.annotations.Test;

/**
 * BEWARE: 5_elements.rst SHOULD BE UPDATED ANYTIME THIS CLASS IS CHANGED
 *
 * @author Charles Prud'homme
 * @version choco
 * @since 16/09/2014
 */
public class IntConstraintExamples {

    @Test
    public void arithm1() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 4, solver);
        solver.post(ICF.arithm(X, ">", 2));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testmember1() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 4, solver);
        solver.post(ICF.member(X, new int[]{-2, -1, 0, 1, 2}));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testmember2() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 4, solver);
        solver.post(ICF.member(X, 2, 5));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testnotmember1() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 4, solver);
        solver.post(ICF.not_member(X, new int[]{-2, -1, 0, 1, 2}));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testnotmember2() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 4, solver);
        solver.post(ICF.not_member(X, 2, 5));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testabsolute() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 0, 2, solver);
        IntVar Y = VF.enumerated("X", -6, 1, solver);
        solver.post(ICF.absolute(X, Y));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testarithm3() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 0, 2, solver);
        IntVar Y = VF.enumerated("X", -6, 1, solver);
        solver.post(ICF.arithm(X, "<=", Y, "+", 1));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testdistance1() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 0, 2, solver);
        IntVar Y = VF.enumerated("X", -3, 1, solver);
        solver.post(ICF.distance(X, Y, "=", 1));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testelement1() {
        Solver solver = new Solver();
        IntVar V = VF.enumerated("V", -2, 2, solver);
        IntVar I = VF.enumerated("I", 0, 5, solver);
        solver.post(ICF.element(V, new int[]{2, -2, 1, -1, 0}, I, 0, "none"));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testsquare() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 0, 5, solver);
        IntVar Y = VF.enumerated("Y", -1, 3, solver);
        solver.post(ICF.square(X, Y));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testtable1() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 0, 5, solver);
        IntVar Y = VF.enumerated("Y", -1, 3, solver);
        Tuples tuples = new Tuples(true);
        tuples.add(1, -2);
        tuples.add(1, 1);
        tuples.add(4, 2);
        tuples.add(1, 4);
        solver.post(ICF.table(X, Y, tuples, "AC2001"));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testdistance2() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 3, solver);
        IntVar Y = VF.enumerated("Y", -1, 1, solver);
        IntVar Z = VF.enumerated("Z", 2, 3, solver);
        solver.post(ICF.distance(X, Y, "<", Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testeucli_div() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 1, 3, solver);
        IntVar Y = VF.enumerated("Y", -1, 1, solver);
        IntVar Z = VF.enumerated("Z", 2, 3, solver);
        solver.post(ICF.eucl_div(X, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testmaximum() {
        Solver solver = new Solver();
        IntVar MAX = VF.enumerated("MAX", 1, 3, solver);
        IntVar Y = VF.enumerated("Y", -1, 1, solver);
        IntVar Z = VF.enumerated("Z", 2, 3, solver);
        solver.post(ICF.maximum(MAX, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testminimum() {
        Solver solver = new Solver();
        IntVar MIN = VF.enumerated("MIN", 1, 3, solver);
        IntVar Y = VF.enumerated("Y", -1, 1, solver);
        IntVar Z = VF.enumerated("Z", 2, 3, solver);
        solver.post(ICF.minimum(MIN, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testmod() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", 2, 4, solver);
        IntVar Y = VF.enumerated("Y", -1, 4, solver);
        IntVar Z = VF.enumerated("Z", 1, 3, solver);
        solver.post(ICF.mod(X, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testtimes() {
        Solver solver = new Solver();
        IntVar X = VF.enumerated("X", -1, 2, solver);
        IntVar Y = VF.enumerated("Y", 2, 4, solver);
        IntVar Z = VF.enumerated("Z", 5, 7, solver);
        solver.post(ICF.times(X, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testalldifferent() {
        Solver solver = new Solver();
        IntVar W = VF.enumerated("W", 0, 1, solver);
        IntVar X = VF.enumerated("X", -1, 2, solver);
        IntVar Y = VF.enumerated("Y", 2, 4, solver);
        IntVar Z = VF.enumerated("Z", 5, 7, solver);
        solver.post(ICF.alldifferent(new IntVar[]{W, X, Y, Z}));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testalldifferent_cond() {
        Solver solver = new Solver();
        IntVar[] XS = VF.enumeratedArray("XS", 5, 0, 3, solver);
        solver.post(ICF.alldifferent_conditionnal(XS,
                x -> !x.contains(1) && !x.contains(3)));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testalldifferent_exc0() {
        Solver solver = new Solver();
        IntVar[] XS = VF.enumeratedArray("XS", 4, 0, 2, solver);
        solver.post(ICF.alldifferent_except_0(XS));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testamong() {
        Solver solver = new Solver();
        IntVar N = VF.enumerated("N", 2, 3, solver);
        IntVar[] XS = VF.enumeratedArray("XS", 4, 0, 6, solver);
        solver.post(ICF.among(N, XS, new int[]{1, 2, 3}));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();

    }

    @Test(groups = "1s")
    public void testatleast_nvalues() {
        Solver solver = new Solver();
        IntVar[] XS = VF.enumeratedArray("XS", 4, 0, 2, solver);
        IntVar N = VF.enumerated("N", 2, 3, solver);
        solver.post(ICF.atleast_nvalues(XS, N, true));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testatmost_nvalues() {
        Solver solver = new Solver();
        IntVar[] XS = VF.enumeratedArray("XS", 4, 0, 2, solver);
        IntVar N = VF.enumerated("N", 1, 3, solver);
        solver.post(ICF.atmost_nvalues(XS, N, false));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testbin_packing() {
        Solver solver = new Solver();
        IntVar[] IBIN = VF.enumeratedArray("IBIN", 5, 1, 3, solver);
        int[] sizes = new int[]{2, 3, 1, 4, 2};
        IntVar[] BLOADS = VF.enumeratedArray("BLOADS", 3, 0, 5, solver);
        solver.post(ICF.bin_packing(IBIN, sizes, BLOADS, 1));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testboolean_channeling() {
        Solver solver = new Solver();
        BoolVar[] BVARS = VF.boolArray("BVARS", 5, solver);
        IntVar VAR = VF.enumerated("VAR", 1, 5, solver);
        solver.post(ICF.boolean_channeling(BVARS, VAR, 1));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testcircuit() {
        Solver solver = new Solver();
        IntVar[] NODES = VF.enumeratedArray("NODES", 5, 0, 4, solver);
        solver.post(ICF.circuit(NODES, 0, CircuitConf.LIGHT));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testcost_regular() {
        Solver solver = new Solver();
        IntVar[] VARS = VF.enumeratedArray("VARS", 5, 0, 2, solver);
        IntVar COST = VF.enumerated("COST", 0, 10, solver);
        FiniteAutomaton fauto = new FiniteAutomaton();
        int start = fauto.addState();
        int end = fauto.addState();
        fauto.setInitialState(start);
        fauto.setFinal(start, end);

        fauto.addTransition(start, start, 0, 1);
        fauto.addTransition(start, end, 2);

        fauto.addTransition(end, end, 1);
        fauto.addTransition(end, start, 0, 2);

        int[][] costs = new int[5][3];
        costs[0] = new int[]{1, 2, 3};
        costs[1] = new int[]{2, 3, 1};
        costs[2] = new int[]{3, 1, 2};
        costs[3] = new int[]{3, 2, 1};
        costs[4] = new int[]{2, 1, 3};

        solver.post(ICF.cost_regular(VARS, COST, CostAutomaton.makeSingleResource(fauto, costs, COST.getLB(), COST.getUB())));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testcount() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 3, solver);
        IntVar VA = VF.enumerated("VA", new int[]{1, 3}, solver);
        IntVar CO = VF.enumerated("CO", new int[]{0, 2, 4}, solver);
        solver.post(ICF.count(VA, VS, CO));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testcumulative() {
        Solver solver = new Solver();
        Task[] TS = new Task[5];
        IntVar[] HE = new IntVar[5];
        for (int i = 0; i < TS.length; i++) {
            IntVar S = VF.bounded("S_" + i, 0, 4, solver);
            TS[i] = VF.task(
                    S,
                    VF.fixed("D_" + i, i + 1, solver),
                    VF.offset(S, i + 1)
            );
            HE[i] = VF.bounded("HE_" + i, i - 1, i + 1, solver);
        }
        IntVar CA = VF.enumerated("CA", 1, 3, solver);
        solver.post(ICF.cumulative(TS, HE, CA, true));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testdiffn() {
        Solver solver = new Solver();
        IntVar[] X = VF.boundedArray("X", 4, 0, 1, solver);
        IntVar[] Y = VF.boundedArray("Y", 4, 0, 2, solver);
        IntVar[] D = new IntVar[4];
        IntVar[] W = new IntVar[4];
        for (int i = 0; i < 4; i++) {
            D[i] = VF.fixed("D_" + i, 1, solver);
            W[i] = VF.fixed("W_" + i, i + 1, solver);
        }
        solver.post(ICF.diffn(X, Y, D, W, true));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testglobal_cardinality() {
        Solver solver = new Solver();
        IntVar[] VS = VF.boundedArray("VS", 4, 0, 4, solver);
        int[] values = new int[]{-1, 1, 2};
        IntVar[] OCC = VF.boundedArray("OCC", 3, 0, 2, solver);
        solver.post(ICF.global_cardinality(VS, values, OCC, true));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testinverse_channeling() {
        Solver solver = new Solver();
        IntVar[] X = VF.enumeratedArray("X", 3, 0, 3, solver);
        IntVar[] Y = VF.enumeratedArray("Y", 3, 1, 4, solver);
        solver.post(ICF.inverse_channeling(X, Y, 0, 1));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testknapsack() {
        Solver solver = new Solver();
        IntVar[] IT = new IntVar[3]; // 3 items
        IT[0] = VF.bounded("IT_0", 0, 3, solver);
        IT[1] = VF.bounded("IT_1", 0, 2, solver);
        IT[2] = VF.bounded("IT_2", 0, 1, solver);
        IntVar WE = VF.bounded("WE", 0, 8, solver);
        IntVar EN = VF.bounded("EN", 0, 6, solver);
        int[] weights = new int[]{1, 3, 4};
        int[] energies = new int[]{1, 4, 6};
        solver.post(ICF.knapsack(IT, WE, EN, weights, energies));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testlex_chain_less() {
        Solver solver = new Solver();
        IntVar[] X = VF.enumeratedArray("X", 3, -1, 1, solver);
        IntVar[] Y = VF.enumeratedArray("Y", 3, 1, 2, solver);
        IntVar[] Z = VF.enumeratedArray("Z", 3, 0, 2, solver);
        solver.post(ICF.lex_chain_less(X, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testlex_chain_less_eq() {
        Solver solver = new Solver();
        IntVar[] X = VF.enumeratedArray("X", 3, -1, 1, solver);
        IntVar[] Y = VF.enumeratedArray("Y", 3, 1, 2, solver);
        IntVar[] Z = VF.enumeratedArray("Z", 3, 0, 2, solver);
        solver.post(ICF.lex_chain_less_eq(X, Y, Z));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testlex_less() {
        Solver solver = new Solver();
        IntVar[] X = VF.enumeratedArray("X", 3, -1, 1, solver);
        IntVar[] Y = VF.enumeratedArray("Y", 3, 1, 2, solver);
        solver.post(ICF.lex_less(X, Y));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testlex_less_eq() {
        Solver solver = new Solver();
        IntVar[] X = VF.enumeratedArray("X", 3, -1, 1, solver);
        IntVar[] Y = VF.enumeratedArray("Y", 3, 1, 2, solver);
        solver.post(ICF.lex_less_eq(X, Y));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testmulticost_regular() {
        Solver solver = new Solver();
        IntVar[] VARS = VF.enumeratedArray("VARS", 5, 0, 2, solver);
        IntVar[] CVARS = VF.enumeratedArray("CVARS", 5, 0, 10, solver);
        FiniteAutomaton fauto = new FiniteAutomaton();
        int start = fauto.addState();
        int end = fauto.addState();
        fauto.setInitialState(start);
        fauto.setFinal(start, end);

        fauto.addTransition(start, start, 0, 1);
        fauto.addTransition(start, end, 2);

        fauto.addTransition(end, end, 1);
        fauto.addTransition(end, start, 0, 2);

        int[][][] costs = new int[5][3][];
//        costs[0] = new int[]{1, 2, 3};
//        costs[1] = new int[]{2, 3, 1};
//        costs[2] = new int[]{3, 1, 2};
//        costs[3] = new int[]{3, 2, 1};
//        costs[4] = new int[]{2, 1, 3};

        solver.post(ICF.multicost_regular(VARS, CVARS, CostAutomaton.makeMultiResources(fauto, costs, CVARS)));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testnvalues() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 2, solver);
        IntVar N = VF.enumerated("N", 0, 3, solver);
        solver.post(ICF.nvalues(VS, N));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testpath() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 4, solver);
        IntVar S = VF.enumerated("S", 0, 3, solver);
        IntVar E = VF.enumerated("E", 0, 3, solver);
        solver.post(ICF.path(VS, S, E, 0));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testregular() {
        Solver solver = new Solver();
        IntVar[] CS = VF.enumeratedArray("CS", 4, 1, 5, solver);
        solver.post(ICF.regular(CS,
                new FiniteAutomaton("(1|2)(3*)(4|5)")));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testscalar() {
        Solver solver = new Solver();
        IntVar[] CS = VF.enumeratedArray("CS", 4, 1, 4, solver);
        int[] coeffs = new int[]{1, 2, 3, 4};
        IntVar R = VF.bounded("R", 0, 20, solver);
        solver.post(ICF.scalar(CS, coeffs, R));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testsort() {
        Solver solver = new Solver();
        IntVar[] X = VF.enumeratedArray("X", 3, 0, 2, solver);
        IntVar[] Y = VF.enumeratedArray("Y", 3, 0, 2, solver);
        solver.post(ICF.sort(X, Y));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testsubcircuit() {
        Solver solver = new Solver();
        IntVar[] NODES = VF.enumeratedArray("NS", 5, 0, 4, solver);
        IntVar SI = VF.enumerated("SI", 2, 3, solver);
        solver.post(ICF.subcircuit(NODES, 0, SI));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testsubpath() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 4, solver);
        IntVar S = VF.enumerated("S", 0, 3, solver);
        IntVar E = VF.enumerated("E", 0, 3, solver);
        IntVar SI = VF.enumerated("SI", 2, 3, solver);
        solver.post(ICF.subpath(VS, S, E, 0, SI));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testsum() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 4, solver);
        IntVar SU = VF.enumerated("SU", 2, 3, solver);
        solver.post(ICF.sum(VS, "<=", SU));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testtree() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 4, solver);
        IntVar NT = VF.enumerated("NT", 2, 3, solver);
        solver.post(ICF.tree(VS, NT, 0));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testtsp() {
        Solver solver = new Solver();
        IntVar[] VS = VF.enumeratedArray("VS", 4, 0, 4, solver);
        IntVar CO = VF.enumerated("CO", 0, 15, solver);
        int[][] costs = new int[][]{{0, 1, 3, 7}, {1, 0, 1, 3}, {3, 1, 0, 1}, {7, 3, 1, 0}};
        solver.post(ICF.tsp(VS, CO, costs));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }

    @Test(groups = "1s")
    public void testbit_channeling() {
        Solver solver = new Solver();
        BoolVar[] BVARS = VF.boolArray("BVARS", 4, solver);
        IntVar VAR = VF.enumerated("VAR", 0, 15, solver);
        solver.post(ICF.bit_channeling(BVARS, VAR));
        Chatterbox.showSolutions(solver);
        solver.findAllSolutions();
    }
}


text:
<?php

namespace Molajo\C;

/**
 * Test
 *
 * @author     Amy Stephen
 * @license    http://www.opensource.org/licenses/mit-license.html MIT License
 * @copyright  2014-2015 Amy Stephen. All rights reserved.
 * @since      1.0.0
 */
class Candy
{

}

redpajama_set_name: RedPajamaGithub


text:
package com.patryklenza.androidespressoidlingresource;

import com.google.gson.Gson;

import java.util.List;
import java.util.concurrent.Executors;

import retrofit.RestAdapter;
import retrofit.converter.GsonConverter;
import rx.Observable;

public class BackendService implements BackendContract {

    static {
        final RestAdapter restAdapter = new RestAdapter.Builder().setEndpoint("https://api.github.com")
                                                                 .setExecutors(Executors.newCachedThreadPool(), null)
                                                                 .setConverter(new GsonConverter(new Gson()))
                                                                 .setLogLevel(BuildConfig.DEBUG ? RestAdapter.LogLevel.FULL : RestAdapter.LogLevel
                                                                         .NONE)
                                                                 .build();
        service = restAdapter.create(BackendContract.class);
    }

    private static BackendContract service;

    @Override
    public Observable<List<Repository>> getJakesRepos() {
        return service.getJakesRepos();
    }
}


text:
package com.jameswolfeoliver.pigeon.Models;

import android.annotation.SuppressLint;

import com.google.gson.annotations.SerializedName;

import java.util.Objects;

import io.github.jameswolfeoliver.atlaslibrary.Models.Comparable;

public class Message implements Comparable {
    @SerializedName("person")
    private int person;

    @SerializedName("date")
    private long date;

    @SerializedName("threadId")
    private int threadId;

    @SerializedName("address")
    private long address;

    @SerializedName("type")
    private int type;

    @SerializedName("status")
    private int status;

    @SerializedName("read")
    private int read;

    @SerializedName("body")
    private String body;

    private Message(int threadId) {
        this.threadId = threadId;
    }

    public int getType() {
        return type;
    }

    public long getDate() {
        return date;
    }

    public int getThreadId() {
        return threadId;
    }

    public long getAddress() {
        return address;
    }

    public int getPerson() {
        return person;
    }

    public String getBody() {
        return body;
    }

    public boolean getRead() {
        return read == 1;
    }

    public int getStatus() {
        return status;
    }

    @SuppressLint("DefaultLocale")
    @Override
    public String toString() {
        return String.format("person: %s; threadId: %d; address: %s; date: %d;" +
                        "\n\tbody: %s; " +
                        "\n\t\ttype: %d; status: %d, read: %b;",
                person, threadId, address, date, body, type, status, getRead());
    }

    @Override
    public boolean equals(Object object) {
        if (object == this) {
            return true;
        }
        if (!(object instanceof Conversation)) {
            return false;
        }
        Message message = (Message) object;
        return Objects.equals(this.threadId, message.threadId)
                && Objects.equals(this.body, message.body)
                && Objects.equals(this.date, message.date);
    }

    @Override
    public boolean compare(Object o) {
        return equals(o);
    }

    @Override
    public int hashCode() {
        return Objects.hash(threadId, body, date);
    }

    public static class Builder {
        private Message message;

        public Builder(int threadId) {
            this.message = new Message(threadId);
            this.message.address = 0;
            this.message.person = 0;
            this.message.date = 0;
            this.message.type = -1;
            this.message.body = "";
            this.message.status = -1;
            this.message.read = 0;
        }

        public Builder(Message donorMessage) {
            this.message = new Message(donorMessage.getThreadId());
            this.message.address = donorMessage.getAddress();
            this.message.person = donorMessage.getPerson();
            this.message.date = donorMessage.getDate();
            this.message.type = donorMessage.getType();
            this.message.body = donorMessage.getBody();
            this.message.status = donorMessage.getStatus();
            this.message.read = donorMessage.read;
        }

        public Builder setBody(String body) {
            if (body != null)
                this.message.body = body;
            return this;
        }

        public Builder setPerson(int person) {
            this.message.person = person;
            return this;
        }

        public Builder setAddress(long address) {
            this.message.address = address;
            return this;
        }

        public Builder setDate(long date) {
            this.message.date = date;
            return this;
        }

        public Builder setThreadId(int threadId) {
            this.message.threadId = threadId;
            return this;
        }

        public Builder setType(int type) {
            this.message.type = type;
            return this;
        }

        public Builder setRead(int read) {
            this.message.read = read;
            return this;
        }

        public Builder setStatus(int status) {
            this.message.status = status;
            return this;
        }

        public Message build() {
            return message;
        }
    }
}


text:
package mockid

import "sync/atomic"

// IDAllocator mocks IDAllocator and it is only used for test.
type IDAllocator struct {
	base uint64
}

// NewIDAllocator creates a new IDAllocator.
func NewIDAllocator() *IDAllocator {
	return &IDAllocator{base: 0}
}

// Alloc returns a new id.
func (alloc *IDAllocator) Alloc() (uint64, error) {
	return atomic.AddUint64(&alloc.base, 1), nil
}

// Rebase implements the IDAllocator interface.
func (alloc *IDAllocator) Rebase() error {
	return nil
}


text:
package org.apache.carbondata.hadoop.ft;

import java.util.List;
import java.util.UUID;

import org.apache.carbondata.core.carbon.CarbonTableIdentifier;
import org.apache.carbondata.core.carbon.metadata.datatype.DataType;
import org.apache.carbondata.hadoop.CarbonInputFormat;
import org.apache.carbondata.scan.expression.ColumnExpression;
import org.apache.carbondata.scan.expression.Expression;
import org.apache.carbondata.scan.expression.LiteralExpression;
import org.apache.carbondata.scan.expression.conditional.EqualToExpression;

import junit.framework.TestCase;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CarbonInputFormat_FT extends TestCase {

  @Before public void setUp() throws Exception {
    //create a table with column c1 string type
    //Insert data with column c1 has "a", "b", "c"
  }

  @Test public void testGetSplits() throws Exception {
    CarbonInputFormat carbonInputFormat = new CarbonInputFormat();
    JobConf jobConf = new JobConf(new Configuration());
    Job job = new Job(jobConf);
    FileInputFormat.addInputPath(job, new Path("/opt/carbonstore/db/table1"));
    job.getConfiguration().set(CarbonInputFormat.INPUT_SEGMENT_NUMBERS, "1,2");
    List splits = carbonInputFormat.getSplits(job);

    Assert.assertTrue(splits != null);
    Assert.assertTrue(!splits.isEmpty());
  }

  @Test public void testGetFilteredSplits() throws Exception {
    CarbonInputFormat carbonInputFormat = new CarbonInputFormat();
    JobConf jobConf = new JobConf(new Configuration());
    Job job = new Job(jobConf);
    FileInputFormat.addInputPath(job, new Path("/opt/carbonstore/db/table1"));
    job.getConfiguration().set(CarbonInputFormat.INPUT_SEGMENT_NUMBERS, "1,2");
    Expression expression = new EqualToExpression(new ColumnExpression("c1", DataType.STRING),
        new LiteralExpression("a", DataType.STRING));
    CarbonInputFormat.setFilterPredicates(job.getConfiguration(), expression);
    List splits = carbonInputFormat.getSplits(job);

    Assert.assertTrue(splits != null);
    Assert.assertTrue(!splits.isEmpty());
  }
}


text:
function sendMessageRaw(message) {
  /*jshint validthis:true */
  message['channel'] = this.id;
  message['parse'] = 'none';
  this._client._send(message);
}

function patchSendMessage(robot) {
  // We monkey patch sendMessage function to send "parse" argument with the message so the text is not
  // formatted and parsed on the server side.
  // NOTE / TODO: We can get rid of this nasty patch once our node-slack-client and hubot-slack pull
  // requests are merged.
  if (robot.adapter && robot.adapter.constructor && robot.adapter.constructor.name === 'SlackBot') {
    for (var channel in robot.adapter.client.channels) {
      robot.adapter.client.channels[channel].sendMessage = sendMessageRaw.bind(robot.adapter.client.channels[channel]);
    }
  }
}

exports.patchSendMessage = patchSendMessage;


text:
package platform

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"

	"github.com/coreos/pkg/capnslog"
	"github.com/satori/go.uuid"
	"golang.org/x/crypto/ssh"
	"golang.org/x/crypto/ssh/agent"

	"github.com/coreos/mantle/network"
	"github.com/coreos/mantle/platform/conf"
	"github.com/coreos/mantle/util"
)

var (
	plog = capnslog.NewPackageLogger("github.com/coreos/mantle", "platform")
)

type BaseCluster struct {
	agent *network.SSHAgent

	machlock   sync.Mutex
	machmap    map[string]Machine
	consolemap map[string]string

	name       string
	rconf      *RuntimeConfig
	platform   Name
	ctPlatform string
	baseopts   *Options
}

func NewBaseCluster(opts *Options, rconf *RuntimeConfig, platform Name, ctPlatform string) (*BaseCluster, error) {
	return NewBaseClusterWithDialer(opts, rconf, platform, ctPlatform, network.NewRetryDialer())
}

func NewBaseClusterWithDialer(opts *Options, rconf *RuntimeConfig, platform Name, ctPlatform string, dialer network.Dialer) (*BaseCluster, error) {
	agent, err := network.NewSSHAgent(dialer)
	if err != nil {
		return nil, err
	}

	bc := &BaseCluster{
		agent:      agent,
		machmap:    make(map[string]Machine),
		consolemap: make(map[string]string),
		name:       fmt.Sprintf("%s-%s", opts.BaseName, uuid.NewV4()),
		rconf:      rconf,
		platform:   platform,
		ctPlatform: ctPlatform,
		baseopts:   opts,
	}

	return bc, nil
}

func (bc *BaseCluster) SSHClient(ip string) (*ssh.Client, error) {
	sshClient, err := bc.agent.NewClient(ip)
	if err != nil {
		return nil, err
	}

	return sshClient, nil
}

func (bc *BaseCluster) UserSSHClient(ip, user string) (*ssh.Client, error) {
	sshClient, err := bc.agent.NewUserClient(ip, user)
	if err != nil {
		return nil, err
	}

	return sshClient, nil
}

func (bc *BaseCluster) PasswordSSHClient(ip string, user string, password string) (*ssh.Client, error) {
	sshClient, err := bc.agent.NewPasswordClient(ip, user, password)
	if err != nil {
		return nil, err
	}

	return sshClient, nil
}

// SSH executes the given command, cmd, on the given Machine, m. It returns the
// stdout and stderr of the command and an error.
// Leading and trailing whitespace is trimmed from each.
func (bc *BaseCluster) SSH(m Machine, cmd string) ([]byte, []byte, error) {
	var stdout bytes.Buffer
	var stderr bytes.Buffer
	client, err := bc.SSHClient(m.IP())
	if err != nil {
		return nil, nil, err
	}
	defer client.Close()

	session, err := client.NewSession()
	if err != nil {
		return nil, nil, err
	}
	defer session.Close()

	session.Stdout = &stdout
	session.Stderr = &stderr
	err = session.Run(cmd)
	outBytes := bytes.TrimSpace(stdout.Bytes())
	errBytes := bytes.TrimSpace(stderr.Bytes())
	return outBytes, errBytes, err
}

func (bc *BaseCluster) Machines() []Machine {
	bc.machlock.Lock()
	defer bc.machlock.Unlock()
	machs := make([]Machine, 0, len(bc.machmap))
	for _, m := range bc.machmap {
		machs = append(machs, m)
	}
	return machs
}

func (bc *BaseCluster) AddMach(m Machine) {
	bc.machlock.Lock()
	defer bc.machlock.Unlock()
	bc.machmap[m.ID()] = m
}

func (bc *BaseCluster) DelMach(m Machine) {
	bc.machlock.Lock()
	defer bc.machlock.Unlock()
	delete(bc.machmap, m.ID())
	bc.consolemap[m.ID()] = m.ConsoleOutput()
}

func (bc *BaseCluster) Keys() ([]*agent.Key, error) {
	return bc.agent.List()
}

func (bc *BaseCluster) RenderUserData(userdata *conf.UserData, ignitionVars map[string]string) (*conf.Conf, error) {
	if userdata == nil {
		userdata = conf.Ignition(`{"ignition": {"version": "2.0.0"}}`)
	}

	// hacky solution for unified ignition metadata variables
	if userdata.IsIgnitionCompatible() {
		for k, v := range ignitionVars {
			userdata = userdata.Subst(k, v)
		}
	}

	conf, err := userdata.Render(bc.ctPlatform)
	if err != nil {
		return nil, err
	}

	for _, dropin := range bc.baseopts.SystemdDropins {
		conf.AddSystemdUnitDropin(dropin.Unit, dropin.Name, dropin.Contents)
	}

	if !bc.rconf.NoSSHKeyInUserData {
		keys, err := bc.Keys()
		if err != nil {
			return nil, err
		}

		conf.CopyKeys(keys)
	}

	return conf, nil
}

// Destroy destroys each machine in the cluster and closes the SSH agent.
func (bc *BaseCluster) Destroy() {

	for _, m := range bc.Machines() {
		m.Destroy()
	}

	if err := bc.agent.Close(); err != nil {
		plog.Errorf("Error closing agent: %v", err)
	}
}

// XXX(mischief): i don't really think this belongs here, but it completes the
// interface we've established.
func (bc *BaseCluster) GetDiscoveryURL(size int) (string, error) {
	var result string
	err := util.Retry(3, 5*time.Second, func() error {
		resp, err := http.Get(fmt.Sprintf("https://discovery.etcd.io/new?size=%d", size))
		if err != nil {
			return err
		}
		defer resp.Body.Close()
		if resp.StatusCode != 200 {
			return fmt.Errorf("Discovery service returned %q", resp.Status)
		}

		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return err
		}
		result = string(body)
		return nil
	})
	return result, err
}

func (bc *BaseCluster) Platform() Name {
	return bc.platform
}

func (bc *BaseCluster) Name() string {
	return bc.name
}

func (bc *BaseCluster) RuntimeConf() RuntimeConfig {
	return *bc.rconf
}

func (bc *BaseCluster) ConsoleOutput() map[string]string {
	ret := map[string]string{}
	bc.machlock.Lock()
	defer bc.machlock.Unlock()
	for k, v := range bc.consolemap {
		ret[k] = v
	}
	return ret
}


text:
<?php
include("lib/inc/chartphp_dist.php");
$freespace = disk_free_space("E:");
$totalspace = disk_total_space("E:");
$usedspace = $totalspace - $freespace;

$p = new chartphp();

$p->data = array(array(array('Free space',$freespace),array('Used space', $usedspace)));
$p->chart_type = "pie";

// Common Options
$p->title = "Pie Chart";

$out = $p->render('c2');

?>

<!DOCTYPE html>

    <link href="css/bootstrap.min.css" rel="stylesheet">
    <link href="css/style.css" rel="stylesheet">

    <link rel="stylesheet" href="lib/js/chartphp.css">

					Online Hotel Reservation Management System - Admin portal

Account Management

System Management

Issue Response

Message Portal

                <?php echo $out; ?>


text:
require_dependency "renalware/virology"

module Renalware
  module Virology
    class Version < PaperTrail::Version
      self.table_name = :virology_versions
    end
  end
end


text:
// Copyright (c) 2012-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include "wallet/wallet.h"

#include <set>
#include <stdint.h>
#include <utility>
#include <vector>

#include "consensus/validation.h"
#include "rpc/server.h"
#include "test/test_bitcoin.h"
#include "validation.h"
#include "wallet/coincontrol.h"
#include "wallet/test/wallet_test_fixture.h"

#include <boost/test/unit_test.hpp>
#include <univalue.h>

extern CWallet* pwalletMain;

extern UniValue importmulti(const JSONRPCRequest& request);
extern UniValue dumpwallet(const JSONRPCRequest& request);
extern UniValue importwallet(const JSONRPCRequest& request);

// how many times to run all the tests to have a chance to catch errors that only show up with particular random shuffles
#define RUN_TESTS 100

// some tests fail 1% of the time due to bad luck.
// we repeat those tests this many times and only complain if all iterations of the test fail
#define RANDOM_REPEATS 5

std::vector<std::unique_ptr<CWalletTx>> wtxn;

typedef std::set<CInputCoin> CoinSet;

BOOST_FIXTURE_TEST_SUITE(wallet_tests, WalletTestingSetup)

static const CWallet testWallet;
static std::vector<COutput> vCoins;

static void add_coin(const CAmount& nValue, int nAge = 6*24, bool fIsFromMe = false, int nInput=0)
{
    static int nextLockTime = 0;
    CMutableTransaction tx;
    tx.nLockTime = nextLockTime++;        // so all transactions get different hashes
    tx.vout.resize(nInput+1);
    tx.vout[nInput].nValue = nValue;
    if (fIsFromMe) {
        // IsFromMe() returns (GetDebit() > 0), and GetDebit() is 0 if vin.empty(),
        // so stop vin being empty, and cache a non-zero Debit to fake out IsFromMe()
        tx.vin.resize(1);
    }
    std::unique_ptr<CWalletTx> wtx(new CWalletTx(&testWallet, MakeTransactionRef(std::move(tx))));
    if (fIsFromMe)
    {
        wtx->fDebitCached = true;
        wtx->nDebitCached = 1;
    }
    COutput output(wtx.get(), nInput, nAge, true /* spendable */, true /* solvable */, true /* safe */);
    vCoins.push_back(output);
    wtxn.emplace_back(std::move(wtx));
}

static void empty_wallet(void)
{
    vCoins.clear();
    wtxn.clear();
}

static bool equal_sets(CoinSet a, CoinSet b)
{
    std::pair<CoinSet::iterator, CoinSet::iterator> ret = mismatch(a.begin(), a.end(), b.begin());
    return ret.first == a.end() && ret.second == b.end();
}

BOOST_AUTO_TEST_CASE(coin_selection_tests)
{
    CoinSet setCoinsRet, setCoinsRet2;
    CAmount nValueRet;

    LOCK(testWallet.cs_wallet);

    // test multiple times to allow for differences in the shuffle order
    for (int i = 0; i < RUN_TESTS; i++)
    {
        empty_wallet();

        // with an empty wallet we can't even pay one cent
        BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, 1, 6, 0, vCoins, setCoinsRet, nValueRet));

        add_coin(1*CENT, 4);        // add a new 1 cent coin

        // with a new 1 cent coin, we still can't find a mature 1 cent
        BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, 1, 6, 0, vCoins, setCoinsRet, nValueRet));

        // but we can find a new 1 cent
        BOOST_CHECK( testWallet.SelectCoinsMinConf( 1 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);

        add_coin(2*CENT);           // add a mature 2 cent coin

        // we can't make 3 cents of mature coins
        BOOST_CHECK(!testWallet.SelectCoinsMinConf( 3 * CENT, 1, 6, 0, vCoins, setCoinsRet, nValueRet));

        // we can make 3 cents of new  coins
        BOOST_CHECK( testWallet.SelectCoinsMinConf( 3 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 3 * CENT);

        add_coin(5*CENT);           // add a mature 5 cent coin,
        add_coin(10*CENT, 3, true); // a new 10 cent coin sent from one of our own addresses
        add_coin(20*CENT);          // and a mature 20 cent coin

        // now we have new: 1+10=11 (of which 10 was self-sent), and mature: 2+5+20=27.  total = 38

        // we can't make 38 cents only if we disallow new coins:
        BOOST_CHECK(!testWallet.SelectCoinsMinConf(38 * CENT, 1, 6, 0, vCoins, setCoinsRet, nValueRet));
        // we can't even make 37 cents if we don't allow new coins even if they're from us
        BOOST_CHECK(!testWallet.SelectCoinsMinConf(38 * CENT, 6, 6, 0, vCoins, setCoinsRet, nValueRet));
        // but we can make 37 cents if we accept new coins from ourself
        BOOST_CHECK( testWallet.SelectCoinsMinConf(37 * CENT, 1, 6, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 37 * CENT);
        // and we can make 38 cents if we accept all new coins
        BOOST_CHECK( testWallet.SelectCoinsMinConf(38 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 38 * CENT);

        // try making 34 cents from 1,2,5,10,20 - we can't do it exactly
        BOOST_CHECK( testWallet.SelectCoinsMinConf(34 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 35 * CENT);       // but 35 cents is closest
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);     // the best should be 20+10+5.  it's incredibly unlikely the 1 or 2 got included (but possible)

        // when we try making 7 cents, the smaller coins (1,2,5) are enough.  We should see just 2+5
        BOOST_CHECK( testWallet.SelectCoinsMinConf( 7 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 7 * CENT);
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);

        // when we try making 8 cents, the smaller coins (1,2,5) are exactly enough.
        BOOST_CHECK( testWallet.SelectCoinsMinConf( 8 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK(nValueRet == 8 * CENT);
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);

        // when we try making 9 cents, no subset of smaller coins is enough, and we get the next bigger coin (10)
        BOOST_CHECK( testWallet.SelectCoinsMinConf( 9 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 10 * CENT);
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);

        // now clear out the wallet and start again to test choosing between subsets of smaller coins and the next biggest coin
        empty_wallet();

        add_coin( 6*CENT);
        add_coin( 7*CENT);
        add_coin( 8*CENT);
        add_coin(20*CENT);
        add_coin(30*CENT); // now we have 6+7+8+20+30 = 71 cents total

        // check that we have 71 and not 72
        BOOST_CHECK( testWallet.SelectCoinsMinConf(71 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK(!testWallet.SelectCoinsMinConf(72 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));

        // now try making 16 cents.  the best smaller coins can do is 6+7+8 = 21; not as good at the next biggest coin, 20
        BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 20 * CENT); // we should get 20 in one coin
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);

        add_coin( 5*CENT); // now we have 5+6+7+8+20+30 = 75 cents total

        // now if we try making 16 cents again, the smaller coins can make 5+6+7 = 18 cents, better than the next biggest coin, 20
        BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 18 * CENT); // we should get 18 in 3 coins
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);

        add_coin( 18*CENT); // now we have 5+6+7+8+18+20+30

        // and now if we try making 16 cents again, the smaller coins can make 5+6+7 = 18 cents, the same as the next biggest coin, 18
        BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);  // we should get 18 in 1 coin
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U); // because in the event of a tie, the biggest coin wins

        // now try making 11 cents.  we should get 5+6
        BOOST_CHECK( testWallet.SelectCoinsMinConf(11 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 11 * CENT);
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);

        // check that the smallest bigger coin is used
        add_coin( 1*COIN);
        add_coin( 2*COIN);
        add_coin( 3*COIN);
        add_coin( 4*COIN); // now we have 5+6+7+8+18+20+30+100+200+300+400 = 1094 cents
        BOOST_CHECK( testWallet.SelectCoinsMinConf(95 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 1 * COIN);  // we should get 1 BTC in 1 coin
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);

        BOOST_CHECK( testWallet.SelectCoinsMinConf(195 * CENT, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 2 * COIN);  // we should get 2 BTC in 1 coin
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);

        // empty the wallet and start again, now with fractions of a cent, to test small change avoidance

        empty_wallet();
        add_coin(MIN_CHANGE * 1 / 10);
        add_coin(MIN_CHANGE * 2 / 10);
        add_coin(MIN_CHANGE * 3 / 10);
        add_coin(MIN_CHANGE * 4 / 10);
        add_coin(MIN_CHANGE * 5 / 10);

        // try making 1 * MIN_CHANGE from the 1.5 * MIN_CHANGE
        // we'll get change smaller than MIN_CHANGE whatever happens, so can expect MIN_CHANGE exactly
        BOOST_CHECK( testWallet.SelectCoinsMinConf(MIN_CHANGE, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);

        // but if we add a bigger coin, small change is avoided
        add_coin(1111*MIN_CHANGE);

        // try making 1 from 0.1 + 0.2 + 0.3 + 0.4 + 0.5 + 1111 = 1112.5
        BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE); // we should get the exact amount

        // if we add more small coins:
        add_coin(MIN_CHANGE * 6 / 10);
        add_coin(MIN_CHANGE * 7 / 10);

        // and try again to make 1.0 * MIN_CHANGE
        BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE); // we should get the exact amount

        // run the 'mtgox' test (see http://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf)
        // they tried to consolidate 10 50k coins into one 500k coin, and ended up with 50k in change
        empty_wallet();
        for (int j = 0; j < 20; j++)
            add_coin(50000 * COIN);

        BOOST_CHECK( testWallet.SelectCoinsMinConf(500000 * COIN, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 500000 * COIN); // we should get the exact amount
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 10U); // in ten coins

        // if there's not enough in the smaller coins to make at least 1 * MIN_CHANGE change (0.5+0.6+0.7 < 1.0+1.0),
        // we need to try finding an exact subset anyway

        // sometimes it will fail, and so we use the next biggest coin:
        empty_wallet();
        add_coin(MIN_CHANGE * 5 / 10);
        add_coin(MIN_CHANGE * 6 / 10);
        add_coin(MIN_CHANGE * 7 / 10);
        add_coin(1111 * MIN_CHANGE);
        BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 1111 * MIN_CHANGE); // we get the bigger coin
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);

        // but sometimes it's possible, and we use an exact subset (0.4 + 0.6 = 1.0)
        empty_wallet();
        add_coin(MIN_CHANGE * 4 / 10);
        add_coin(MIN_CHANGE * 6 / 10);
        add_coin(MIN_CHANGE * 8 / 10);
        add_coin(1111 * MIN_CHANGE);
        BOOST_CHECK( testWallet.SelectCoinsMinConf(MIN_CHANGE, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);   // we should get the exact amount
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U); // in two coins 0.4+0.6

        // test avoiding small change
        empty_wallet();
        add_coin(MIN_CHANGE * 5 / 100);
        add_coin(MIN_CHANGE * 1);
        add_coin(MIN_CHANGE * 100);

        // trying to make 100.01 from these three coins
        BOOST_CHECK(testWallet.SelectCoinsMinConf(MIN_CHANGE * 10001 / 100, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE * 10105 / 100); // we should get all coins
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);

        // but if we try to make 99.9, we should take the bigger of the two small coins to avoid small change
        BOOST_CHECK(testWallet.SelectCoinsMinConf(MIN_CHANGE * 9990 / 100, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
        BOOST_CHECK_EQUAL(nValueRet, 101 * MIN_CHANGE);
        BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);

        // test with many inputs
        for (CAmount amt=1500; amt < COIN; amt*=10) {
             empty_wallet();
             // Create 676 inputs (=  (old MAX_STANDARD_TX_SIZE == 100000)  / 148 bytes per input)
             for (uint16_t j = 0; j < 676; j++)
                 add_coin(amt);
             BOOST_CHECK(testWallet.SelectCoinsMinConf(2000, 1, 1, 0, vCoins, setCoinsRet, nValueRet));
             if (amt - 2000 < MIN_CHANGE) {
                 // needs more than one input:
                 uint16_t returnSize = std::ceil((2000.0 + MIN_CHANGE)/amt);
                 CAmount returnValue = amt * returnSize;
                 BOOST_CHECK_EQUAL(nValueRet, returnValue);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), returnSize);
             } else {
                 // one input is sufficient:
                 BOOST_CHECK_EQUAL(nValueRet, amt);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
             }
        }

        // test randomness
        {
            empty_wallet();
            for (int i2 = 0; i2 < 100; i2++)
                add_coin(COIN);

            // picking 50 from 100 coins doesn't depend on the shuffle,
            // but does depend on randomness in the stochastic approximation code
            BOOST_CHECK(testWallet.SelectCoinsMinConf(50 * COIN, 1, 6, 0, vCoins, setCoinsRet , nValueRet));
            BOOST_CHECK(testWallet.SelectCoinsMinConf(50 * COIN, 1, 6, 0, vCoins, setCoinsRet2, nValueRet));
            BOOST_CHECK(!equal_sets(setCoinsRet, setCoinsRet2));

            int fails = 0;
            for (int j = 0; j < RANDOM_REPEATS; j++)
            {
                // selecting 1 from 100 identical coins depends on the shuffle; this test will fail 1% of the time
                // run the test RANDOM_REPEATS times and only complain if all of them fail
                BOOST_CHECK(testWallet.SelectCoinsMinConf(COIN, 1, 6, 0, vCoins, setCoinsRet , nValueRet));
                BOOST_CHECK(testWallet.SelectCoinsMinConf(COIN, 1, 6, 0, vCoins, setCoinsRet2, nValueRet));
                if (equal_sets(setCoinsRet, setCoinsRet2))
                    fails++;
            }
            BOOST_CHECK_NE(fails, RANDOM_REPEATS);

            // add 75 cents in small change.  not enough to make 90 cents,
            // then try making 90 cents.  there are multiple competing "smallest bigger" coins,
            // one of which should be picked at random
            add_coin(5 * CENT);
            add_coin(10 * CENT);
            add_coin(15 * CENT);
            add_coin(20 * CENT);
            add_coin(25 * CENT);

            fails = 0;
            for (int j = 0; j < RANDOM_REPEATS; j++)
            {
                // selecting 1 from 100 identical coins depends on the shuffle; this test will fail 1% of the time
                // run the test RANDOM_REPEATS times and only complain if all of them fail
                BOOST_CHECK(testWallet.SelectCoinsMinConf(90*CENT, 1, 6, 0, vCoins, setCoinsRet , nValueRet));
                BOOST_CHECK(testWallet.SelectCoinsMinConf(90*CENT, 1, 6, 0, vCoins, setCoinsRet2, nValueRet));
                if (equal_sets(setCoinsRet, setCoinsRet2))
                    fails++;
            }
            BOOST_CHECK_NE(fails, RANDOM_REPEATS);
        }
    }
    empty_wallet();
}

BOOST_AUTO_TEST_CASE(ApproximateBestSubset)
{
    CoinSet setCoinsRet;
    CAmount nValueRet;

    LOCK(testWallet.cs_wallet);

    empty_wallet();

    // Test vValue sort order
    for (int i = 0; i < 1000; i++)
        add_coin(1000 * COIN);
    add_coin(3 * COIN);

    BOOST_CHECK(testWallet.SelectCoinsMinConf(1003 * COIN, 1, 6, 0, vCoins, setCoinsRet, nValueRet));
    BOOST_CHECK_EQUAL(nValueRet, 1003 * COIN);
    BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);

    empty_wallet();
}

static void AddKey(CWallet& wallet, const CKey& key)
{
    LOCK(wallet.cs_wallet);
    wallet.AddKeyPubKey(key, key.GetPubKey());
}

BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
{
    LOCK(cs_main);

    // Cap last block file size, and mine new block in a new block file.
    CBlockIndex* const nullBlock = nullptr;
    CBlockIndex* oldTip = chainActive.Tip();
    GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
    CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
    CBlockIndex* newTip = chainActive.Tip();

    // Verify ScanForWalletTransactions picks up transactions in both the old
    // and new block files.
    {
        CWallet wallet;
        AddKey(wallet, coinbaseKey);
        BOOST_CHECK_EQUAL(nullBlock, wallet.ScanForWalletTransactions(oldTip));
        BOOST_CHECK_EQUAL(wallet.GetImmatureBalance(), 100 * COIN);
    }

    // Prune the older block file.
    PruneOneBlockFile(oldTip->GetBlockPos().nFile);
    UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});

    // Verify ScanForWalletTransactions only picks transactions in the new block
    // file.
    {
        CWallet wallet;
        AddKey(wallet, coinbaseKey);
        BOOST_CHECK_EQUAL(oldTip, wallet.ScanForWalletTransactions(oldTip));
        BOOST_CHECK_EQUAL(wallet.GetImmatureBalance(), 50 * COIN);
    }

    // Verify importmulti RPC returns failure for a key whose creation time is
    // before the missing block, and success for a key whose creation time is
    // after.
    {
        CWallet wallet;
        vpwallets.insert(vpwallets.begin(), &wallet);
        UniValue keys;
        keys.setArray();
        UniValue key;
        key.setObject();
        key.pushKV("scriptPubKey", HexStr(GetScriptForRawPubKey(coinbaseKey.GetPubKey())));
        key.pushKV("timestamp", 0);
        key.pushKV("internal", UniValue(true));
        keys.push_back(key);
        key.clear();
        key.setObject();
        CKey futureKey;
        futureKey.MakeNewKey(true);
        key.pushKV("scriptPubKey", HexStr(GetScriptForRawPubKey(futureKey.GetPubKey())));
        key.pushKV("timestamp", newTip->GetBlockTimeMax() + TIMESTAMP_WINDOW + 1);
        key.pushKV("internal", UniValue(true));
        keys.push_back(key);
        JSONRPCRequest request;
        request.params.setArray();
        request.params.push_back(keys);

        UniValue response = importmulti(request);
        BOOST_CHECK_EQUAL(response.write(),
            strprintf("[{\"success\":false,\"error\":{\"code\":-1,\"message\":\"Rescan failed for key with creation "
                      "timestamp %d. There was an error reading a block from time %d, which is after or within %d "
                      "seconds of key creation, and could contain transactions pertaining to the key. As a result, "
                      "transactions and coins using this key may not appear in the wallet. This error could be caused "
                      "by pruning or data corruption (see litecoind log for details) and could be dealt with by "
                      "downloading and rescanning the relevant blocks (see -reindex and -rescan "
                      "options).\"}},{\"success\":true}]",
                              0, oldTip->GetBlockTimeMax(), TIMESTAMP_WINDOW));
        vpwallets.erase(vpwallets.begin());
    }
}

// Verify importwallet RPC starts rescan at earliest block with timestamp
// greater or equal than key birthday. Previously there was a bug where
// importwallet RPC would start the scan at the latest block with timestamp less
// than or equal to key birthday.
BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
{
    LOCK(cs_main);

    // Create two blocks with same timestamp to verify that importwallet rescan
    // will pick up both blocks, not just the first.
    const int64_t BLOCK_TIME = chainActive.Tip()->GetBlockTimeMax() + 5;
    SetMockTime(BLOCK_TIME);
    coinbaseTxns.emplace_back(*CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
    coinbaseTxns.emplace_back(*CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);

    // Set key birthday to block time increased by the timestamp window, so
    // rescan will start at the block time.
    const int64_t KEY_TIME = BLOCK_TIME + TIMESTAMP_WINDOW;
    SetMockTime(KEY_TIME);
    coinbaseTxns.emplace_back(*CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);

    // Import key into wallet and call dumpwallet to create backup file.
    {
        CWallet wallet;
        LOCK(wallet.cs_wallet);
        wallet.mapKeyMetadata[coinbaseKey.GetPubKey().GetID()].nCreateTime = KEY_TIME;
        wallet.AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());

        JSONRPCRequest request;
        request.params.setArray();
        request.params.push_back((pathTemp / "wallet.backup").string());
        vpwallets.insert(vpwallets.begin(), &wallet);
        ::dumpwallet(request);
    }

    // Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME
    // were scanned, and no prior blocks were scanned.
    {
        CWallet wallet;

        JSONRPCRequest request;
        request.params.setArray();
        request.params.push_back((pathTemp / "wallet.backup").string());
        vpwallets[0] = &wallet;
        ::importwallet(request);

        BOOST_CHECK_EQUAL(wallet.mapWallet.size(), 3);
        BOOST_CHECK_EQUAL(coinbaseTxns.size(), 103);
        for (size_t i = 0; i < coinbaseTxns.size(); ++i) {
            bool found = wallet.GetWalletTx(coinbaseTxns[i].GetHash());
            bool expected = i >= 100;
            BOOST_CHECK_EQUAL(found, expected);
        }
    }

    SetMockTime(0);
    vpwallets.erase(vpwallets.begin());
}

// Check that GetImmatureCredit() returns a newly calculated value instead of
// the cached value after a MarkDirty() call.
//
// This is a regression test written to verify a bugfix for the immature credit
// function. Similar tests probably should be written for the other credit and
// debit functions.
BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
{
    CWallet wallet;
    CWalletTx wtx(&wallet, MakeTransactionRef(coinbaseTxns.back()));
    LOCK2(cs_main, wallet.cs_wallet);
    wtx.hashBlock = chainActive.Tip()->GetBlockHash();
    wtx.nIndex = 0;

    // Call GetImmatureCredit() once before adding the key to the wallet to
    // cache the current immature credit amount, which is 0.
    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), 0);

    // Invalidate the cached value, add the key, and make sure a new immature
    // credit amount is calculated.
    wtx.MarkDirty();
    wallet.AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), 50*COIN);
}

static int64_t AddTx(CWallet& wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime)
{
    CMutableTransaction tx;
    tx.nLockTime = lockTime;
    SetMockTime(mockTime);
    CBlockIndex* block = nullptr;
    if (blockTime > 0) {
        auto inserted = mapBlockIndex.emplace(GetRandHash(), new CBlockIndex);
        assert(inserted.second);
        const uint256& hash = inserted.first->first;
        block = inserted.first->second;
        block->nTime = blockTime;
        block->phashBlock = &hash;
    }

    CWalletTx wtx(&wallet, MakeTransactionRef(tx));
    if (block) {
        wtx.SetMerkleBranch(block, 0);
    }
    wallet.AddToWallet(wtx);
    return wallet.mapWallet.at(wtx.GetHash()).nTimeSmart;
}

// Simple test to verify assignment of CWalletTx::nSmartTime value. Could be
// expanded to cover more corner cases of smart time logic.
BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
{
    CWallet wallet;

    // New transaction should use clock time if lower than block time.
    BOOST_CHECK_EQUAL(AddTx(wallet, 1, 100, 120), 100);

    // Test that updating existing transaction does not change smart time.
    BOOST_CHECK_EQUAL(AddTx(wallet, 1, 200, 220), 100);

    // New transaction should use clock time if there's no block time.
    BOOST_CHECK_EQUAL(AddTx(wallet, 2, 300, 0), 300);

    // New transaction should use block time if lower than clock time.
    BOOST_CHECK_EQUAL(AddTx(wallet, 3, 420, 400), 400);

    // New transaction should use latest entry time if higher than
    // min(block time, clock time).
    BOOST_CHECK_EQUAL(AddTx(wallet, 4, 500, 390), 400);

    // If there are future entries, new transaction should use time of the
    // newest entry that is no more than 300 seconds ahead of the clock time.
    BOOST_CHECK_EQUAL(AddTx(wallet, 5, 50, 600), 300);

    // Reset mock time for other tests.
    SetMockTime(0);
}

BOOST_AUTO_TEST_CASE(LoadReceiveRequests)
{
    CTxDestination dest = CKeyID();
    pwalletMain->AddDestData(dest, "misc", "val_misc");
    pwalletMain->AddDestData(dest, "rr0", "val_rr0");
    pwalletMain->AddDestData(dest, "rr1", "val_rr1");

    auto values = pwalletMain->GetDestValues("rr");
    BOOST_CHECK_EQUAL(values.size(), 2);
    BOOST_CHECK_EQUAL(values[0], "val_rr0");
    BOOST_CHECK_EQUAL(values[1], "val_rr1");
}

class ListCoinsTestingSetup : public TestChain100Setup
{
public:
    ListCoinsTestingSetup()
    {
        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
        ::bitdb.MakeMock();
        wallet.reset(new CWallet(std::unique_ptr<CWalletDBWrapper>(new CWalletDBWrapper(&bitdb, "wallet_test.dat"))));
        bool firstRun;
        wallet->LoadWallet(firstRun);
        AddKey(*wallet, coinbaseKey);
        wallet->ScanForWalletTransactions(chainActive.Genesis());
    }

    ~ListCoinsTestingSetup()
    {
        wallet.reset();
        ::bitdb.Flush(true);
        ::bitdb.Reset();
    }

    CWalletTx& AddTx(CRecipient recipient)
    {
        CWalletTx wtx;
        CReserveKey reservekey(wallet.get());
        CAmount fee;
        int changePos = -1;
        std::string error;
        CCoinControl dummy;
        BOOST_CHECK(wallet->CreateTransaction({recipient}, wtx, reservekey, fee, changePos, error, dummy));
        CValidationState state;
        BOOST_CHECK(wallet->CommitTransaction(wtx, reservekey, nullptr, state));
        auto it = wallet->mapWallet.find(wtx.GetHash());
        BOOST_CHECK(it != wallet->mapWallet.end());
        CreateAndProcessBlock({CMutableTransaction(*it->second.tx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
        it->second.SetMerkleBranch(chainActive.Tip(), 1);
        return it->second;
    }

    std::unique_ptr<CWallet> wallet;
};

BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
{
    std::string coinbaseAddress = coinbaseKey.GetPubKey().GetID().ToString();
    LOCK2(cs_main, wallet->cs_wallet);

    // Confirm ListCoins initially returns 1 coin grouped under coinbaseKey
    // address.
    auto list = wallet->ListCoins();
    BOOST_CHECK_EQUAL(list.size(), 1);
    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
    BOOST_CHECK_EQUAL(list.begin()->second.size(), 1);

    // Check initial balance from one mature coinbase transaction.
    BOOST_CHECK_EQUAL(50 * COIN, wallet->GetAvailableBalance());

    // Add a transaction creating a change address, and confirm ListCoins still
    // returns the coin associated with the change address underneath the
    // coinbaseKey pubkey, even though the change address has a different
    // pubkey.
    AddTx(CRecipient{GetScriptForRawPubKey({}), 1 * COIN, false /* subtract fee */});
    list = wallet->ListCoins();
    BOOST_CHECK_EQUAL(list.size(), 1);
    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
    BOOST_CHECK_EQUAL(list.begin()->second.size(), 2);

    // Lock both coins. Confirm number of available coins drops to 0.
    std::vector<COutput> available;
    wallet->AvailableCoins(available);
    BOOST_CHECK_EQUAL(available.size(), 2);
    for (const auto& group : list) {
        for (const auto& coin : group.second) {
            wallet->LockCoin(COutPoint(coin.tx->GetHash(), coin.i));
        }
    }
    wallet->AvailableCoins(available);
    BOOST_CHECK_EQUAL(available.size(), 0);

    // Confirm ListCoins still returns same result as before, despite coins
    // being locked.
    list = wallet->ListCoins();
    BOOST_CHECK_EQUAL(list.size(), 1);
    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
    BOOST_CHECK_EQUAL(list.begin()->second.size(), 2);
}

BOOST_AUTO_TEST_SUITE_END()


text:
(function(angular) {
    'use strict';
    angular.module('scoreBoard')
        .controller('setMatchController', SetMatchController);

    SetMatchController.$inject = ['setMatchService', 'playGameService', '$stateParams'];

    function SetMatchController(setMatchService, playGameService, $stateParams) {
        var vm = this;

        vm.startGame = startGame;

        vm.countries = setMatchService.getCountries();
        vm.bowlingStatus = 'teamOne';

        function startGame() {
            var match = {
                bowling: vm.bowlingStatus == 'teamOne' ? vm.teamOne : vm.teamTwo,
                batting: vm.bowlingStatus == 'teamOne' ? vm.teamTwo : vm.teamOne
            };

            //existingMatchInfo = PlayGameService.getCurrentMatchInfo($stateParams.matchId),
            console.log(playGameService.existingMatchInfo);
            // if (PlayGameService.existingMatchInfo.matchResults) {
            //     PlayGameService.existingMatchInfo.matchResults = [];
            // }
            // matchResults = existingMatchInfo.matchResults ? existingMatchInfo.matchResults : [];
            // console.log(PlayGameService.existingMatchInfo);
            setMatchService.setMatch(match);
        }

    }
})(window.angular);


text:
package hipg.runtime;

import hipg.Config;
import ibis.ipl.ReadMessage;
import ibis.ipl.SendPort;
import ibis.ipl.WriteMessage;

import java.io.IOException;

import myutils.IOUtils;
import myutils.ipc.FastContigMessageQueue;

/**
 * Message (buffer of final integers) with no locking.
 *
 * @author ela, ekr@cs.vu.nl
 *
 */
public final class FastMessage extends FastContigMessageQueue {

	/* message opcodes */

	/** Opcode: synchronizer barrier. */
	public static final int GLOBAL_BARRIER = -1001;
	/** Opcode: announce synchronizer barrier. */
	public static final int GLOBAL_BARRIER_ANNOUNCE = -1002;
	/** Opcode: synchronizer barrier. */
	public static final int BARRIER = -1003;
	/** Opcode: announce synchronizer barrier. */
	public static final int BARRIER_ANNOUNCE = -1004;
	/** Opcode: synchronizer reduce. */
	public static final int REDUCE = -1005;
	/** Opcode: synchronizer reduce announce. */
	public static final int REDUCE_ANNOUNCE = -1006;
	/** Opcode: synchronizer barrier-reduce. */
	public static final int BARRED = -1007;
	/** Opcode: synchronizer barrier-reduce announce. */
	public static final int BARRED_QUERY = -1008;
	/** Opcode: synchronizer barrier-reduce query answer. */
	public static final int BARRED_ANSWER = -1009;
	/** Opcode: synchronizer barrier-reduce announce. */
	public static final int BARRED_ANNOUNCE = -1010;
	/** Opcode: synchronizer notification method. */
	public static final int NOTIFICATION = -1011;
	/** Opcode: synchronizer notification reception acknowledgment. */
	public static final int NOTIFICATION_ACK = -1012;
	/** Opcode: global abort. */
	public static final int ABORT = -1014;
	/** Opcode: id message. */
	public static final int ID = -1015;
	/** Opcode: child done. */
	public static final int CHDONE = -1016;
	/** Opcode: ambassador delete. */
	public static final int ADEL = -1017;
	/** Opcode: test. */
	public static final int TEST = -1018;

	/** Opcode: synchronizer spawn (new synchronizer). */
	public static final int SSPAWN = -2000;
	/** Opcode: ambassador spawn. */
	public static final int ASPAWN = -2001;

	/** Message destination. */
	private SendPort sp;

	/**
	 * Creates a new message (allocates buffer).
	 */
	public FastMessage(final int bufsize) {
		super(bufsize);
		for (int i = 0; i < buf.length; ++i) {
			buf[i] = 17;
		}
	}

	public void set(SendPort sp) {
		this.sp = sp;
	}

	void addGlobalBarrierToken(final int position, final int length, final int barrier, final int sum, final int master) {
		if (Config.STATISTICS) {
			Statistics.sendingGlobalBarrierMessage(length);
		}
		IOUtils.write4Ints(GLOBAL_BARRIER, barrier, sum, master, buf, position);
		assert (length == IOUtils.INT_BYTES * 4);
		commitWrite(position + length);
	}

	void addGlobalBarrierAnnounceToken(final int position, final int length) {
		if (Config.STATISTICS) {
			Statistics.sendingGlobalBarrierMessage(length);
		}
		IOUtils.writeInt(GLOBAL_BARRIER_ANNOUNCE, buf, position);
		assert (length == IOUtils.INT_BYTES);
		commitWrite(position + length);
	}

	void addBarrierToken(final int position, final int length, final Synchronizer synchronizer, final int barrier,
			final int sum, final int master) {
		if (Config.STATISTICS) {
			Statistics.sendingBarrierMessage(length);
		}
		IOUtils.write6Ints(BARRIER, synchronizer.getOwner(), synchronizer.getId(), barrier, sum, master, buf, position);
		assert (length == IOUtils.INT_BYTES * 6);
		commitWrite(position + length);
	}

	void addBarrierAnnounceToken(final int position, final int length, final int synchronizerOwner,
			final int synchronizerId) {
		if (Config.STATISTICS) {
			Statistics.sendingBarrierMessage(length);
		}
		IOUtils.write3Ints(BARRIER_ANNOUNCE, synchronizerOwner, synchronizerId, buf, position);
		assert (length == IOUtils.INT_BYTES * 3);
		commitWrite(position + length);
	}

	void addReduceToken(final int position, final int length, final int synchronizerOwner, final int synchronizerId,
			final int reduce, final short reduceMethodId, final byte[] result) {
		if (Config.STATISTICS) {
			Statistics.sendingReduceMessage(length);
		}
		IOUtils.write4Ints(REDUCE, synchronizerOwner, synchronizerId, reduce, buf, position);
		int tempPosition = position + IOUtils.INT_BYTES * 4;
		IOUtils.writeShort(reduceMethodId, buf, tempPosition);
		tempPosition += IOUtils.SHORT_BYTES;
		IOUtils.writeByteArray(result, buf, tempPosition);
		assert (length == 4 * IOUtils.INT_BYTES + IOUtils.SHORT_BYTES + IOUtils.bytesByteArray(result));
		commitWrite(position + length);
	}

	void addReduceAnnounceToken(final int position, final int length, final int synchronizerOwner,
			final int synchronizerId, final byte[] result, final int sender) {
		if (Config.STATISTICS) {
			Statistics.sendingReduceMessage(length);
		}
		IOUtils.write4Ints(REDUCE_ANNOUNCE, synchronizerOwner, synchronizerId, sender, buf, position);
		IOUtils.writeByteArray(result, buf, position + 4 * IOUtils.INT_BYTES);
		assert (length == 4 * IOUtils.INT_BYTES + IOUtils.bytesByteArray(result));
		commitWrite(position + length);
	}

	void addBarrierReduceToken(final int position, final int length, final int synchronizerOwner,
			final int synchronizerId, final int barrier, final int sum, final int master) {
		if (Config.STATISTICS) {
			Statistics.sendingBarrierReduceMessage(length);
		}
		IOUtils.write6Ints(BARRED, synchronizerOwner, synchronizerId, barrier, sum, master, buf, position);
		assert (length == 6 * IOUtils.INT_BYTES);
		commitWrite(position + length);
	}

	void addBarrierReduceQueryToken(final int position, final int length, final int synchronizerOwner,
			final int synchronizerId, byte[] result) {
		if (Config.STATISTICS) {
			Statistics.sendingBarrierReduceMessage(length);
		}
		IOUtils.write3Ints(BARRED_QUERY, synchronizerOwner, synchronizerId, buf, position);
		IOUtils.writeByteArray(result, buf, position + IOUtils.INT_BYTES * 3);
		assert (length == 3 * IOUtils.INT_BYTES + IOUtils.bytesByteArray(result));
		commitWrite(position + length);
	}

	void addBarrierReduceAnnounceToken(final int position, final int length, final Synchronizer synchronizer,
			final byte[] result) {
		if(Config.STATISTICS) {
		Statistics.sendingBarrierReduceMessage(length);
		}
		IOUtils.write3Ints(BARRED_ANNOUNCE, synchronizer.getOwner(), synchronizer.getId(), buf, position);
		IOUtils.writeByteArray(result, buf, position + IOUtils.INT_BYTES * 3);
		assert (length == IOUtils.INT_BYTES * 3 + IOUtils.bytesByteArray(result));
		commitWrite(position + length);
	}

	void addNotificationToken(final int position, final int length, final Synchronizer synchronizer,
			final short notificationMethodId, final byte[] result, final int id, final int issuer) {
		if (Config.STATISTICS) {
			Statistics.sendingNotificationMessage(length);
		}
		IOUtils.write5Ints(NOTIFICATION, synchronizer.getOwner(), synchronizer.getId(), id, issuer, buf, position);
		int tempPosition = position + IOUtils.INT_BYTES * 5;
		IOUtils.writeShort(notificationMethodId, buf, tempPosition);
		tempPosition += IOUtils.SHORT_BYTES;
		IOUtils.writeByteArray(result, buf, tempPosition);
		assert (length == IOUtils.INT_BYTES * 5 + IOUtils.SHORT_BYTES + IOUtils.bytesByteArray(result));
		commitWrite(position + length);
	}

	void addNotificationAckToken(final int position, final int length, final Synchronizer synchronizer, final int id) {
		if (Config.STATISTICS) {
			Statistics.sendingNotificationMessage(length);
		}
		IOUtils.write4Ints(NOTIFICATION_ACK, synchronizer.getOwner(), synchronizer.getId(), id, buf, position);
		assert (length == 4 * IOUtils.INT_BYTES);
		commitWrite(position + length);
	}

	void addChildDoneMessage(final int position, final int length, final int synchronizerId) {
		if (Config.STATISTICS) {
			Statistics.sendingChildDoneMessage(length);
		}
		IOUtils.write2Ints(CHDONE, synchronizerId, buf, position);
		assert (length == 2 * IOUtils.INT_BYTES);
		commitWrite(position + length);
	}

	void addRemoveAmbassadorMessage(final int position, final int length, final Synchronizer synchronizer) {
		if (Config.STATISTICS) {
			Statistics.sendingRemoveAmbassadorMessage(length);
		}
		IOUtils.write3Ints(ADEL, synchronizer.getOwner(), synchronizer.getId(), buf, position);
		assert (length == 3 * IOUtils.INT_BYTES);
		commitWrite(position + length);
	}

	void addSynchronizerSpawnMessage(final Synchronizer synchronizer) {
		throw new RuntimeException("Sending objects not implemented!");
		// final int paramsPosition = paramAppend;
		// params[paramsPosition++] = SSPAWN;
		// params[paramsPosition++] = synchronizer;
		// commitParams(paramsPosition);
		// if (Config.COARSETIMING)
		// controlMessagesCount++;
	}

	void addAmbassadorSpawnMessage(final Synchronizer synchronizer) {
		throw new RuntimeException("Sending objects not implemented!");
		// final int paramsPosition = paramAppend;
		// params[paramsPosition++] = ASPAWN;
		// params[paramsPosition++] = synchronizer;
		// commitParams(paramsPosition);
		// if (Config.COARSETIMING)
		// controlMessagesCount++;
	}

	void addIdMessage(final int position, final int length, final int fatherId, final int fatherOwner,
			final int spawns, final int id) {
		if (Config.STATISTICS) {
			Statistics.sendingIdMessage(length);
		}
		IOUtils.write5Ints(ID, fatherId, fatherOwner, spawns, id, buf, position);
		assert (length == 5 * IOUtils.INT_BYTES);
		commitWrite(position + length);
	}

	void addTestMessage(final int position, final int length, final String msg) {
		if (Config.STATISTICS) {
			Statistics.sendingTestMessage(length);
		}
		IOUtils.writeInt(TEST, buf, position);
		IOUtils.writeString(msg, buf, position + IOUtils.INT_BYTES);
		assert (length == IOUtils.INT_BYTES + IOUtils.bytesString(msg));
		commitWrite(position + length);
	}

	void addAbortMessage(final int position, final int length, final int issuer, final String msg) {
		if (Config.STATISTICS) {
			Statistics.sendingAbortMessage(length);
		}
		IOUtils.write2Ints(ABORT, issuer, buf, position);
		IOUtils.writeString(msg, buf, position + IOUtils.INT_BYTES * 2);
		assert (length == IOUtils.INT_BYTES * 2 + IOUtils.bytesString(msg));
		commitWrite(position + length);
	}

	void flush() throws IOException {
		while (sizeInReader() > 0) {
			final int size = availableContigRead();
			if (size > 0) {
				if (Config.STATISTICS) {
					Statistics.startingFlush(size);
				}
				final int start = startContigRead();
				final WriteMessage message = sp.newMessage();
				message.writeInt(size);
				message.writeArray(buf, start, size);
				final long bytes = message.finish();
				commitRead(start + size);
				if (Config.STATISTICS) {
					Statistics.flushDone(bytes);
				}
			}
		}
	}

	public void append(final int position, final int addSize, ReadMessage readMessage) throws IOException,
			ClassNotFoundException {
		readMessage.readArray(buf, position, addSize);
		commitWrite(position + addSize);
	}
}


text:
layout: default
---

{{ site.title }} > {{ page.title }}

{{ page.title }}

{{ page.description }}

{{ content }}


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

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>EditorSceneController</title>
<meta name="date" content="2016-05-23">
<link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

controller

Class EditorSceneController

java.lang.Object

controller.EditorSceneController

public class EditorSceneController
extends java.lang.Object

Created by SH on 2016-05-11.

Field Summary

Fields

Modifier and Type
Field and Description

private javafx.scene.control.Button
btnCompare

private javafx.scene.control.Button
btnFileOpen

private javafx.scene.control.Button
btnFileSave

private javafx.scene.control.Button
btnMergeLeft

private javafx.scene.control.Button
btnMergeRight

private HighlightEditorInterface
editor

private javafx.scene.control.Label
filePath

Constructor Summary

Constructors

Constructor and Description

EditorSceneController()

Method Summary

All Methods Instance Methods Concrete Methods

Modifier and Type
Method and Description

private void
_getBtnsReference()

private void
initialize()

private void
onTBBtnEditClicked(javafx.event.ActionEvent event)

private void
onTBBtnLoadClicked(javafx.event.ActionEvent event)

private void
onTBBtnSaveClicked(javafx.event.ActionEvent event)

private void
onTextAreaKeyPressed(javafx.scene.input.KeyEvent event)

void
useSaveActionMethod()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

editor

private HighlightEditorInterface editor

btnFileSave

private javafx.scene.control.Button btnFileSave

btnFileOpen

private javafx.scene.control.Button btnFileOpen

filePath

private javafx.scene.control.Label filePath

btnCompare

private javafx.scene.control.Button btnCompare

btnMergeLeft

private javafx.scene.control.Button btnMergeLeft

btnMergeRight

private javafx.scene.control.Button btnMergeRight

Constructor Detail

EditorSceneController

public EditorSceneController()

Method Detail

initialize

private void initialize()

_getBtnsReference

private void _getBtnsReference()

onTextAreaKeyPressed

private void onTextAreaKeyPressed(javafx.scene.input.KeyEvent event)

onTBBtnLoadClicked

private void onTBBtnLoadClicked(javafx.event.ActionEvent event)

onTBBtnSaveClicked

private void onTBBtnSaveClicked(javafx.event.ActionEvent event)
                         throws java.io.IOException

Throws:

java.io.IOException

onTBBtnEditClicked

private void onTBBtnEditClicked(javafx.event.ActionEvent event)

useSaveActionMethod

public void useSaveActionMethod()
                         throws java.io.IOException

Throws:

java.io.IOException

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
import {Renderer, RendererView} from "./renderer"
import * as p from "core/properties"

export abstract class GuideRendererView extends RendererView {
  model: GuideRenderer
  visuals: GuideRenderer.Visuals
}

export namespace GuideRenderer {
  export type Attrs = p.AttrsOf<Props>

  export type Props = Renderer.Props

  export type Visuals = Renderer.Visuals
}

export interface GuideRenderer extends GuideRenderer.Attrs {}

export abstract class GuideRenderer extends Renderer {
  properties: GuideRenderer.Props

  constructor(attrs?: Partial<GuideRenderer.Attrs>) {
    super(attrs)
  }

  static initClass(): void {
    this.override({
      level: "overlay",
    })
  }
}
GuideRenderer.initClass()


text:
import argparse

import chainer
from chainer import functions as F
from chainer import links as L
from chainer import optimizers as O
from chainer import cuda
import numpy
import six

from deepmark_chainer import net
from deepmark_chainer.utils import timer
from deepmark_chainer.utils import cache

parser = argparse.ArgumentParser(description='Deepmark benchmark for text data.')
parser.add_argument('--predictor', '-p', type=str, default='big-lstm',
                    choices=('small-lstm', 'big-lstm'),
                    help='Network architecture')
parser.add_argument('--seed', '-s', type=int, default=0,
                    help='Random seed')
parser.add_argument('--iteration', '-i', type=int, default=10,
                    help='The number of iteration to be averaged over.')
parser.add_argument('--seq-length', '-t', type=int, default=200,
                    help='Sequence length')
parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU to use. Negative value to use CPU')
parser.add_argument('--cudnn', '-c', action='store_true', help='If this flag is set, cuDNN is enabled.')
parser.add_argument('--cache-level', '-C', type=str, default='none',
                    choices=('none', 'memory', 'disk'),
                    help='This option determines the type of the kernel cache used.'
                    'By default, memory cache and disk cache are removed '
                    'at the beginning of every iteration. '
                    'Otherwise, elapsed times of each iteration are '
                    'measured with corresponding cache enabled. '
                    'If either cache is enabled, this script operates one additional '
                    'iteration for burn-in before measurement. '
                    'This iteration is not included in the mean elapsed time.'
                    'If we do not use GPU, we do not clear cache at all regardless of the value of '
                    'this option.')
parser.add_argument('--batchsize', '-b', type=int, default=50, help='Batchsize')
args = parser.parse_args()

numpy.random.seed(args.seed)
if args.gpu >= 0:
    cuda.cupy.random.seed(args.seed)

vocab_size = 10

if args.predictor == 'small-lstm':
    predictor = net.small_lstm.SmallLSTM(vocab_size)
elif args.predictor == 'big-lstm':
    predictor = net.big_lstm.BigLSTM(vocab_size)
else:
    raise ValueError('Invalid architector:{}'.format(args.predictor))
model = L.Classifier(predictor)
model.compute_accuracy = False

if args.gpu >= 0:
    cuda.get_device(args.gpu).use()
    model.to_gpu()
optimizer = O.SGD()
optimizer.setup(model)

xp = cuda.cupy if args.gpu >= 0 else numpy

start_iteration = 0 if args.cache_level is None else -1
forward_time = 0.0
backward_time = 0.0
update_time = 0.0

print('iteration\tforward\tbackward\tupdate (in seconds)')
for iteration in six.moves.range(start_iteration, args.iteration):
    if args.gpu >= 0:
        cache.clear_cache(args.cache_level)

    # data generation
    data = numpy.random.randint(0, vocab_size,
                                (args.batchsize, args.seq_length)
                                ).astype(numpy.int32)
    data = chainer.Variable(xp.asarray(data))
    label = numpy.random.randint(0, vocab_size,
                                 (args.batchsize, args.seq_length)
                                 ).astype(numpy.int32)
    label = chainer.Variable(xp.asarray(label))

    # forward
    with timer.get_timer(xp) as t:
        loss = model(data, label)
    forward_time_one = t.total_time()

    # backward
    with timer.get_timer(xp) as t:
        loss.backward()
    backward_time_one = t.total_time()

    # parameter update
    with timer.get_timer(xp) as t:
        optimizer.update()
    update_time_one = t.total_time()

    if iteration < 0:
        print('Burn-in\t{}\t{}\t{}'.format(forward_time_one, backward_time_one, update_time_one))
    else:
        print('{}\t{}\t{}\t{}'.format(iteration, forward_time_one, backward_time_one, update_time_one))
        forward_time += forward_time_one
        backward_time += backward_time_one
        update_time += update_time_one

forward_time /= args.iteration
backward_time /= args.iteration
update_time /= args.iteration

print('Mean\t{}\t{}\t{}'.format(forward_time, backward_time, update_time))


text:
namespace printing {

namespace {

const char* kMetafileKey = "CrMetafile";
const char* kCustomScaleKey = "CrCustomScale";

}  // namespace

// static
void MetafileSkiaWrapper::SetMetafileOnCanvas(const SkCanvas& canvas,
                                              PdfMetafileSkia* metafile) {
  skia::RefPtr<MetafileSkiaWrapper> wrapper;
  if (metafile)
    wrapper = skia::AdoptRef(new MetafileSkiaWrapper(metafile));

  SkMetaData& meta = skia::getMetaData(canvas);
  meta.setRefCnt(kMetafileKey, wrapper.get());
}

// static
PdfMetafileSkia* MetafileSkiaWrapper::GetMetafileFromCanvas(
    const SkCanvas& canvas) {
  SkMetaData& meta = skia::getMetaData(canvas);
  SkRefCnt* value;
  if (!meta.findRefCnt(kMetafileKey, &value) || !value)
    return NULL;

  return static_cast<MetafileSkiaWrapper*>(value)->metafile_;
}

// static
void MetafileSkiaWrapper::SetCustomScaleOnCanvas(const SkCanvas& canvas,
                                                 double scale) {
  SkMetaData& meta = skia::getMetaData(canvas);
  meta.setScalar(kCustomScaleKey, SkFloatToScalar(scale));
}

// static
bool MetafileSkiaWrapper::GetCustomScaleOnCanvas(const SkCanvas& canvas,
                                                 double* scale) {
  SkMetaData& meta = skia::getMetaData(canvas);
  SkScalar value;
  if (!meta.findScalar(kCustomScaleKey, &value))
    return false;

  *scale = SkScalarToFloat(value);
  return true;
}

MetafileSkiaWrapper::MetafileSkiaWrapper(PdfMetafileSkia* metafile)
    : metafile_(metafile) {
}

}  // namespace printing


text: Rails.application.config.session_store :cookie_store, key: '_givelightCRM_session'


text:
<?php
    $PAGE_NAME = 'all';
    require_once($_SERVER["DOCUMENT_ROOT"].'/css/csshead.php');
?>

This property is capable of changing every CSS property associated with its target in one of three ways, with the exceptions of unicode-bidi and direction. This is most useful for reversing a number of changes made more generally on a specific level. Note, though, that under normal circumstances it is easier to avoid targeting an element via selectors than by undoing higher-level changes; the most likely use case here would be if you don't have full control over the stylesheets of the site you're working on.

Example of use:

				<style scoped>

				    .redp {

				        background-color: red;

				        color: white;

				    }

				    #normalp {

				        all: initial;

				    }

				</style>

				<p class="redp">The background color in this <code><p></code> element is red.</p>

				<p class="redp" id="normalp">In this one, it isn't, because the values were reset.</p>

Will be rendered as:

The background color in this <p> element is red.

In this one, it isn't, because the values were reset.

Accepted values of all:

initial

Sets all properties assigned to the element to their initial, unmodified values.

inherit

Sets all properties assigned to the element to the parent element's values if they are inheritable. If they are not, they will be unchanged.

unset

Sets all properties assigned to the element to the parent element's values if they are inheritable. If they are not, they will be set to the initial values instead.

<?php
    require_once($_SERVER["DOCUMENT_ROOT"].'/genericfoot.php');
?>