text:
package com.typesafe.config.impl;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.typesafe.config.ConfigException;
import com.typesafe.config.ConfigOrigin;
import com.typesafe.config.impl.SerializedConfigValue.SerializedField;

// it would be cleaner to have a class hierarchy for various origin types,
// but was hoping this would be enough simpler to be a little messy. eh.
final class SimpleConfigOrigin implements ConfigOrigin {

    final private String description;
    final private int lineNumber;
    final private int endLineNumber;
    final private OriginType originType;
    final private String urlOrNull;
    final private List<String> commentsOrNull;

    protected SimpleConfigOrigin(String description, int lineNumber, int endLineNumber,
            OriginType originType, String urlOrNull, List<String> commentsOrNull) {
        if (description == null)
            throw new ConfigException.BugOrBroken("description may not be null");
        this.description = description;
        this.lineNumber = lineNumber;
        this.endLineNumber = endLineNumber;
        this.originType = originType;
        this.urlOrNull = urlOrNull;
        this.commentsOrNull = commentsOrNull;
    }

    static SimpleConfigOrigin newSimple(String description) {
        return new SimpleConfigOrigin(description, -1, -1, OriginType.GENERIC, null, null);
    }

    static SimpleConfigOrigin newFile(String filename) {
        String url;
        try {
            url = (new File(filename)).toURI().toURL().toExternalForm();
        } catch (MalformedURLException e) {
            url = null;
        }
        return new SimpleConfigOrigin(filename, -1, -1, OriginType.FILE, url, null);
    }

    static SimpleConfigOrigin newURL(URL url) {
        String u = url.toExternalForm();
        return new SimpleConfigOrigin(u, -1, -1, OriginType.URL, u, null);
    }

    static SimpleConfigOrigin newResource(String resource, URL url) {
        return new SimpleConfigOrigin(resource, -1, -1, OriginType.RESOURCE,
                url != null ? url.toExternalForm() : null, null);
    }

    static SimpleConfigOrigin newResource(String resource) {
        return newResource(resource, null);
    }

    SimpleConfigOrigin setLineNumber(int lineNumber) {
        if (lineNumber == this.lineNumber && lineNumber == this.endLineNumber) {
            return this;
        } else {
            return new SimpleConfigOrigin(this.description, lineNumber, lineNumber,
                    this.originType, this.urlOrNull, this.commentsOrNull);
        }
    }

    SimpleConfigOrigin addURL(URL url) {
        return new SimpleConfigOrigin(this.description, this.lineNumber, this.endLineNumber,
                this.originType, url != null ? url.toExternalForm() : null, this.commentsOrNull);
    }

    SimpleConfigOrigin setComments(List<String> comments) {
        if (ConfigImplUtil.equalsHandlingNull(comments, this.commentsOrNull)) {
            return this;
        } else {
            return new SimpleConfigOrigin(this.description, this.lineNumber, this.endLineNumber,
                    this.originType, this.urlOrNull, comments);
        }
    }

    @Override
    public String description() {
        // not putting the URL in here for files and resources, because people
        // parsing "file: line" syntax would hit the ":" in the URL.
        if (lineNumber < 0) {
            return description;
        } else if (endLineNumber == lineNumber) {
            return description + ": " + lineNumber;
        } else {
            return description + ": " + lineNumber + "-" + endLineNumber;
        }
    }

    @Override
    public boolean equals(Object other) {
        if (other instanceof SimpleConfigOrigin) {
            SimpleConfigOrigin otherOrigin = (SimpleConfigOrigin) other;

            return this.description.equals(otherOrigin.description)
                    && this.lineNumber == otherOrigin.lineNumber
                    && this.endLineNumber == otherOrigin.endLineNumber
                    && this.originType == otherOrigin.originType
                    && ConfigImplUtil.equalsHandlingNull(this.urlOrNull, otherOrigin.urlOrNull);
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        int h = 41 * (41 + description.hashCode());
        h = 41 * (h + lineNumber);
        h = 41 * (h + endLineNumber);
        h = 41 * (h + originType.hashCode());
        if (urlOrNull != null)
            h = 41 * (h + urlOrNull.hashCode());
        return h;
    }

    @Override
    public String toString() {
        // the url is only really useful on top of description for resources
        if (originType == OriginType.RESOURCE && urlOrNull != null) {
            return "ConfigOrigin(" + description + "," + urlOrNull + ")";
        } else {
            return "ConfigOrigin(" + description + ")";
        }
    }

    @Override
    public String filename() {
        if (originType == OriginType.FILE) {
            return description;
        } else if (urlOrNull != null) {
            URL url;
            try {
                url = new URL(urlOrNull);
            } catch (MalformedURLException e) {
                return null;
            }
            if (url.getProtocol().equals("file")) {
                return url.getFile();
            } else {
                return null;
            }
        } else {
            return null;
        }
    }

    @Override
    public URL url() {
        if (urlOrNull == null) {
            return null;
        } else {
            try {
                return new URL(urlOrNull);
            } catch (MalformedURLException e) {
                return null;
            }
        }
    }

    @Override
    public String resource() {
        if (originType == OriginType.RESOURCE) {
            return description;
        } else {
            return null;
        }
    }

    @Override
    public int lineNumber() {
        return lineNumber;
    }

    @Override
    public List<String> comments() {
        if (commentsOrNull != null) {
            return commentsOrNull;
        } else {
            return Collections.emptyList();
        }
    }

    static final String MERGE_OF_PREFIX = "merge of ";

    private static SimpleConfigOrigin mergeTwo(SimpleConfigOrigin a, SimpleConfigOrigin b) {
        String mergedDesc;
        int mergedStartLine;
        int mergedEndLine;
        List<String> mergedComments;

        OriginType mergedType;
        if (a.originType == b.originType) {
            mergedType = a.originType;
        } else {
            mergedType = OriginType.GENERIC;
        }

        // first use the "description" field which has no line numbers
        // cluttering it.
        String aDesc = a.description;
        String bDesc = b.description;
        if (aDesc.startsWith(MERGE_OF_PREFIX))
            aDesc = aDesc.substring(MERGE_OF_PREFIX.length());
        if (bDesc.startsWith(MERGE_OF_PREFIX))
            bDesc = bDesc.substring(MERGE_OF_PREFIX.length());

        if (aDesc.equals(bDesc)) {
            mergedDesc = aDesc;

            if (a.lineNumber < 0)
                mergedStartLine = b.lineNumber;
            else if (b.lineNumber < 0)
                mergedStartLine = a.lineNumber;
            else
                mergedStartLine = Math.min(a.lineNumber, b.lineNumber);

            mergedEndLine = Math.max(a.endLineNumber, b.endLineNumber);
        } else {
            // this whole merge song-and-dance was intended to avoid this case
            // whenever possible, but we've lost. Now we have to lose some
            // structured information and cram into a string.

            // description() method includes line numbers, so use it instead
            // of description field.
            String aFull = a.description();
            String bFull = b.description();
            if (aFull.startsWith(MERGE_OF_PREFIX))
                aFull = aFull.substring(MERGE_OF_PREFIX.length());
            if (bFull.startsWith(MERGE_OF_PREFIX))
                bFull = bFull.substring(MERGE_OF_PREFIX.length());

            mergedDesc = MERGE_OF_PREFIX + aFull + "," + bFull;

            mergedStartLine = -1;
            mergedEndLine = -1;
        }

        String mergedURL;
        if (ConfigImplUtil.equalsHandlingNull(a.urlOrNull, b.urlOrNull)) {
            mergedURL = a.urlOrNull;
        } else {
            mergedURL = null;
        }

        if (ConfigImplUtil.equalsHandlingNull(a.commentsOrNull, b.commentsOrNull)) {
            mergedComments = a.commentsOrNull;
        } else {
            mergedComments = new ArrayList<String>();
            if (a.commentsOrNull != null)
                mergedComments.addAll(a.commentsOrNull);
            if (b.commentsOrNull != null)
                mergedComments.addAll(b.commentsOrNull);
        }

        return new SimpleConfigOrigin(mergedDesc, mergedStartLine, mergedEndLine, mergedType,
                mergedURL, mergedComments);
    }

    private static int similarity(SimpleConfigOrigin a, SimpleConfigOrigin b) {
        int count = 0;

        if (a.originType == b.originType)
            count += 1;

        if (a.description.equals(b.description)) {
            count += 1;

            // only count these if the description field (which is the file
            // or resource name) also matches.
            if (a.lineNumber == b.lineNumber)
                count += 1;
            if (a.endLineNumber == b.endLineNumber)
                count += 1;
            if (ConfigImplUtil.equalsHandlingNull(a.urlOrNull, b.urlOrNull))
                count += 1;
        }

        return count;
    }

    // this picks the best pair to merge, because the pair has the most in
    // common. we want to merge two lines in the same file rather than something
    // else with one of the lines; because two lines in the same file can be
    // better consolidated.
    private static SimpleConfigOrigin mergeThree(SimpleConfigOrigin a, SimpleConfigOrigin b,
            SimpleConfigOrigin c) {
        if (similarity(a, b) >= similarity(b, c)) {
            return mergeTwo(mergeTwo(a, b), c);
        } else {
            return mergeTwo(a, mergeTwo(b, c));
        }
    }

    static ConfigOrigin mergeOrigins(ConfigOrigin a, ConfigOrigin b) {
        return mergeTwo((SimpleConfigOrigin) a, (SimpleConfigOrigin) b);
    }

    static ConfigOrigin mergeOrigins(List<? extends AbstractConfigValue> stack) {
        List<ConfigOrigin> origins = new ArrayList<ConfigOrigin>(stack.size());
        for (AbstractConfigValue v : stack) {
            origins.add(v.origin());
        }
        return mergeOrigins(origins);
    }

    static ConfigOrigin mergeOrigins(Collection<? extends ConfigOrigin> stack) {
        if (stack.isEmpty()) {
            throw new ConfigException.BugOrBroken("can't merge empty list of origins");
        } else if (stack.size() == 1) {
            return stack.iterator().next();
        } else if (stack.size() == 2) {
            Iterator<? extends ConfigOrigin> i = stack.iterator();
            return mergeTwo((SimpleConfigOrigin) i.next(), (SimpleConfigOrigin) i.next());
        } else {
            List<SimpleConfigOrigin> remaining = new ArrayList<SimpleConfigOrigin>();
            for (ConfigOrigin o : stack) {
                remaining.add((SimpleConfigOrigin) o);
            }
            while (remaining.size() > 2) {
                SimpleConfigOrigin c = remaining.get(remaining.size() - 1);
                remaining.remove(remaining.size() - 1);
                SimpleConfigOrigin b = remaining.get(remaining.size() - 1);
                remaining.remove(remaining.size() - 1);
                SimpleConfigOrigin a = remaining.get(remaining.size() - 1);
                remaining.remove(remaining.size() - 1);

                SimpleConfigOrigin merged = mergeThree(a, b, c);

                remaining.add(merged);
            }

            // should be down to either 1 or 2
            return mergeOrigins(remaining);
        }
    }

    Map<SerializedField, Object> toFields() {
        Map<SerializedField, Object> m = new EnumMap<SerializedField, Object>(SerializedField.class);

        m.put(SerializedField.ORIGIN_DESCRIPTION, description);

        if (lineNumber >= 0)
            m.put(SerializedField.ORIGIN_LINE_NUMBER, lineNumber);
        if (endLineNumber >= 0)
            m.put(SerializedField.ORIGIN_END_LINE_NUMBER, endLineNumber);

        m.put(SerializedField.ORIGIN_TYPE, originType.ordinal());

        if (urlOrNull != null)
            m.put(SerializedField.ORIGIN_URL, urlOrNull);
        if (commentsOrNull != null)
            m.put(SerializedField.ORIGIN_COMMENTS, commentsOrNull);

        return m;
    }

    Map<SerializedField, Object> toFieldsDelta(SimpleConfigOrigin baseOrigin) {
        Map<SerializedField, Object> baseFields;
        if (baseOrigin != null)
            baseFields = baseOrigin.toFields();
        else
            baseFields = Collections.<SerializedField, Object> emptyMap();
        return fieldsDelta(baseFields, toFields());
    }

    // Here we're trying to avoid serializing the same info over and over
    // in the common case that child objects have the same origin fields
    // as their parent objects. e.g. we don't need to store the source
    // filename with every single value.
    static Map<SerializedField, Object> fieldsDelta(Map<SerializedField, Object> base,
            Map<SerializedField, Object> child) {
        Map<SerializedField, Object> m = new EnumMap<SerializedField, Object>(child);

        for (Map.Entry<SerializedField, Object> baseEntry : base.entrySet()) {
            SerializedField f = baseEntry.getKey();
            if (m.containsKey(f)
                    && ConfigImplUtil.equalsHandlingNull(baseEntry.getValue(), m.get(f))) {
                // if field is unchanged, just remove it so we inherit
                m.remove(f);
            } else if (!m.containsKey(f)) {
                // if field has been removed, we have to add a deletion entry
                switch (f) {
                case ORIGIN_DESCRIPTION:
                    throw new ConfigException.BugOrBroken("origin missing description field? "
                            + child);
                case ORIGIN_LINE_NUMBER:
                    m.put(SerializedField.ORIGIN_LINE_NUMBER, -1);
                    break;
                case ORIGIN_END_LINE_NUMBER:
                    m.put(SerializedField.ORIGIN_END_LINE_NUMBER, -1);
                    break;
                case ORIGIN_TYPE:
                    throw new ConfigException.BugOrBroken("should always be an ORIGIN_TYPE field");
                case ORIGIN_URL:
                    m.put(SerializedField.ORIGIN_NULL_URL, "");
                    break;
                case ORIGIN_COMMENTS:
                    m.put(SerializedField.ORIGIN_NULL_COMMENTS, "");
                    break;
                case ORIGIN_NULL_URL: // FALL THRU
                case ORIGIN_NULL_COMMENTS:
                    throw new ConfigException.BugOrBroken(
                            "computing delta, base object should not contain " + f
                            + " " + base);
                case END_MARKER:
                case ROOT_VALUE:
                case ROOT_WAS_CONFIG:
                case UNKNOWN:
                case VALUE_DATA:
                case VALUE_ORIGIN:
                    throw new ConfigException.BugOrBroken("should not appear here: " + f);
                }
            } else {
                // field is in base and child, but differs, so leave it
            }
        }

        return m;
    }

    static SimpleConfigOrigin fromFields(Map<SerializedField, Object> m) throws IOException {
        String description = (String) m.get(SerializedField.ORIGIN_DESCRIPTION);
        Integer lineNumber = (Integer) m.get(SerializedField.ORIGIN_LINE_NUMBER);
        Integer endLineNumber = (Integer) m.get(SerializedField.ORIGIN_END_LINE_NUMBER);
        Number originTypeOrdinal = (Number) m.get(SerializedField.ORIGIN_TYPE);
        if (originTypeOrdinal == null)
            throw new IOException("Missing ORIGIN_TYPE field");
        OriginType originType = OriginType.values()[originTypeOrdinal.byteValue()];
        String urlOrNull = (String) m.get(SerializedField.ORIGIN_URL);
        @SuppressWarnings("unchecked")
        List<String> commentsOrNull = (List<String>) m.get(SerializedField.ORIGIN_COMMENTS);
        return new SimpleConfigOrigin(description, lineNumber != null ? lineNumber : -1,
                endLineNumber != null ? endLineNumber : -1, originType, urlOrNull, commentsOrNull);
    }

    static Map<SerializedField, Object> applyFieldsDelta(Map<SerializedField, Object> base,
            Map<SerializedField, Object> delta) throws IOException {

        Map<SerializedField, Object> m = new EnumMap<SerializedField, Object>(delta);

        for (Map.Entry<SerializedField, Object> baseEntry : base.entrySet()) {
            SerializedField f = baseEntry.getKey();
            if (delta.containsKey(f)) {
                // delta overrides when keys are in both
                // "m" should already contain the right thing
            } else {
                // base has the key and delta does not.
                // we inherit from base unless a "NULL" key blocks.
                switch (f) {
                case ORIGIN_DESCRIPTION:
                    m.put(f, base.get(f));
                    break;
                case ORIGIN_URL:
                    if (delta.containsKey(SerializedField.ORIGIN_NULL_URL)) {
                        m.remove(SerializedField.ORIGIN_NULL_URL);
                    } else {
                        m.put(f, base.get(f));
                    }
                    break;
                case ORIGIN_COMMENTS:
                    if (delta.containsKey(SerializedField.ORIGIN_NULL_COMMENTS)) {
                        m.remove(SerializedField.ORIGIN_NULL_COMMENTS);
                    } else {
                        m.put(f, base.get(f));
                    }
                    break;
                case ORIGIN_NULL_URL: // FALL THRU
                case ORIGIN_NULL_COMMENTS: // FALL THRU
                    // base objects shouldn't contain these, should just
                    // lack the field. these are only in deltas.
                    throw new ConfigException.BugOrBroken(
                            "applying fields, base object should not contain " + f + " " + base);
                case ORIGIN_END_LINE_NUMBER: // FALL THRU
                case ORIGIN_LINE_NUMBER: // FALL THRU
                case ORIGIN_TYPE:
                    m.put(f, base.get(f));
                    break;

                case END_MARKER:
                case ROOT_VALUE:
                case ROOT_WAS_CONFIG:
                case UNKNOWN:
                case VALUE_DATA:
                case VALUE_ORIGIN:
                    throw new ConfigException.BugOrBroken("should not appear here: " + f);
                }
            }
        }
        return m;
    }

    static SimpleConfigOrigin fromBase(SimpleConfigOrigin baseOrigin,
            Map<SerializedField, Object> delta) throws IOException {
        Map<SerializedField, Object> baseFields;
        if (baseOrigin != null)
            baseFields = baseOrigin.toFields();
        else
            baseFields = Collections.<SerializedField, Object> emptyMap();
        Map<SerializedField, Object> fields = applyFieldsDelta(baseFields, delta);
        return fromFields(fields);
    }
}


text:
'use strict';

/**
 * A class represents the access keys of SignalR service.
 *
 */
class SignalRKeys {
  /**
   * Create a SignalRKeys.
   * @member {string} [primaryKey] The primary access key.
   * @member {string} [secondaryKey] The secondary access key.
   * @member {string} [primaryConnectionString] SignalR connection string
   * constructed via the primaryKey
   * @member {string} [secondaryConnectionString] SignalR connection string
   * constructed via the secondaryKey
   */
  constructor() {
  }

  /**
   * Defines the metadata of SignalRKeys
   *
   * @returns {object} metadata of SignalRKeys
   *
   */
  mapper() {
    return {
      required: false,
      serializedName: 'SignalRKeys',
      type: {
        name: 'Composite',
        className: 'SignalRKeys',
        modelProperties: {
          primaryKey: {
            required: false,
            serializedName: 'primaryKey',
            type: {
              name: 'String'
            }
          },
          secondaryKey: {
            required: false,
            serializedName: 'secondaryKey',
            type: {
              name: 'String'
            }
          },
          primaryConnectionString: {
            required: false,
            serializedName: 'primaryConnectionString',
            type: {
              name: 'String'
            }
          },
          secondaryConnectionString: {
            required: false,
            serializedName: 'secondaryConnectionString',
            type: {
              name: 'String'
            }
          }
        }
      }
    };
  }
}

module.exports = SignalRKeys;

redpajama_set_name: RedPajamaGithub


text:
            {{name}}
            Unbekannt!

            Deine Mac Adresse lautet: {{mac}}

        Deine Mac Adresse wird zufällig generiert, daher kannst du dafür keinen Namen eingeben. Bei Windows 10 kann man das angeblich ändern.

Ändern

            Ändere deinen Namen auf Status.
            Der wird immer dann angezeigt, wenn du mit diesem Gerät im Mainframe WLAN bist.

    <form class="mac-form" ng-submit="saveName()">

            Name/Alias
            <input type="text" class="form-control" id="name" placeholder="Dein Name" ng-model="form.name" ng-disabled="ajax" required>

            Sichtbarkeit
            Hilfe! Was heißt das?

                    <input type="radio" name="visibility" value="show" ng-model="form.visibility" ng-disabled="ajax">
                    Mit Name/Alias anzeigen.

                    <input type="radio" name="visibility" value="anon" ng-model="form.visibility" ng-disabled="ajax">
                    Als anonyme Person anzeigen.

                    <input type="radio" name="visibility" value="ignored" ng-model="form.visibility" ng-disabled="ajax">
                    Gar nicht anzeigen. Die wirklich paranoide Option. Meistens ist der obere Punkt besser.

            Eintrag löschen
            <button class="btn btn-primary pull-right" type="submit" ng-disabled="ajax">Speichern</button>

{{errorMsg}}

    </form>


text:
from ui.login.loginpage import LoginWindow

if __name__ == '__main__':
    LoginWindow().showView()


text:
import os
import os.path as op
import shutil

import pytest
from numpy.testing import assert_array_equal
import numpy as np

from mne.datasets.testing import data_path, requires_testing_data
from mne.io import read_raw_persyst
from mne.io.tests.test_raw import _test_raw_reader

fname_lay = op.join(
    data_path(download=False), 'Persyst',
    'sub-pt1_ses-02_task-monitor_acq-ecog_run-01_clip2.lay')
fname_dat = op.join(
    data_path(download=False), 'Persyst',
    'sub-pt1_ses-02_task-monitor_acq-ecog_run-01_clip2.dat')

@requires_testing_data
def test_persyst_lay_load():
    """Test reading Persyst files using path to header file."""
    raw = read_raw_persyst(fname_lay, preload=False)

    # Test data import
    assert raw.info['sfreq'] == 200
    assert raw.preload is False

    # load raw data
    raw.load_data()
    assert raw._data.shape == (83, 847)
    assert raw.preload is True

    # defaults channels to EEG
    raw = raw.pick_types(eeg=True)
    assert len(raw.ch_names) == 83

    # no "-Ref" in channel names
    assert all(['-ref' not in ch.lower()
                for ch in raw.ch_names])

    # test with preload True
    raw = read_raw_persyst(fname_lay, preload=True)

@requires_testing_data
def test_persyst_raw():
    """Test reading Persyst files using path to header file."""
    raw = read_raw_persyst(fname_lay, preload=False)

    # defaults channels to EEG
    raw = raw.pick_types(eeg=True)

    # get data
    data, times = raw.get_data(start=200, return_times=True)
    assert data.shape == (83, 647)

    # seconds should match up to what is in the file
    assert times.min() == 1.0
    assert times.max() == 4.23

    # get data
    data = raw.get_data(start=200, stop=400)
    assert data.shape == (83, 200)

    # data should have been set correctly
    assert not data.min() == 0 and not data.max() == 0

    first_ch_data = raw.get_data(picks=[0], start=200, stop=400)
    assert_array_equal(first_ch_data.squeeze(), data[0, :])

@requires_testing_data
def test_persyst_dates(tmpdir):
    """Test different Persyst date formats for meas date."""
    # now test what if you change contents of the lay file
    out_dir = str(tmpdir)
    new_fname_lay = op.join(out_dir, op.basename(fname_lay))
    new_fname_dat = op.join(out_dir, op.basename(fname_dat))
    shutil.copy(fname_dat, new_fname_dat)

    # reformat the lay file to have testdate with
    # "/" character
    with open(fname_lay, "r") as fin:
        with open(new_fname_lay, 'w') as fout:
            # for each line in the input file
            for idx, line in enumerate(fin):
                if line.startswith('TestDate'):
                    line = 'TestDate=01/23/2000\n'
                fout.write(line)
    # file should update correctly with datetime
    raw = read_raw_persyst(new_fname_lay)
    assert raw.info['meas_date'].month == 1
    assert raw.info['meas_date'].day == 23
    assert raw.info['meas_date'].year == 2000

    # reformat the lay file to have testdate with
    # "-" character
    os.remove(new_fname_lay)
    with open(fname_lay, "r") as fin:
        with open(new_fname_lay, 'w') as fout:
            # for each line in the input file
            for idx, line in enumerate(fin):
                if line.startswith('TestDate'):
                    line = 'TestDate=24-01-2000\n'
                fout.write(line)
    # file should update correctly with datetime
    raw = read_raw_persyst(new_fname_lay)
    assert raw.info['meas_date'].month == 1
    assert raw.info['meas_date'].day == 24
    assert raw.info['meas_date'].year == 2000

@requires_testing_data
def test_persyst_wrong_file(tmpdir):
    """Test reading Persyst files when passed in wrong file path."""
    with pytest.raises(FileNotFoundError, match='The path you'):
        read_raw_persyst(fname_dat, preload=True)

    out_dir = str(tmpdir)
    new_fname_lay = op.join(out_dir, op.basename(fname_lay))
    new_fname_dat = op.join(out_dir, op.basename(fname_dat))
    shutil.copy(fname_lay, new_fname_lay)

    # without a .dat file, reader should break
    desired_err_msg = \
        'The data path you specified does ' \
        'not exist for the lay path, ' \
        'sub-pt1_ses-02_task-monitor_acq-ecog_run-01_clip2.lay'
    with pytest.raises(FileNotFoundError, match=desired_err_msg):
        read_raw_persyst(new_fname_lay, preload=True)

    # once you copy over the .dat file things should work
    shutil.copy(fname_dat, new_fname_dat)
    read_raw_persyst(new_fname_lay, preload=True)

@requires_testing_data
def test_persyst_moved_file(tmpdir):
    """Test reader - Persyst files need to be in same directory."""
    out_dir = str(tmpdir)
    new_fname_lay = op.join(out_dir, op.basename(fname_lay))
    new_fname_dat = op.join(out_dir, op.basename(fname_dat))
    shutil.copy(fname_lay, new_fname_lay)

    # original file read should work
    read_raw_persyst(fname_lay)

    # without a .dat file, reader should break
    # when the lay file was moved
    desired_err_msg = \
        'The data path you specified does ' \
        'not exist for the lay path, ' \
        'sub-pt1_ses-02_task-monitor_acq-ecog_run-01_clip2.lay'
    with pytest.raises(FileNotFoundError, match=desired_err_msg):
        read_raw_persyst(new_fname_lay, preload=True)

    # now change the file contents to point
    # to the full path, but it should still not work
    # as reader requires lay and dat file to be in
    # same directory
    with open(fname_lay, "r") as fin:
        with open(new_fname_lay, 'w') as fout:
            # for each line in the input file
            for idx, line in enumerate(fin):
                if line.startswith('File='):
                    # give it the full path to the old data
                    test_fpath = op.join(op.dirname(fname_dat),
                                         line.split('=')[1])
                    line = f'File={test_fpath}\n'
                fout.write(line)
    with pytest.raises(FileNotFoundError, match=desired_err_msg):
        read_raw_persyst(new_fname_lay, preload=True)

    # once we copy the dat file to the same directory, reader
    # should work
    shutil.copy(fname_dat, new_fname_dat)
    read_raw_persyst(new_fname_lay, preload=True)

@requires_testing_data
def test_persyst_standard():
    """Test standard operations."""
    _test_raw_reader(read_raw_persyst, fname=fname_lay)

@requires_testing_data
def test_persyst_annotations(tmp_path):
    """Test annotations reading in Persyst."""
    new_fname_lay = tmp_path / op.basename(fname_lay)
    new_fname_dat = tmp_path / op.basename(fname_dat)
    shutil.copy(fname_dat, new_fname_dat)
    shutil.copy(fname_lay, new_fname_lay)

    raw = read_raw_persyst(new_fname_lay)
    raw.crop(tmin=0, tmax=4)

    # get the annotations and make sure that repeated annotations
    # are in the dataset
    annotations = raw.annotations
    assert np.count_nonzero(annotations.description == 'seizure') == 2

    # make sure annotation with a "," character is in there
    assert 'seizure1,2' in annotations.description
    assert 'CLip2' in annotations.description

@requires_testing_data
def test_persyst_errors(tmpdir):
    """Test reading Persyst files when passed in wrong file path."""
    out_dir = str(tmpdir)
    new_fname_lay = op.join(out_dir, op.basename(fname_lay))
    new_fname_dat = op.join(out_dir, op.basename(fname_dat))
    shutil.copy(fname_dat, new_fname_dat)

    # reformat the lay file
    with open(fname_lay, "r") as fin:
        with open(new_fname_lay, 'w') as fout:
            # for each line in the input file
            for idx, line in enumerate(fin):
                if idx == 1:
                    line = line.replace('=', ',')
                fout.write(line)
    # file should break
    with pytest.raises(RuntimeError, match='The line'):
        read_raw_persyst(new_fname_lay)

    # reformat the lay file
    os.remove(new_fname_lay)
    with open(fname_lay, "r") as fin:
        with open(new_fname_lay, 'w') as fout:
            # for each line in the input file
            for idx, line in enumerate(fin):
                if line.startswith('WaveformCount'):
                    line = 'WaveformCount=1\n'
                fout.write(line)
    # file should break
    with pytest.raises(RuntimeError, match='Channels in lay '
                                           'file do not'):
        read_raw_persyst(new_fname_lay)

    # reformat the lay file to have testdate
    # improperly specified
    os.remove(new_fname_lay)
    with open(fname_lay, "r") as fin:
        with open(new_fname_lay, 'w') as fout:
            # for each line in the input file
            for idx, line in enumerate(fin):
                if line.startswith('TestDate'):
                    line = 'TestDate=Jan 23rd 2000\n'
                fout.write(line)
    # file should not read in meas date
    with pytest.warns(RuntimeWarning,
                      match='Cannot read in the measurement date'):
        raw = read_raw_persyst(new_fname_lay)
        assert raw.info['meas_date'] is None


text:
var zmq = require('zmq');

var producer = zmq.socket('push');

producer.bindSync('tcp://localhost:3000');

setInterval(function() {
    producer.send('New Work!');
}, 1000);


text:
using System;
using CommandLineParser.Arguments;
using CommandLineParser.Exceptions;
using System.Linq;

namespace CommandLineParser.Validation
{
    /// <summary>
    /// Allows to define a group of arguments required for another argument.
    /// </summary>
    public class ArgumentRequiresOtherArgumentsCertification : ArgumentCertification
    {
        private Argument[] _argumentsRequiredForMainArgument;
        private Argument _mainArgument;
        private readonly string _argumentsRequiredForMainArgumentString;
        private readonly string _mainArgumentString;

        /// <summary>
        /// Creates new instance of ArgumentRequiresOtherArgumentsCertification - this certification allows to define a
        /// group of arguments required for another argument.
        /// </summary>
        /// <param name="mainArgument"></param>
        /// <param name="argumentsRequiredForMainArgument"></param>
        public ArgumentRequiresOtherArgumentsCertification(Argument mainArgument, Argument[] argumentsRequiredForMainArgument)
        {
            _argumentsRequiredForMainArgument = argumentsRequiredForMainArgument;
            _argumentsRequiredForMainArgumentString = ArgumentGroupCertification.GetGroupStringFromArguments(argumentsRequiredForMainArgument);
            _mainArgumentString = ArgumentGroupCertification.GetGroupStringFromArguments(new[] { mainArgument });
            if (_description == null)
            {
                _description = DefaultUsageDescription();
            }
        }

        /// <summary>
        /// Creates new instance of ArgumentRequiresOtherArgumentsCertification - this certification allows to define a
        /// group of arguments required for another argument.
        /// </summary>
        /// <param name="mainArgument">name of the argument that requires other arguments</param>
        /// <param name="argumentsRequiredForMainArgument">arguments required by <paramref name="mainArgument"/> - names of the
        /// arguments separated by commas, semicolons or '|' character</param>
        public ArgumentRequiresOtherArgumentsCertification(string mainArgument, string argumentsRequiredForMainArgument)
        {
            _argumentsRequiredForMainArgumentString = argumentsRequiredForMainArgument;
            _mainArgumentString = mainArgument;
            if (_description == null)
            {
                _description = DefaultUsageDescription();
            }
        }

        /// <summary>
        /// When main argument is present, tests, whether arguments required by main argument are also present.
        /// If not <see cref="MandatoryArgumentNotSetException"/> is thrown.
        /// </summary>
        /// <param name="parser">parser object gives access to the defined arguments, their values and
        /// parameters of the parser</param>
        /// <exception cref="MandatoryArgumentNotSetException">Thrown when main argument is present but some of the arguments
        /// required for main argument is not.</exception>
        public override void Certify(CommandLineParser parser)
        {
            if (_argumentsRequiredForMainArgument == null || _mainArgument == null)
            {
                _argumentsRequiredForMainArgument = ArgumentGroupCertification.GetArgumentsFromGroupString(parser, _argumentsRequiredForMainArgumentString);
                _mainArgument = ArgumentGroupCertification.GetArgumentsFromGroupString(parser, _mainArgumentString).SingleOrDefault();
            }

            if (_argumentsRequiredForMainArgument.Length == 0)
                throw new InvalidArgumentGroupException(
                    "Argument group is empty. Argument group must have at least one member.");

            if (Description == null)
            {
                Description = DefaultUsageDescription();
            }

            if (_mainArgument.Parsed)
            {
                foreach (Argument requiredArgument in _argumentsRequiredForMainArgument)
                {
                    if (!requiredArgument.Parsed)
                    {
                        var withDefaultValue = requiredArgument as IArgumentWithDefaultValue;
                        if (withDefaultValue?.DefaultValue != null)
                        {
                            continue;
                        }
                        throw new MandatoryArgumentNotSetException(String.Format(Messages.EXC_GROUP_ARGUMENTS_REQUIRED_BY_ANOTHER_ARGUMENT, _mainArgumentString, _argumentsRequiredForMainArgumentString), requiredArgument.Name);
                    }
                }
            }
        }

        private string DefaultUsageDescription()
        {
            return string.Format(Messages.EXC_GROUP_ARGUMENTS_REQUIRED_BY_ANOTHER_ARGUMENT, _mainArgument, _argumentsRequiredForMainArgumentString);
        }
    }

    /// <summary>
    /// Use DistinctGroupsCertificationAttribute to define <see cref="DistinctGroupsCertification"/>s declaratively.
    /// </summary>
	/// <include file='..\Doc\CommandLineParser.xml' path='CommandLineParser/Certifications/CertificationAttribute/*'/>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
    public class ArgumentRequiresOtherArgumentsCertificationAttribute : ArgumentCertificationAttribute
    {
        /// <summary>
        /// Adds <see cref="ArgumentRequiresOtherArgumentsCertification"/> condition for the arguments.
        /// </summary>
        /// <param name="mainArgument">name of the argument that requires other arguments</param>
        /// <param name="argumentsRequiredForMainArgument">arguments required by <paramref name="mainArgument"/> - names of the
        /// arguments separated by commas, semicolons or '|' character</param>
        public ArgumentRequiresOtherArgumentsCertificationAttribute(string mainArgument, string argumentsRequiredForMainArgument)
            : base(typeof(ArgumentRequiresOtherArgumentsCertification), mainArgument, argumentsRequiredForMainArgument)
        {
        }
    }
}


text:
package Paws::CloudFront::DeleteCloudFrontOriginAccessIdentity;
  use Moose;
  has Id => (is => 'ro', isa => 'Str', uri_name => 'Id', traits => ['ParamInURI'], required => 1);
  has IfMatch => (is => 'ro', isa => 'Str', header_name => 'If-Match', traits => ['ParamInHeader']);

  use MooseX::ClassAttribute;

  class_has _api_call => (isa => 'Str', is => 'ro', default => 'DeleteCloudFrontOriginAccessIdentity');
  class_has _api_uri  => (isa => 'Str', is => 'ro', default => '/2017-03-25/origin-access-identity/cloudfront/{Id}');
  class_has _api_method  => (isa => 'Str', is => 'ro', default => 'DELETE');
  class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::API::Response');
  class_has _result_key => (isa => 'Str', is => 'ro');

1;

### main pod documentation begin ###

=head1 NAME

Paws::CloudFront::DeleteCloudFrontOriginAccessIdentity - Arguments for method DeleteCloudFrontOriginAccessIdentity on Paws::CloudFront

=head1 DESCRIPTION

This class represents the parameters used for calling the method DeleteCloudFrontOriginAccessIdentity2017_03_25 on the
Amazon CloudFront service. Use the attributes of this class
as arguments to method DeleteCloudFrontOriginAccessIdentity2017_03_25.

You shouldn't make instances of this class. Each attribute should be used as a named argument in the call to DeleteCloudFrontOriginAccessIdentity2017_03_25.

As an example:

  $service_obj->DeleteCloudFrontOriginAccessIdentity2017_03_25(Att1 => $value1, Att2 => $value2, ...);

Values for attributes that are native types (Int, String, Float, etc) can passed as-is (scalar values). Values for complex Types (objects) can be passed as a HashRef. The keys and values of the hashref will be used to instance the underlying object.

=head1 ATTRIBUTES

=head2 B<REQUIRED> Id => Str

The origin access identity's ID.

=head2 IfMatch => Str

The value of the C<ETag> header you received from a previous C<GET> or
C<PUT> request. For example: C<E2QWRUHAPOMQZL>.

=head1 SEE ALSO

This class forms part of L<Paws>, documenting arguments for method DeleteCloudFrontOriginAccessIdentity2017_03_25 in L<Paws::CloudFront>

=head1 BUGS and CONTRIBUTIONS

The source code is located here: https://github.com/pplu/aws-sdk-perl

Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues

=cut


text:
<?php

namespace Message;

use Message\Utils as Utils;

/**
 * Class Message
 *
 * @package Message
 */
class Message extends Base
{
    const TYPE_SMS     = 'sms';
    const TYPE_BINARY  = 'binary';
    const TYPE_PREMIUM = 'premium';

    const DATACODING_UNICODE = 'unicode';
    const DATACODING_PLAIN   = 'plain';
    const DATACODING_AUTO    = 'auto';

    const MAX_SEGMENT_SIZE_UCS2           = 70;
    const MAX_SEGMENT_SIZE_7BIT           = 160;
    const MAX_MULTIPART_SEGMENT_SIZE_UCS2 = 67;
    const MAX_MULTIPART_SEGMENT_SIZE_7BIT = 153;

    const UDHL = '05';
    const IEI  = '00';
    const IEDL = '03';

    /**
     * @access private
     * @var MessageBird
     */
    private $MessageBird;

    /**
     * @access private
     * @var Message
     */
    private $Message;

    /**
     * @access private
     * @var array
     */
    private $errors = array();

    /**
     * @access private
     * @var array
     */
    private $data = array();

    /**
     * @access private
     * @var string
     */
    public $type = self::TYPE_SMS;

    /**
     * @access public
     * @var array
     */
    public $typeDetails = array();

    /**
     * @access public
     * @var string
     */
    public $datacoding = self::DATACODING_PLAIN;

    /**
     * Send the sms
     *
     * @param  array $data
     *
     * @return array
     */
    public function send($data = array())
    {
        $response = array();

        // In case when recipient is a comma-separated string...
        if (isset($data['recipient']) && !is_array($data['recipient'])) {
            $data['recipient'] = explode(',', $data['recipient']);
        }

        $this->data = Utils::sanitize($data);

        if ($this->validate()) {
            $parts = $this->getParts();

            try {
                $results = array();

                foreach ($parts as $part) {
                    $this->MessageBird = new \MessageBird\Client($this->access_key);

                    $this->Message = new \MessageBird\Objects\Message();
                    $this->Message->originator = $this->data['originator'];
                    $this->Message->recipients = $this->data['recipient'];
                    $this->Message->datacoding = $this->datacoding;
                    $this->Message->type       = $this->type;
                    $this->Message->body       = $part['body'];

                    if ($part['header']) {
                        $this->Message->typeDetails['udh'] = $part['header'];
                    }

                    $results[] = $this->MessageBird->messages->create($this->Message);

                    $this->destruct();

                    // To honor one API request per second
                    sleep(1);
                }

                $response['status']  = 201;
                $response['success'] = $results;
            } catch (\MessageBird\Exceptions\AuthenticateException $e) {
                $response['status'] = 401;
                $response['error']  = 'A valid ACCESS_KEY is required!';
            } catch (\MessageBird\Exceptions\BalanceException $e) {
                $response['status'] = 999;
                $response['error']  = 'Insufficient balance!';
            } catch (\Exception $e) {
                $response['status'] = 500;
                $response['error']  = $e->getMessage();
            }
        } else {
            $response['status'] = 400;
            $response['error']  = $this->errors;
        }

        return $response;
    }

    /**
     * Validate the data being sent
     *
     * @return boolean
     */
    private function validate()
    {
        $required_fields = array('recipient', 'originator', 'body');

        foreach ($required_fields as $field) {
            if (!isset($this->data[$field]) || !$this->data[$field] || (is_array($this->data[$field]) && !$this->data[$field][0])) {
                $this->errors[$field] = 'The field ' . ucfirst($field) . ' is required!';
            }
        }

        if (count($this->data['recipient']) > 50) {
            $this->errors['recipient'] = 'The maximum number of recipients per request is 50!';
        }

        if (preg_match('/[^0-9]/', $this->data['originator']) && strlen($this->data['originator']) > 11) {
            $this->errors['originator'] = 'For alphanumeric originator, the maximum length allowed is 11 characters!';
        }

        return !$this->errors;
    }

    /**
     * Get array of message parts to be sent
     *
     * @return array
     */
    private function getParts()
    {
        $parts = array();

        // Set max segment size
        if ($this->datacoding == self::DATACODING_UNICODE) {
            $max_segment_size           = self::MAX_SEGMENT_SIZE_UCS2;
            $max_multipart_segment_size = self::MAX_MULTIPART_SEGMENT_SIZE_UCS2;
        } else {
            $max_segment_size           = self::MAX_SEGMENT_SIZE_7BIT;
            $max_multipart_segment_size = self::MAX_MULTIPART_SEGMENT_SIZE_7BIT;
        }

        // Single message...
        if (strlen($this->data['body']) <= $max_segment_size) {
            $parts[] = array(
                'header' => null,
                'body'   => $this->data['body']
            );
        } else {
        // Concatenated message
            $this->type = self::TYPE_BINARY;

            // Determine number of messages to be sent
            $message_len = strlen($this->data['body']);
            $n_segments  = ceil($message_len / $max_multipart_segment_size);

            if ($n_segments > 255) {
                $n_segments  = 255;
                $message_len = $n_segments * $max_multipart_segment_size;
            }

            // Generate reference number
            $reference = Utils::generateReference();

            $hex_n_segments = str_pad(strtoupper(dechex($n_segments)), 2, '0', STR_PAD_LEFT);

            // Split the message and add proper UDH
            for ($i = 0; $i < $n_segments; $i++) {
                if (($n_segments - $i) == 1) {
                    $segment_len = $message_len - $i * $max_multipart_segment_size;
                } else {
                    $segment_len = $max_multipart_segment_size;
                }

                $hex_current_segment = strtoupper(dechex($i + 1));
                $hex_current_segment = str_pad($hex_current_segment, 2, '0', STR_PAD_LEFT);

                $segment_body     = substr($this->data['body'], ($i * $max_multipart_segment_size), $segment_len);
                $hex_segment_body = Utils::strToHex($segment_body);

                $parts[$i] = array(
                    'header' => self::UDHL . self::IEI . self::IEDL . $reference . $hex_n_segments . $hex_current_segment, // e.g. 050003340201
                    'body'   => $hex_segment_body
                );
            }
        }

        return $parts;
    }

    /**
     * Destruct and release classes
     */
    private function destruct()
    {
        $this->MessageBird = null;
        $this->Message = null;
    }
}


text:
/**
 * These tests do not test that Express/Connect/Passport/etc middleware is
 * working/loaded as needed - only that `custom` middleware is working/loaded.
 */
var express = require('express'),
    request = require('supertest'),
    should = require('should'),
    app = express();

/**
 * Tests that `flash` is available to the session.
 * @param {!http.IncomingMessage} req Node/Express request object.
 * @param {!http.ServerResponse} res Node/Express response object.
 * @param {Function} next Callback function.}
 */
var testConnectFlash = function(req, res, next) {
  res.locals.messages.should.be.an.Object;
  req.session.flash.should.be.an.Object;
  res.locals.messages.should.eql(req.session.flash);
  next();
};

/**
 * Tests that the `user` locals var is set, which requires custom middleware.
 * This DOES NOT test authentication -- ONLY that if the `logged_in` property is
 * set to true on the session, that the local `user` var will be set.
 * @param {!http.IncomingMessage} req Node/Express request object.
 * @param {!http.ServerResponse} res Node/Express response object.
 * @param {Function} next Callback function.
 */
var testLoadUserLocal = function(req, res, next) {
  req.session.passport.should.be.an.Object;
  (res.locals.user === req.session.passport.user).should.be.true;
  next();
};

// Set up the tests.
require('bula-test')(app);
var bulaTest = app.test;
app.set('ROOT PATH', '/test/path');
app.set('REDIS SECRET', 'test-secret');
require('../../config/environment/dev')(app);

// Enable the test middleware - required to access the `req` request objects.
// This middleware needs to be registered in order for the test suite below
// to have access to the middleware.
app.use(testConnectFlash);
app.use(testLoadUserLocal);

describe('Core middleware module', function() {
  beforeEach(function(done) {
    var session = app.request.session = new bulaTest.authenticate();
    session.logged_in.should.be.true;
    session.passport.should.be.an.Object;
    session.passport.should.have.property.user;
    done();
  });

  it('should register the core middleware', function(done) {
    request(app)
      .get('/')
      .end(done);
  });
});


text:
import { CommonModule } from '@angular/common';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { SkyIdModule } from '@skyux/core';
import { SkyCheckboxModule } from '@skyux/forms';
import { SkyToolbarModule } from '@skyux/layout';
import { SkyFilterModule, SkyRepeaterModule } from '@skyux/lists';

import { FilterDemoComponent } from './filter-demo.component';

@NgModule({
  imports: [
    CommonModule,
    FormsModule,
    SkyCheckboxModule,
    SkyIdModule,
    SkyFilterModule,
    SkyRepeaterModule,
    SkyToolbarModule,
  ],
  declarations: [FilterDemoComponent],
  exports: [FilterDemoComponent],
})
export class FilterDemoModule {}


text:
var util = require('util');

var nodePage = require('../../node_page');

function yamlNode(id) {
    nodePage.call(this, id);
}

util.inherits(yamlNode, nodePage);

yamlNode.prototype.setAction = function (action) {
    browser.setValue('node-input-action', action);
}

yamlNode.prototype.setProperty = function (property) {
    browser.setValue('//*[contains(@class, "red-ui-typedInput-container")]/div[1]/input', property);
}

module.exports = yamlNode;


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>cz.metacentrum</groupId>
        <artifactId>perun</artifactId>
        <version>3.0.1-SNAPSHOT</version>
    </parent>

	<groupId>cz.metacentrum.perun</groupId>

    <artifactId>perun-ldapc-initializer</artifactId>
	<version>3.0.1-SNAPSHOT-${perun.build.type}</version>
    <packaging>jar</packaging>

	<name>perun-ldapc-initializer</name>
	<description>LDAP connector initialization script</description>

	<properties>
		<start-class>cz.metacentrum.perun.ldapc.initializer.main.Main</start-class>
	</properties>

	<!-- common build settings used by all profiles -->
	<build>
		<plugins>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-clean-plugin</artifactId>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-install-plugin</artifactId>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-javadoc-plugin</artifactId>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-source-plugin</artifactId>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
			</plugin>

			<!-- Package JAR with Main class and all libraries -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-shade-plugin</artifactId>
				<!-- Main-Class taken from property ${start-class} -->
			</plugin>

			<!-- Executing plug-in:  mvn exec:java -->
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>exec-maven-plugin</artifactId>
				<executions>
					<execution>
						<goals>
							<goal>java</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<mainClass>${start-class}</mainClass>
				</configuration>
			</plugin>

		</plugins>

		<!-- set filtering on resources -->
		<resources>
			<resource>
				<!-- to set jdbc.properties path and logging folder -->
				<directory>src/main/resources/</directory>
				<filtering>true</filtering>
			</resource>
		</resources>

	</build>

	<dependencies>
		<dependency>
			<groupId>cz.metacentrum.perun</groupId>
			<artifactId>perun-rpc-lib</artifactId>
			<version>${project.version}</version>
		</dependency>

		<dependency>
			<groupId>commons-cli</groupId>
			<artifactId>commons-cli</artifactId>
			<version>${commons-cli.version}</version>
		</dependency>
	</dependencies>

	<profiles>

		<profile>

			<id>devel</id>

			<activation>
				<property>
					<name>devel</name>
				</property>
			</activation>

			<properties>
				<perun.build.type>devel</perun.build.type>
				<spring.profiles.default>devel</spring.profiles.default>
			</properties>

			<build>
				<plugins>
					<plugin>
						<!-- Make "devel" tests to run against real DB -->
						<groupId>org.apache.maven.plugins</groupId>
						<artifactId>maven-surefire-plugin</artifactId>
						<configuration>
							<systemPropertyVariables>
								<spring.profiles.default>devel</spring.profiles.default>
							</systemPropertyVariables>
						</configuration>
					</plugin>
				</plugins>
			</build>

		</profile>

		<profile>

			<id>production</id>

			<activation>
				<property>
					<name>production</name>
				</property>
			</activation>

			<properties>
				<perun.build.type>production</perun.build.type>
				<skipTests>true</skipTests>
			</properties>

		</profile>

	</profiles>
</project>


text:
package com.lht.justcanvas;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

import com.lht.justcanvas.draw.AbstractDraw;

import java.io.Serializable;
import java.util.ArrayList;

/**
 * Created by lht on 16/9/1.
 */
public class JustView extends View implements Serializable {

    Context mContext;
    float mCanvasWidth = JustConfig.screenWidth;
    float mCanvasHeight = JustConfig.screenHeight - JustConfig.navbarheight - JustConfig.statusbarheight;
    float mCanvasX = 0, mCanvasY = 0;

    Bitmap mBitmap = null;
    boolean bDrawFinished = false;

    public JustView(Context context) {
        super(context);
        mContext = context;
    }

    public JustView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
    }

    public void draw(ArrayList<AbstractDraw> abstractDrawList) {
        mBitmap = Bitmap.createBitmap((int)mCanvasWidth, (int)mCanvasHeight, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas();
        canvas.setBitmap(mBitmap);

        for (AbstractDraw abstractDraw : abstractDrawList) {
            abstractDraw.draw(canvas);
        }

        bDrawFinished = true;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        if (bDrawFinished) {
            canvas.drawBitmap(mBitmap, 0, 0, new Paint());
            mBitmap.recycle();
            bDrawFinished = false;
        }
    }

    public float getCanvasHeight() {
        return mCanvasHeight;
    }

    public void setCanvasHeight(float mCanvasHeight) {
        this.mCanvasHeight = mCanvasHeight;
    }

    public float getCanvasWidth() {
        return mCanvasWidth;
    }

    public void setCanvasWidth(float mCanvasWidth) {
        this.mCanvasWidth = mCanvasWidth;
    }

    public float getCanvasX() {
        return mCanvasX;
    }

    public void setCanvasX(float mCanvasX) {
        this.mCanvasX = mCanvasX;
    }

    public float getCanvasY() {
        return mCanvasY;
    }

    public void setCanvasY(float mCanvasY) {
        this.mCanvasY = mCanvasY;
    }
}


text:
import java.util.Collections;
import java.util.List;

public class MinMaxPlayer implements Player {
    private final int level;

    MinMaxPlayer(int level) {
        this.level = level;
    }

    public Move getMove(Board board) {
        return getMove(board, level);
    }

    private Move getMove(Board board, int depth) {
        List<Move> moves = board.getMoves();
        Collections.shuffle(moves);
        Move bestMove = null;

        for (Move move : moves) {
            Board child = board.clone();
            child.makeMove(move);

            if (depth < 1 && !move.jump) {
                move.score = -eval(child);
            } else {
                Move result = getMove(child, depth - 1);
                move.score = result == null ? Integer.MAX_VALUE : -result.score;
            }

            if (depth == 6) {
                System.out.println(move);
            }

            if (bestMove == null || move.score > bestMove.score) {
                bestMove = move;
            }
        }

        return bestMove;
    }

    /*private static int eval(Board board) {
        int player = 0;
        int opponent = 0;

        // prowadzi ten kto ma więcej pionków na planszy
        for (int y = 0; y < Board.height; y++) {
            for (int x = 0; x < Board.width; x++) {
                if (board.getPlayer(x, y) == board.turnHolder) {
                    player += board.getPiece(x, y);
                } else {
                    opponent += board.getPiece(x, y);
                }
            }
        }

        return player - opponent;
    }*/

    private static int eval(Board board) {
        int player = 0;
        int opponent = 0;

        for (int y = 0; y < Board.height; y++) {
            for (int x = 0; x < Board.width; x++) {
                if (board.getPlayer(x, y) == board.turnHolder) {
                    player += board.getPiece(x, y);
                } else {
                    opponent += board.getPiece(x, y);
                }
            }
        }

        return player - opponent;
    }

    @Override
    public String toString() {
        return "MinMax (" + level + ")";
    }

    @Override
    public boolean isHuman() {
        return false;
    }
}


text:
using BeYourMarket.Model.Models;
using Repository.Pattern.Repositories;
using Service.Pattern;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BeYourMarket.Service
{
    public interface IPictureService : IService<Picture>
    {
    }

    public class PictureService : Service<Picture>, IPictureService
    {
        public PictureService(IRepositoryAsync<Picture> repository)
            : base(repository)
        {
        }
    }
}


text:
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings  #-}
-- | Add <http://content-security-policy.com/ CSP> headers to Yesod apps.
-- This helps reduce the risk of exposure to XSS and bad assets.
module Yesod.Csp (
  cspPolicy
  , getCspPolicy
  , cspMiddleware
  , EscapedURI
  , escapeAndParseURI
  , escapedTextForNonce
  , nonce
  , DirectiveList
  , Directive(..)
  , SourceList
  , Source(..)
  , SandboxOptions(..)
  , textSource
  ) where

import qualified Data.CaseInsensitive as CI
import           Data.Data          (Data)
import           Data.List.NonEmpty
import           Data.Text
import qualified Data.Text          as T
import qualified Data.Text.Encoding as TE
import           Data.Typeable      (Typeable)
import           Network.URI
import           Yesod.Core
import           Network.Wai        (Middleware, mapResponseHeaders,
                                     modifyResponse)

-- | Adds a "Content-Security-Policy" header to your response.
--
-- > getExample1R :: Handler Html
-- > getExample1R = do
-- >   -- only allow scripts from my website
-- >   cspPolicy [ScriptSrc (Self :| [])]
-- >   defaultLayout $ do
-- >     addScriptRemote "http://httpbin.org/i_am_external"
-- >     [whamlet|hello|]
--
cspPolicy :: (MonadHandler m) => DirectiveList -> m ()
cspPolicy = addHeader cspHeaderName . directiveListToHeader

cspHeaderName :: Text
cspHeaderName = "Content-Security-Policy"

-- | Returns a generated Content-Security-Policy header.
getCspPolicy :: DirectiveList -> Text
getCspPolicy = directiveListToHeader

-- | Creates a WAI 'Middleware' to add a Content-Security-Policy
-- header to every response.
cspMiddleware :: DirectiveList -> Middleware
cspMiddleware = addHeaderMiddleware . mkHeader . directiveListToHeader
  where
    addHeaderMiddleware = modifyResponse . mapResponseHeaders . insertAt 5
    mkHeader dltext = (cspHeaderNameBS, TE.encodeUtf8 dltext)
    cspHeaderNameBS = CI.mk $ TE.encodeUtf8 cspHeaderName

insertAt :: Int -> a -> [a] -> [a]
insertAt n x xs =
  let (h, t) = Prelude.splitAt n xs
  in h ++ x : t

newtype EscapedURI = EscapedURI { uri :: URI } deriving (Eq, Data, Typeable)

newtype EscapedText = EscapedText { text :: String } deriving (Eq, Data, Typeable)

instance Show EscapedURI where
  show x = show (uri x)

instance Show EscapedText where
  show x = mconcat ["'nonce-", text x, "'"]

toEscape :: String
toEscape = ";'* "

notEscapable :: Char -> Bool
notEscapable = not . flip elem toEscape

-- | Escapes ';' '\'' and ' ', and parses to URI
escapeAndParseURI :: Text -> Maybe EscapedURI
escapeAndParseURI = fmap EscapedURI . parseURI . escapeURIString notEscapable . unpack

-- | Escapes Text to be a valid nonce value
escapedTextForNonce :: String -> EscapedText
escapedTextForNonce = EscapedText . Prelude.filter notEscapable

-- | Escapes a Text value, returning a valid Nonce
nonce :: Text -> Source
nonce = Nonce . escapedTextForNonce . unpack

directiveListToHeader :: DirectiveList -> Text
directiveListToHeader = intercalate "; " . fmap textDirective

w :: Text -> SourceList -> Text
w = wrap

wrap :: Text -> SourceList -> Text
wrap k x = mconcat [k, " ", textSourceList x]

textSourceList :: SourceList -> Text
textSourceList = T.unwords . toList . filtered
  where filtered = fmap textSource . filterOut

-- * and none should be alone if present
filterOut :: SourceList -> SourceList
filterOut x | Wildcard `elem` x = Wildcard :| []
filterOut x | None `elem` x = None :| []
            | otherwise = x

-- | Represents a location from which assets may be loaded.
data Source = Wildcard
              | None
              | Self
              | DataScheme
              | Host EscapedURI
              | Https
              | UnsafeInline
              | UnsafeEval
              | StrictDynamic
              | Nonce EscapedText
              | MetaSource Text deriving (Eq, Show, Data, Typeable)

-- | A list of allowed sources for a directive.
type SourceList = NonEmpty Source

textSource :: Source -> Text
textSource Wildcard = "*"
textSource None = "'none'"
textSource Self = "'self'"
textSource DataScheme = "data:"
textSource (Host x) = (pack . show) x
textSource Https = "https:"
textSource UnsafeInline = "'unsafe-inline'"
textSource UnsafeEval = "'unsafe-eval'"
textSource StrictDynamic = "'strict-dynamic'"
textSource (MetaSource _) = ""
textSource (Nonce x) = (pack . show) x

-- | A list of restrictions to apply.
type DirectiveList = [Directive]

-- | A restriction on how assets can be loaded.
-- For example @ImgSrc@ concerns where images may be loaded from.
data Directive = DefaultSrc SourceList
                 | ScriptSrc SourceList
                 | StyleSrc SourceList
                 | ImgSrc SourceList
                 | ConnectSrc SourceList
                 | FontSrc SourceList
                 | ObjectSrc SourceList
                 | MediaSrc SourceList
                 | FrameSrc SourceList
                 | FrameAncestors SourceList
                 -- | Applies a sandbox to the result. <http://content-security-policy.com/ See here> for more info.
                 | Sandbox [SandboxOptions]
                 | ReportUri EscapedURI deriving (Eq, Show, Data, Typeable)

-- | Configuration options for the sandbox.
data SandboxOptions = AllowForms
                      | AllowScripts
                      | AllowSameOrigin
                      | AllowTopNavigation deriving (Eq, Show, Data, Typeable)

textDirective :: Directive -> Text
textDirective (DefaultSrc x) = w "default-src" x
textDirective (ScriptSrc x) =  w "script-src" x
textDirective (StyleSrc x) =  w "style-src" x
textDirective (ImgSrc x) =  w "img-src" x
textDirective (ConnectSrc x) =  w "connect-src" x
textDirective (FontSrc x) =  w "font-src" x
textDirective (ObjectSrc x) =  w "object-src" x
textDirective (MediaSrc x) =  w "media-src" x
textDirective (FrameSrc x) =  w "frame-src" x
textDirective (FrameAncestors x) =  w "frame-ancestors" x
textDirective (ReportUri t) = mconcat ["report-uri ", (pack . show) t]
textDirective (Sandbox []) = "sandbox"
textDirective (Sandbox s) = mconcat ["sandbox ", T.unwords . fmap textSandbox $ s]
  where textSandbox AllowForms = "allow-forms"
        textSandbox AllowScripts = "allow-scripts"
        textSandbox AllowSameOrigin = "allow-same-origin"
        textSandbox AllowTopNavigation = "allow-top-navigation"


text:
{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}

-- !!! Mis-matched contexts in a mutually recursive group

{-  # LANGUAGE NoRelaxedPolyRec #-}
-- With the new type checker you can't turn off RelaxedPolyRec
-- so this test always succeeds

module ShouldFail where

f :: (Ord d) => d -> d
f c = g c

g :: e -> e
g c = c
  where p = f (1 :: Int)


text:
#ifndef __included_vpp_echo_common_h__
#define __included_vpp_echo_common_h__

#include <vnet/session/application_interface.h>
#include <vpp/api/vpe_msg_enum.h>

#define vl_typedefs		/* define message structures */
#include <vpp/api/vpe_all_api_h.h>
#undef vl_typedefs

/* declare message handlers for each api */

#define vl_endianfun		/* define message structures */
#include <vpp/api/vpe_all_api_h.h>
#undef vl_endianfun

/* instantiate all the print functions we know about */
#define vl_print(handle, ...)
#define vl_printfun
#include <vpp/api/vpe_all_api_h.h>
#undef vl_printfun

#define TIMEOUT 10.0
#define LOGGING_BATCH (100)
#define LOG_EVERY_N_IDLE_CYCLES (1e8)

#define foreach_echo_fail_code                                          \
  _(ECHO_FAIL_NONE, "ECHO_FAIL_NONE")                                   \
  _(ECHO_FAIL_USAGE, "ECHO_FAIL_USAGE")                                 \
  _(ECHO_FAIL_SEND_IO_EVT, "ECHO_FAIL_SEND_IO_EVT")                     \
  _(ECHO_FAIL_SOCKET_CONNECT, "ECHO_FAIL_SOCKET_CONNECT")               \
  _(ECHO_FAIL_INIT_SHM_API, "ECHO_FAIL_INIT_SHM_API")                   \
  _(ECHO_FAIL_SHMEM_CONNECT, "ECHO_FAIL_SHMEM_CONNECT")                 \
  _(ECHO_FAIL_TEST_BYTES_ERR, "ECHO_FAIL_TEST_BYTES_ERR")               \
  _(ECHO_FAIL_BIND, "ECHO_FAIL_BIND")                                   \
  _(ECHO_FAIL_SESSION_ACCEPTED_BAD_LISTENER,                            \
    "ECHO_FAIL_SESSION_ACCEPTED_BAD_LISTENER")                          \
  _(ECHO_FAIL_ACCEPTED_WAIT_FOR_SEG_ALLOC,                              \
    "ECHO_FAIL_ACCEPTED_WAIT_FOR_SEG_ALLOC")                            \
  _(ECHO_FAIL_SESSION_CONNECT, "ECHO_FAIL_SESSION_CONNECT")             \
  _(ECHO_FAIL_CONNECTED_WAIT_FOR_SEG_ALLOC,                             \
    "ECHO_FAIL_CONNECTED_WAIT_FOR_SEG_ALLOC")                           \
  _(ECHO_FAIL_APP_ATTACH, "ECHO_FAIL_APP_ATTACH")                       \
  _(ECHO_FAIL_SERVER_DISCONNECT_TIMEOUT,                                \
    "ECHO_FAIL_SERVER_DISCONNECT_TIMEOUT")                              \
  _(ECHO_FAIL_INVALID_URI, "ECHO_FAIL_INVALID_URI")                     \
  _(ECHO_FAIL_PROTOCOL_NOT_SUPPORTED,                                   \
    "ECHO_FAIL_PROTOCOL_NOT_SUPPORTED")                                 \
  _(ECHO_FAIL_CONNECT_TO_VPP, "ECHO_FAIL_CONNECT_TO_VPP")               \
  _(ECHO_FAIL_ATTACH_TO_VPP, "ECHO_FAIL_ATTACH_TO_VPP")                 \
  _(ECHO_FAIL_1ST_PTHREAD_CREATE, "ECHO_FAIL_1ST_PTHREAD_CREATE")       \
  _(ECHO_FAIL_PTHREAD_CREATE, "ECHO_FAIL_PTHREAD_CREATE")               \
  _(ECHO_FAIL_DETACH, "ECHO_FAIL_DETACH")                               \
  _(ECHO_FAIL_DEL_CERT_KEY, "ECHO_FAIL_DEL_CERT_KEY")                               \
  _(ECHO_FAIL_MQ_PTHREAD, "ECHO_FAIL_MQ_PTHREAD")                       \
  _(ECHO_FAIL_VL_API_APP_ATTACH, "ECHO_FAIL_VL_API_APP_ATTACH")         \
  _(ECHO_FAIL_VL_API_MISSING_SEGMENT_NAME,                              \
    "ECHO_FAIL_VL_API_MISSING_SEGMENT_NAME")                            \
  _(ECHO_FAIL_VL_API_NULL_APP_MQ, "ECHO_FAIL_VL_API_NULL_APP_MQ")       \
  _(ECHO_FAIL_VL_API_RECV_FD_MSG, "ECHO_FAIL_VL_API_RECV_FD_MSG")       \
  _(ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,                               \
    "ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH")                             \
  _(ECHO_FAIL_VL_API_FIFO_SEG_ATTACH,                                   \
    "ECHO_FAIL_VL_API_FIFO_SEG_ATTACH")                                 \
  _(ECHO_FAIL_VL_API_DETACH_REPLY, "ECHO_FAIL_VL_API_DETACH_REPLY")     \
  _(ECHO_FAIL_VL_API_BIND_URI_REPLY, "ECHO_FAIL_VL_API_BIND_URI_REPLY") \
  _(ECHO_FAIL_VL_API_UNBIND_REPLY, "ECHO_FAIL_VL_API_UNBIND_REPLY")     \
  _(ECHO_FAIL_SESSION_DISCONNECT, "ECHO_FAIL_SESSION_DISCONNECT")       \
  _(ECHO_FAIL_SESSION_RESET, "ECHO_FAIL_SESSION_RESET")                 \
  _(ECHO_FAIL_VL_API_CERT_KEY_ADD_REPLY,                                \
    "ECHO_FAIL_VL_API_CERT_KEY_ADD_REPLY")                              \
  _(ECHO_FAIL_VL_API_CERT_KEY_DEL_REPLY,                                \
    "ECHO_FAIL_VL_API_CERT_KEY_DEL_REPLY")                              \
  _(ECHO_FAIL_GET_SESSION_FROM_HANDLE,                                  \
    "ECHO_FAIL_GET_SESSION_FROM_HANDLE")                                \
  _(ECHO_FAIL_QUIC_WRONG_CONNECT, "ECHO_FAIL_QUIC_WRONG_CONNECT")       \
  _(ECHO_FAIL_QUIC_WRONG_ACCEPT, "ECHO_FAIL_QUIC_WRONG_ACCEPT")         \
  _(ECHO_FAIL_TCP_BAPI_CONNECT, "ECHO_FAIL_TCP_BAPI_CONNECT")           \
  _(ECHO_FAIL_UDP_BAPI_CONNECT, "ECHO_FAIL_UDP_BAPI_CONNECT")           \
  _(ECHO_FAIL_MISSING_START_EVENT, "ECHO_FAIL_MISSING_START_EVENT")     \
  _(ECHO_FAIL_MISSING_END_EVENT, "ECHO_FAIL_MISSING_END_EVENT")         \
  _(ECHO_FAIL_TEST_ASSERT_RX_TOTAL, "ECHO_FAIL_TEST_ASSERT_RX_TOTAL")   \
  _(ECHO_FAIL_UNIDIRECTIONAL, "ECHO_FAIL_UNIDIRECTIONAL")               \
  _(ECHO_FAIL_TEST_ASSERT_TX_TOTAL, "ECHO_FAIL_TEST_ASSERT_TX_TOTAL")   \
  _(ECHO_FAIL_TEST_ASSERT_ALL_SESSIONS_CLOSED,                          \
    "ECHO_FAIL_TEST_ASSERT_ALL_SESSIONS_CLOSED")                        \
  _(ECHO_FAIL_RPC_SIZE, "ECHO_FAIL_RPC_SIZE")

typedef enum
{
#define _(sym, str) sym,
  foreach_echo_fail_code
#undef _
} echo_fail_t;

extern char *echo_fail_code_str[];

#define CHECK_SAME(fail, expected, result, _fmt, _args...)      \
do {                                                            \
  if ((expected) != (result))                                   \
    ECHO_FAIL ((fail), "expected same (%lld, got %lld) : "_fmt, \
               (u64)(expected), (u64)(result), ##_args);        \
} while (0)

#define CHECK_DIFF(fail, expected, result, _fmt, _args...)      \
do {                                                            \
  if ((expected) == (result))                                   \
    ECHO_FAIL ((fail), "expected different (both %lld) : "_fmt, \
               (u64)(expected), ##_args);                       \
} while (0)

#define ECHO_FAIL(fail, _fmt, _args...)                                 \
do {                                                                    \
    echo_main_t *em = &echo_main;                                       \
    em->has_failed = (fail);                                            \
    if (vec_len(em->fail_descr))                                        \
      em->fail_descr = format(em->fail_descr, " | %s (%u): "_fmt,       \
                              echo_fail_code_str[fail], fail, ##_args); \
    else                                                                \
      em->fail_descr = format(0, "%s (%u): "_fmt,                       \
                              echo_fail_code_str[fail], fail, ##_args); \
    em->time_to_stop = 1;                                               \
    if (em->log_lvl > 0)                                                \
      clib_warning ("%v", em->fail_descr);                              \
} while (0)

#define ECHO_LOG(lvl, _fmt,_args...)    \
  {                                     \
    echo_main_t *em = &echo_main;       \
    if (em->log_lvl > lvl)              \
         clib_warning (_fmt, ##_args);  \
  }

#define ECHO_REGISTER_PROTO(proto, vft)         \
  static void __clib_constructor                \
  vpp_echo_init_##proto ()                      \
  {                                             \
    echo_main_t *em = &echo_main;               \
    em->available_proto_cb_vft[proto] = &vft;   \
  }

typedef struct
{
  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
#define _(type, name) type name;
  foreach_app_session_field
#undef _
  u64 vpp_session_handle;
  u64 bytes_sent;
  u64 bytes_to_send;
  volatile u64 bytes_received;
  volatile u64 bytes_to_receive;
  f64 start;
  u32 listener_index;		/* listener index in echo session pool */
  u32 idle_cycles;		/* consecutive enq/deq with no data */
  volatile u64 accepted_session_count;	/* sessions we accepted (as a listener) */
} echo_session_t;

typedef enum
{
  ECHO_NO_DATA_SOURCE,
  ECHO_TEST_DATA_SOURCE,
  ECHO_RX_DATA_SOURCE,
  ECHO_INVALID_DATA_SOURCE
} data_source_t;

enum echo_close_f_t
{
  ECHO_CLOSE_F_INVALID = 0,
  ECHO_CLOSE_F_PASSIVE,		/* wait for close msg */
  ECHO_CLOSE_F_ACTIVE,		/* send close msg */
  ECHO_CLOSE_F_NONE,		/* don't bother sending close msg */
};

enum quic_session_type_t
{
  ECHO_SESSION_TYPE_QUIC,
  ECHO_SESSION_TYPE_STREAM,
  ECHO_SESSION_TYPE_LISTEN,
};

enum quic_session_state_t
{
  ECHO_SESSION_STATE_INITIAL,
  ECHO_SESSION_STATE_READY,
  ECHO_SESSION_STATE_AWAIT_CLOSING,	/* Data transfer is done, wait for close evt */
  ECHO_SESSION_STATE_AWAIT_DATA,	/* Peer closed, wait for outstanding data */
  ECHO_SESSION_STATE_CLOSING,	/* told vpp to close */
  ECHO_SESSION_STATE_CLOSED,	/* closed in vpp */
};

typedef enum
{
  STATE_START,
  STATE_ATTACHED_NO_CERT,
  STATE_ATTACHED,
  STATE_LISTEN,
  STATE_READY,
  STATE_DATA_DONE,
  STATE_DISCONNECTED,
  STATE_CLEANED_CERT_KEY,
  STATE_DETACHED
} connection_state_t;

typedef enum echo_test_evt_
{
  ECHO_EVT_START = 1,		/* app starts */
  ECHO_EVT_FIRST_QCONNECT = (1 << 1),	/* First connect Quic session sent */
  ECHO_EVT_LAST_QCONNECTED = (1 << 2),	/* All Quic session are connected */
  ECHO_EVT_FIRST_SCONNECT = (1 << 3),	/* First connect Stream session sent */
  ECHO_EVT_LAST_SCONNECTED = (1 << 4),	/* All Stream session are connected */
  ECHO_EVT_LAST_BYTE = (1 << 5),	/* Last byte received */
  ECHO_EVT_EXIT = (1 << 6),	/* app exits */
} echo_test_evt_t;

typedef union session_connected_bundled_msg_
{
  session_connected_msg_t *mp;
  vl_api_connect_uri_reply_t *bmp;
} session_connected_bundled_msg_t;

typedef struct echo_proto_cb_vft_
{
  void (*connected_cb) (session_connected_bundled_msg_t * mp, u32 session_index, u8 is_failed);	/* Session is connected */
  void (*accepted_cb) (session_accepted_msg_t * mp, echo_session_t * session);	/* Session got accepted */
  void (*bound_uri_cb) (session_bound_msg_t * mp, echo_session_t * session);	/* Session got bound */
  void (*reset_cb) (session_reset_msg_t * mp, echo_session_t * s);	/* Received RESET on session */
  void (*disconnected_cb) (session_disconnected_msg_t * mp, echo_session_t * s);	/* Received DISCONNECT on session */
  void (*sent_disconnect_cb) (echo_session_t * s);	/* ACK disconnect we sent to vpp */
  void (*cleanup_cb) (echo_session_t * s, u8 parent_died);	/* Session should be cleaned up (parent listener may be dead) */
  /* Add CLI options */
  int (*process_opts_cb) (unformat_input_t * a);
  void (*set_defaults_before_opts_cb) (void);
  void (*set_defaults_after_opts_cb) (void);
  void (*print_usage_cb) (void);
} echo_proto_cb_vft_t;

typedef enum
{
  RETURN_PACKETS_NOTEST,
  RETURN_PACKETS_LOG_WRONG,
  RETURN_PACKETS_ASSERT,
} test_return_packets_t;

typedef struct teardown_stat_
{
  u32 q;			/* quic sessions */
  u32 s;			/* stream sessions */
} teardown_stat_t;

typedef struct echo_stats_
{
  u64 tx_total;
  u64 rx_total;
  u64 tx_expected;
  u64 rx_expected;
  teardown_stat_t reset_count;	/* received reset from vpp */
  teardown_stat_t close_count;	/* received close from vpp */
  teardown_stat_t active_count;	/* sent close to vpp */
  teardown_stat_t clean_count;	/* cleaned up stale session */
  teardown_stat_t connected_count;	/* connected sessions count */
  teardown_stat_t accepted_count;	/* connected sessions count */
} echo_stats_t;

typedef struct
{
  svm_queue_t *vl_input_queue;	/* vpe input queue */
  u32 my_client_index;		/* API client handle */
  u8 *uri;			/* The URI we're playing with */
  u32 n_uris;			/* Cycle through adjacent ips */
  ip46_address_t lcl_ip;	/* Local ip for client */
  u8 lcl_ip_set;
  echo_session_t *sessions;	/* Session pool */
  svm_msg_q_t *app_mq;		/* Our receiveing event queue */
  svm_msg_q_t *ctrl_mq;		/* Our control queue (towards vpp) */
  clib_time_t clib_time;	/* For deadman timers */
  u8 *socket_name;
  int i_am_master;
  u32 *listen_session_indexes;	/* vec of vpp listener sessions */
  volatile u32 listen_session_cnt;

  uword *session_index_by_vpp_handles;	/* Hash table : quic_echo s_id -> vpp s_handle */
  clib_spinlock_t sid_vpp_handles_lock;	/* Hash table lock */

  uword *shared_segment_handles;	/* Hash table : segment_names -> 1 */
  clib_spinlock_t segment_handles_lock;	/* Hash table lock */
  echo_proto_cb_vft_t *proto_cb_vft;
  svm_msg_q_t *rpc_msq_queue;	/* MQ between quic_echo threads */
  fifo_segment_main_t segment_main;

  /* State of the connection, shared between msg RX thread and main thread */
  volatile connection_state_t state;
  volatile u8 time_to_stop;	/* Signal variables */
  u8 rx_results_diff;		/* Rx results will be different than cfg */
  u8 tx_results_diff;		/* Tx results will be different than cfg */
  u8 has_failed;		/* stores the exit code */
  u8 *fail_descr;		/* vector containing fail description */

  /** Flag that decides if socket, instead of svm, api is used to connect to
   * vpp. If sock api is used, shm binary api is subsequently bootstrapped
   * and all other messages are exchanged using shm IPC. */
  u8 use_sock_api;

  u8 *connect_test_data;
  u8 test_return_packets;
  u64 bytes_to_send;		/* target per stream */
  u64 bytes_to_receive;		/* target per stream */
  u32 fifo_size;
  u32 prealloc_fifo_pairs;
  u64 rx_buf_size;
  u64 tx_buf_size;
  data_source_t data_source;	/* Use no/dummy/mirrored data */
  u8 send_stream_disconnects;	/* actively send disconnect */
  u8 output_json;		/* Output stats as JSON */
  volatile u8 wait_for_gdb;	/* Wait for gdb to attach */
  u8 log_lvl;			/* Verbosity of the logging */
  int max_test_msg;		/* Limit the number of incorrect data messages */
  u32 evt_q_size;		/* Size of the vpp MQ (app<->vpp events) */
  u32 ckpair_index;		/* Cert key pair used */
  u8 crypto_engine;		/* crypto engine used */
  u8 connect_flag;		/* flags to pass to mq connect */
  u32 periodic_stats_delta;	/* seconds between periodic stats */

  u8 *appns_id;
  u64 appns_flags;
  u64 appns_secret;

  pthread_t *data_thread_handles;	/* vec of data thread handles */
  pthread_t mq_thread_handle;	/* Message queue thread handle */
  u32 *volatile data_thread_args;

  u32 n_connects;		/* Target number of connects to send */
  u32 n_sessions;		/* Number of sessions to prealloc */
  u32 n_clients;		/* Target number of clients doing RX/TX */
  u32 n_rx_threads;		/* Number of data threads */

  volatile u32 n_clients_connected;	/* Number of STREAM sessions connected */
  volatile u32 nxt_available_sidx;	/* next unused prealloced session_index */

  volatile int max_sim_connects;

  /* VNET_API_ERROR_FOO -> "Foo" hash table */
  uword *error_string_by_error_number;
  echo_proto_cb_vft_t *available_proto_cb_vft[TRANSPORT_N_PROTO];

  echo_stats_t stats;
  echo_stats_t last_stat_sampling;	/* copy of stats at last sampling */
  f64 last_stat_sampling_ts;

  struct			/* Event based timing : start & end depend on CLI specified events */
  {
    f64 start_time;
    f64 end_time;
    u8 events_sent;
    u8 start_event;
    u8 end_event;
  } timing;

  struct
  {
    u32 transport_proto;
    ip46_address_t ip;
    u32 port;
    u8 is_ip4;
  } uri_elts;
} echo_main_t;

extern echo_main_t echo_main;

typedef struct echo_connect_args_
{
  u32 context;
  u64 parent_session_handle;
  ip46_address_t ip;
  ip46_address_t lcl_ip;
} echo_connect_args_t;

typedef struct echo_disconnect_args_
{
  u64 session_handle;
} echo_disconnect_args_t;

typedef union
{
  echo_connect_args_t connect;
  echo_disconnect_args_t disconnect;
} echo_rpc_args_t;

typedef void (*echo_rpc_t) (echo_main_t * em, echo_rpc_args_t * arg);

typedef struct
{
  void *fp;
  echo_rpc_args_t args;
} echo_rpc_msg_t;

u8 *format_ip4_address (u8 * s, va_list * args);
u8 *format_ip6_address (u8 * s, va_list * args);
u8 *format_ip46_address (u8 * s, va_list * args);
u8 *format_api_error (u8 * s, va_list * args);
void init_error_string_table ();
u8 *echo_format_session (u8 * s, va_list * args);
u8 *echo_format_session_type (u8 * s, va_list * args);
u8 *echo_format_session_state (u8 * s, va_list * args);
u8 *echo_format_app_state (u8 * s, va_list * args);
uword echo_unformat_close (unformat_input_t * input, va_list * args);
uword echo_unformat_timing_event (unformat_input_t * input, va_list * args);
u8 *echo_format_timing_event (u8 * s, va_list * args);
uword unformat_transport_proto (unformat_input_t * input, va_list * args);
u8 *format_transport_proto (u8 * s, va_list * args);
uword unformat_ip4_address (unformat_input_t * input, va_list * args);
uword unformat_ip6_address (unformat_input_t * input, va_list * args);

void echo_session_handle_add_del (echo_main_t * em, u64 handle, u32 sid);
echo_session_t *echo_session_new (echo_main_t * em);
int echo_send_rpc (echo_main_t * em, void *fp, echo_rpc_args_t * args);
echo_session_t *echo_get_session_from_handle (echo_main_t * em, u64 handle);
int wait_for_state_change (echo_main_t * em, connection_state_t state,
			   f64 timeout);
void echo_notify_event (echo_main_t * em, echo_test_evt_t e);
void echo_session_print_stats (echo_main_t * em, echo_session_t * session);
u8 *echo_format_crypto_engine (u8 * s, va_list * args);
uword echo_unformat_crypto_engine (unformat_input_t * input, va_list * args);
u8 *echo_format_bytes_per_sec (u8 * s, va_list * args);
int echo_ssvm_segment_attach (char *name, ssvm_segment_type_t type, int fd);
void echo_segment_handle_add_del (echo_main_t * em, u64 segment_handle,
				  u8 add);

/* Binary API */

void echo_send_attach (echo_main_t * em);
void echo_send_detach (echo_main_t * em);
void echo_send_listen (echo_main_t * em, ip46_address_t * ip);
void echo_send_unbind (echo_main_t * em, echo_session_t * s);
void echo_send_connect (echo_main_t * em, void *args);
void echo_send_disconnect_session (echo_main_t * em, void *args);
void echo_api_hookup (echo_main_t * em);
void echo_send_add_cert_key (echo_main_t * em);
void echo_send_del_cert_key (echo_main_t * em);

#endif /* __included_vpp_echo_common_h__ */

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */


text:
package eu.julxzs.julxzscraft.item;

public class ItemFlour extends ItemJC
{
	public ItemFlour()
	{
		super();
		this.setUnlocalizedName("flour");
	}
}


text:
		User Event
		List

<?php echo anchor('home',' Home')?>

List

			<?php echo $add_btn?>
			<?php echo $delete_btn?>

			<?php echo form_open($action,array('class'=>'form-inline'))?>

					<?php echo form_label('Show entries','limit')?>
					<?php echo form_dropdown('limit',array('10'=>'10','50'=>'50','100'=>'100'),set_value('limit',$this->input->get('limit')),'onchange="submit()" class="form-control input-sm"')?>

					<?php echo form_input(array('name'=>'search','value'=>$this->input->get('search'),'autocomplete'=>'off','placeholder'=>'Search..','onchange=>"submit()"','class'=>'form-control input-sm'))?>

					<?php echo form_dropdown('user',$this->master_model->dropdown('user','User'),$this->input->get('user'),'class="form-control input-sm" onchange="submit()"')?>

					<?php echo form_dropdown('event',$this->master_model->dropdown('event','Event'),$this->input->get('event'),'class="form-control input-sm" onchange="submit()"')?>

			<?php echo form_close()?>
			<?php echo form_open($action_delete,array('class'=>'form-check-delete'))?>

				<?php echo $table?>

			<?php echo form_close()?>

			<?php echo form_label($total,'',array('class'=>'label-footer'))?>

				<?php echo $pagination?>


text:
package org.ensembl.healthcheck;

import java.util.List;

import org.ensembl.healthcheck.testcase.EnsTestCase;
import org.ensembl.healthcheck.testcase.MultiDatabaseTestCase;
import org.ensembl.healthcheck.testcase.OrderedDatabaseTestCase;
import org.ensembl.healthcheck.testcase.SingleDatabaseTestCase;

/**
 * Hold information about tests. Can also find tests in a particular location.
 */
public interface TestRegistry {
	/**
	 * @param groupsToRun
	 * @param type
	 * @return
	 */
	public List<SingleDatabaseTestCase> getAllSingle(List<String> groupsToRun,
			DatabaseType type);

	/**
	 * @param groupsToRun
	 * @return list of tests belonging to those groups
	 */
	public List<MultiDatabaseTestCase> getAllMulti(List<String> groupsToRun);

	/**
	 * @param groups list of group names
	 * @return list of tests belonging to those groups
	 */
	public List<OrderedDatabaseTestCase> getAllOrdered(List<String> groups);

	/**
	 * @return all tests in the registry
	 */
	public List<EnsTestCase> getAll();

	/**
	 * @return all types covered by the registered tests
	 */
	public DatabaseType[] getTypes();

	/**
	 * @param type
	 * @return groups applicable to the supplied type
	 */
	public String[] getGroups(DatabaseType type);

	/**
	 * Return list of tests for the given group
	 * @param string group name
	 * @param type database type
	 * @return list of test objects
	 */
	public EnsTestCase[] getTestsInGroup(String string, DatabaseType type);

}


text:
package collectors

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"path/filepath"
	"regexp"
	"strings"
	"time"

	"bosun.org/cmd/scollector/conf"
	"bosun.org/metadata"
	"bosun.org/opentsdb"
	"bosun.org/util"
)

func init() {
	registerInit(func(c *conf.Conf) {
		if c.IfaceExpr != "" {
			ifstatRE = regexp.MustCompile(fmt.Sprintf("(%s):(.*)", c.IfaceExpr))
		}

		collectors = append(collectors, &IntervalCollector{F: c_ifstat_linux})
		collectors = append(collectors, &IntervalCollector{F: c_ipcount_linux})
		collectors = append(collectors, &IntervalCollector{F: c_if_team_linux})
		collectors = append(collectors, &IntervalCollector{F: c_if_bond_linux})
	})
}

var netFields = []struct {
	key  string
	rate metadata.RateType
	unit metadata.Unit
}{
	{"bytes", metadata.Counter, metadata.Bytes},
	{"packets", metadata.Counter, metadata.Count},
	{"errs", metadata.Counter, metadata.Count},
	{"dropped", metadata.Counter, metadata.Count},
	{"fifo.errs", metadata.Counter, metadata.Count},
	{"frame.errs", metadata.Counter, metadata.Count},
	{"compressed", metadata.Counter, metadata.Count},
	{"multicast", metadata.Counter, metadata.Count},
	{"bytes", metadata.Counter, metadata.Bytes},
	{"packets", metadata.Counter, metadata.Count},
	{"errs", metadata.Counter, metadata.Count},
	{"dropped", metadata.Counter, metadata.Count},
	{"fifo.errs", metadata.Counter, metadata.Count},
	{"collisions", metadata.Counter, metadata.Count},
	{"carrier.errs", metadata.Counter, metadata.Count},
	{"compressed", metadata.Counter, metadata.Count},
}

var ifstatRE = regexp.MustCompile(`\s*(eth\d+|em\d+_\d+/\d+|em\d+_\d+|em\d+|` +
	`bond\d+|team\d+|` +
	`p\d+p\d+_\d+/\d+|p\d+p\d+_\d+|p\d+p\d+|` +
	`en[[:alnum:]]+|wl[[:alnum:]]+|ww[[:alnum:]]+` + // Systemd predictable interface names
	`):(.*)`)

func c_ipcount_linux() (opentsdb.MultiDataPoint, error) {
	var md opentsdb.MultiDataPoint
	v4c := 0
	v6c := 0
	err := util.ReadCommand(func(line string) error {
		tl := strings.TrimSpace(line)
		if strings.HasPrefix(tl, "inet ") {
			v4c++
		}
		if strings.HasPrefix(tl, "inet6 ") {
			v6c++
		}
		return nil
	}, "ip", "addr", "list")
	if err != nil {
		return md, err
	}
	Add(&md, "linux.net.ip_count", v4c, opentsdb.TagSet{"version": "4"}, metadata.Gauge, "IP_Addresses", "")
	Add(&md, "linux.net.ip_count", v6c, opentsdb.TagSet{"version": "6"}, metadata.Gauge, "IP_Addresses", "")
	return md, nil
}

func c_ifstat_linux() (opentsdb.MultiDataPoint, error) {
	var md opentsdb.MultiDataPoint
	direction := func(i int) string {
		if i >= 8 {
			return "out"
		} else {
			return "in"
		}
	}
	err := readLine("/proc/net/dev", func(s string) error {
		m := ifstatRE.FindStringSubmatch(s)
		if m == nil {
			return nil
		}
		intf := m[1]
		stats := strings.Fields(m[2])
		tags := opentsdb.TagSet{"iface": intf}
		var bond_string string
		if strings.HasPrefix(intf, "bond") || strings.HasPrefix(intf, "team") {
			bond_string = "bond."
		}
		// Detect speed of the interface in question
		_ = readLine("/sys/class/net/"+intf+"/speed", func(speed string) error {
			Add(&md, "linux.net."+bond_string+"ifspeed", speed, tags, metadata.Gauge, metadata.Megabit, "")
			Add(&md, "os.net."+bond_string+"ifspeed", speed, tags, metadata.Gauge, metadata.Megabit, "")
			return nil
		})
		for i, v := range stats {
			Add(&md, "linux.net."+bond_string+strings.Replace(netFields[i].key, ".", "_", -1), v, opentsdb.TagSet{
				"iface":     intf,
				"direction": direction(i),
			}, netFields[i].rate, netFields[i].unit, "")
			if i < 4 || (i >= 8 && i < 12) {
				Add(&md, "os.net."+bond_string+strings.Replace(netFields[i].key, ".", "_", -1), v, opentsdb.TagSet{
					"iface":     intf,
					"direction": direction(i),
				}, netFields[i].rate, netFields[i].unit, "")

			}
		}
		return nil
	})
	return md, err
}

const (
	linuxNetBondSlaveIsUpDesc = "The status of the bonded or teamed interface."
	linuxNetBondSlaveCount    = "The number of slaves on the bonded or teamed interface."
)

func c_if_bond_linux() (opentsdb.MultiDataPoint, error) {
	var md opentsdb.MultiDataPoint
	const bondingPath = "/proc/net/bonding"
	bondDevices, err := ioutil.ReadDir(bondingPath)
	if err != nil {
		return md, nil
	}
	for _, fi := range bondDevices {
		var iface string
		var slaveCount int
		if err := readLine(filepath.Join(bondingPath, fi.Name()), func(s string) error {
			f := strings.SplitN(s, ":", 2)
			if len(f) != 2 {
				return nil
			}
			f[0] = strings.TrimSpace(f[0])
			f[1] = strings.TrimSpace(f[1])
			if f[0] == "Slave Interface" {
				iface = f[1]
				slaveCount++
			}
			// TODO: This will probably need to be updated for other types of bonding beside LACP, but I have no examples available to work with at the moment
			if f[0] == "MII Status" && iface != "" {
				var status int
				if f[1] == "up" {
					status = 1
				}
				Add(&md, "linux.net.bond.slave.is_up", status, opentsdb.TagSet{"slave": iface, "bond": fi.Name()}, metadata.Gauge, metadata.Bool, linuxNetBondSlaveIsUpDesc)
			}
			return nil
		}); err != nil {
			return md, err
		}
		Add(&md, "linux.net.bond.slave.count", slaveCount, opentsdb.TagSet{"bond": fi.Name()}, metadata.Gauge, metadata.Count, linuxNetBondSlaveCount)
	}
	return md, nil
}

func c_if_team_linux() (opentsdb.MultiDataPoint, error) {
	var md opentsdb.MultiDataPoint
	getState := func(iname string) (TeamState, error) {
		var ts TeamState
		reader, err := util.Command(time.Second*5, nil, "teamdctl", iname, "state", "dump")
		if err != nil {
			return ts, err
		}
		err = json.NewDecoder(reader).Decode(&ts)
		if err != nil {
			return ts, err
		}
		return ts, nil
	}
	teamdFiles, err := ioutil.ReadDir("/var/run/teamd")
	if err != nil {
		return md, nil
	}
	for _, f := range teamdFiles {
		name := f.Name()
		if strings.HasSuffix(name, ".pid") {
			name = strings.TrimSuffix(name, ".pid")
			ts, err := getState(name)
			if err != nil {
				return md, err
			}
			var slaveCount int
			var speed int64
			for portName, port := range ts.TeamPorts {
				slaveCount++
				speed += int64(port.Link.Speed)
				metadata.AddMeta("", opentsdb.TagSet{"iface": portName}, "master", name, true)
				Add(&md, "linux.net.bond.slave.is_up", port.Link.Up, opentsdb.TagSet{"slave": portName, "bond": name}, metadata.Gauge, metadata.Bool, linuxNetBondSlaveIsUpDesc)
			}
			Add(&md, "os.net.bond.ifspeed", speed, opentsdb.TagSet{"bond": name}, metadata.Gauge, metadata.Megabit, osNetIfSpeedDesc)
			Add(&md, "linux.net.bond.slave.count", slaveCount, opentsdb.TagSet{"bond": name}, metadata.Gauge, metadata.Count, linuxNetBondSlaveCount)
		}
	}
	return md, nil
}

type TeamState struct {
	TeamPorts map[string]TeamPort `json:"ports"`
	Runner    struct {
		Active       bool    `json:"active"`
		FastRate     bool    `json:"fast_rate"`
		SelectPolicy string  `json:"select_policy"`
		SysPrio      float64 `json:"sys_prio"`
	} `json:"runner"`
	Setup struct {
		Daemonized         bool    `json:"daemonized"`
		DbusEnabled        bool    `json:"dbus_enabled"`
		DebugLevel         float64 `json:"debug_level"`
		KernelTeamModeName string  `json:"kernel_team_mode_name"`
		Pid                float64 `json:"pid"`
		PidFile            string  `json:"pid_file"`
		RunnerName         string  `json:"runner_name"`
		ZmqEnabled         bool    `json:"zmq_enabled"`
	} `json:"setup"`
	TeamDevice struct {
		Ifinfo struct {
			DevAddr    string  `json:"dev_addr"`
			DevAddrLen float64 `json:"dev_addr_len"`
			Ifindex    float64 `json:"ifindex"`
			Ifname     string  `json:"ifname"`
		} `json:"ifinfo"`
	} `json:"team_device"`
}

type TeamPort struct {
	Ifinfo struct {
		DevAddr    string  `json:"dev_addr"`
		DevAddrLen float64 `json:"dev_addr_len"`
		Ifindex    float64 `json:"ifindex"`
		Ifname     string  `json:"ifname"`
	}
	Link struct {
		Duplex string  `json:"duplex"`
		Speed  float64 `json:"speed"`
		Up     bool    `json:"up"`
	} `json:"link"`
	LinkWatches struct {
		List struct {
			LinkWatch0 struct {
				DelayDown float64 `json:"delay_down"`
				DelayUp   float64 `json:"delay_up"`
				Name      string  `json:"name"`
				Up        bool    `json:"up"`
			} `json:"link_watch_0"`
		} `json:"list"`
		Up bool `json:"up"`
	} `json:"link_watches"`
	Runner struct {
		ActorLacpduInfo struct {
			Key            float64 `json:"key"`
			Port           float64 `json:"port"`
			PortPriority   float64 `json:"port_priority"`
			State          float64 `json:"state"`
			System         string  `json:"system"`
			SystemPriority float64 `json:"system_priority"`
		} `json:"actor_lacpdu_info"`
		Aggregator struct {
			ID       float64 `json:"id"`
			Selected bool    `json:"selected"`
		} `json:"aggregator"`
		Key               float64 `json:"key"`
		PartnerLacpduInfo struct {
			Key            float64 `json:"key"`
			Port           float64 `json:"port"`
			PortPriority   float64 `json:"port_priority"`
			State          float64 `json:"state"`
			System         string  `json:"system"`
			SystemPriority float64 `json:"system_priority"`
		} `json:"partner_lacpdu_info"`
		Prio     float64 `json:"prio"`
		Selected bool    `json:"selected"`
		State    string  `json:"state"`
	} `json:"runner"`
}