text:
using UnityEngine;
using System;
using System.IO;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using Random = UnityEngine.Random;

public class EnemyFactory : MonoBehaviour {

    [SerializeField]
    GameObject ExplosionPrefab;     //!< 爆発プレハブ

    [SerializeField]
    GameObject EnemyPrefab;     //!< 敵プレハブ

    [SerializeField]
    GameObject[] WallObjects;   //!< 壁から生成する

    public static Dictionary<int, NormalEnemyData.NormalEnemyBulletAI> normalEnemyAiData = new Dictionary<int, NormalEnemyData.NormalEnemyBulletAI>();    //!< 通常敵のAIデータ

    // 外部変数
    public GameObject EnemyBulletBaseObject;    //!< 敵の弾丸生成オブジェクト
    public Animator BossCautionAnim;
    public bool initFlag = false;

    // 内部変数
    private float timer = 0f;
    private int maxId = 0;
    public EnemyFactoryState state = EnemyFactoryState.none;
    private Dictionary<int, NormalEnemyData.EnemyFormation> normalFormData = new Dictionary<int, NormalEnemyData.EnemyFormation>();
    private Dictionary<Stage, BossEnemyData.BossEnemyFormation> bossFormData = new Dictionary<Stage, BossEnemyData.BossEnemyFormation>();
    private Dictionary<string, Dictionary<int, GameObject>> readyNormalEnemyObjectDic = new Dictionary<string, Dictionary<int, GameObject>>();
    private List<GameObject> explosionObjectList = new List<GameObject>();
    private GameObject bossObject = null;

    /// <summary>
    /// 通常敵のAIデータ作成
    /// </summary>
    public static void CreateNormalEnemyAiData(string aiData = null) {
        string aiRoot = "EnemyFormationData/NormalEnemyAIData";
        if (aiData == null) {
            if (normalEnemyAiData.Count > 0) return;
            TextAsset data = Resources.Load<TextAsset>(aiRoot);
            if (data != null) {
                List<string> lineData = CommonUtil.InitLineData(data.text.Split(new char[] { '\n', '\r' }).ToList<string>());
                foreach (string line in lineData) {
                    string[] ai = line.Split(new char[] { ',' });
                    CommonUtil.Unset(ref ai);
                    normalEnemyAiData.Add(int.Parse(ai[0]), new NormalEnemyData.NormalEnemyBulletAI(int.Parse(ai[1]), int.Parse(ai[2]), float.Parse(ai[3]), float.Parse(ai[4]), int.Parse(ai[5]), int.Parse(ai[6]), float.Parse(ai[7]), float.Parse(ai[8]), ai.Length >= 10 ? int.Parse(ai[9]) : -1));
                }
            }
        }
        else {
            normalEnemyAiData.Clear();
            List<string> lineData = CommonUtil.InitLineData(aiData.Split(new char[] { '\n', '\r' }).ToList<string>());
            foreach (string line in lineData) {
                string[] ai = line.Split(new char[] { ',' });
                CommonUtil.Unset(ref ai);
                normalEnemyAiData.Add(int.Parse(ai[0]), new NormalEnemyData.NormalEnemyBulletAI(int.Parse(ai[1]), int.Parse(ai[2]), float.Parse(ai[3]), float.Parse(ai[4]), int.Parse(ai[5]), int.Parse(ai[6]), float.Parse(ai[7]), float.Parse(ai[8]), ai.Length >= 10 ? int.Parse(ai[9]) : -1));
            }
        }
    }

    void Awake() {
        // バトルスキップの場合はデータを生成しない
        if (!YkSys.battleSkip && Application.loadedLevelName != BattleDebug.BUTTLE_DEBUG_SCENE_NAME) {
            init();
            initFlag = true;
        }
        BossCautionAnim.gameObject.SetActive(false);
    }

    public void init(string normalData = null, string bossStrData = null) {
        string normalEnemyFormPath = "EnemyFormationData/enemy_" + EnemyFactoryState.normal + "_" + YkSys.nowStage;
        string bossEnemyFormPath = "EnemyFormationData/enemy_" + EnemyFactoryState.boss;

        List<string> lineData = new List<string>();
        if (normalData == null) {
            lineData = NormalEnemyData.getNormalFormationLineStrDataListFromResorcesPath(normalEnemyFormPath);
        }else{
            lineData = NormalEnemyData.getNormalFormationLineStrDataListFromStrData(normalData);
        }

        NormalEnemyData.setNormalFormationData(ref normalFormData, ref maxId, lineData);
        lineData.Clear();

        if (bossStrData == null) {
            BossEnemyData.setBossFormationData(ref bossFormData, BossEnemyData.getBossFormationLineStrDataListFromResorcesPath(bossEnemyFormPath));
        }
        else {
            BossEnemyData.setBossFormationDataForDebug(ref bossFormData, BossEnemyData.getBossFormationLineStrDataListFromStrData(bossStrData));
        }
    }

    void Start() {
        if (EnemyBulletBaseObject == null)
            EnemyBulletBaseObject = CommonUtil.SearchObjectChild("EnemyBulletFactory", this.transform);
        state = EnemyFactoryState.normal;

        if (initFlag) {
            CreateInitObjects();
        }
    }

    public void CreateInitObjects() {
        foreach (NormalEnemyData.EnemyFormation data in normalFormData.Values) {
            GameObject obj = CommonUtil.PrefabInstance(data.prefab, WallObjects[data.trans_id].transform);
            obj.SetActive(false);
            if (readyNormalEnemyObjectDic.ContainsKey(data.prefab.name)) {
                readyNormalEnemyObjectDic[data.prefab.name].Add(readyNormalEnemyObjectDic[data.prefab.name].Count, obj);
            }
            else {
                readyNormalEnemyObjectDic.Add(data.prefab.name, new Dictionary<int, GameObject>() { { 0, obj } });
            }
        }

        BossEnemyData.BossEnemyFormation formData = bossFormData[YkSys.nowStage];
        bossObject = CommonUtil.PrefabInstance(formData.prefab, WallObjects[formData.trans_id].transform);
        bossObject.SetActive(false);

        for (int i = 0; i < 20; i++) {
            GameObject obj = CommonUtil.PrefabInstance(ExplosionPrefab);
            obj.SetActive(false);
            explosionObjectList.Add(obj);
        }
    }

    public int nowCreateId = 0;
    void Update() {
        // ポーズ中は敵の生成を行わない
        if (YkSys.Pose) {
            if (!YkSys.battleSkip) {
                switch (state) {
                    case EnemyFactoryState.normal:
                        CreateNormalEnemy();
                        break;
                    case EnemyFactoryState.boss:
                        CreateBossEnemy();
                        break;
                }
            }

            // 敵と弾丸が全て無くなったらボスフラグを立てる
            if (GetEnableEnemyAtouchInAllWall() && !GetEnableEnemyBullet() && nowCreateId >= maxId && state == EnemyFactoryState.normal && readyNormalEnemyObjectDic.Count > 0) {
                if (Application.loadedLevelName != BattleDebug.BUTTLE_DEBUG_SCENE_NAME) {
                    if (!BossCautionAnim.gameObject.activeSelf) {
                        BossCautionAnim.gameObject.SetActive(true);
                    }
                    else {
                        (CommonSys.GetSystem() as TopWindow).boss = true;
                        (CommonSys.GetSystem() as TopWindow).scenarioState = ScenarioPatternType.BOSS;
                        state = EnemyFactoryState.boss;
                    }
                }
                else {
                    (CommonSys.GetSystem() as BattleDebug).boss = true;
                    state = EnemyFactoryState.boss;
                }
            }
            timer += Time.deltaTime;
        }
    }

    /// <summary>
    /// 生きている敵がいるかどうかを調べる
    /// </summary>
    /// <returns></returns>
    private bool GetEnableEnemyAtouchInAllWall() {
        if (readyNormalEnemyObjectDic.Count <= 0) return true;
        int cnt, high = 0;
        foreach (var i in readyNormalEnemyObjectDic.Values) {
            cnt = i.Values.Count(x => x.activeSelf == true);
            if (cnt > high) high = cnt;
        }
        return high == 0;
    }

    /// <summary>
    /// 生きている弾丸があるかどうかを調べる
    /// </summary>
    /// <returns></returns>
    private bool GetEnableEnemyBullet() {
        foreach (Transform trans in EnemyBulletBaseObject.transform) {
            if (trans.gameObject.activeSelf) return true;
        }
        return false;
    }

    public void stopAllBullet() {
        foreach (Transform trans in EnemyBulletBaseObject.transform) {
            trans.gameObject.SetActive(false);
        }
    }

    private List<NormalEnemyData.EnemyFormation> nowNormalEnemyFormation = new List<NormalEnemyData.EnemyFormation>();
    private int beforeId = -1;
    /// <summary>
    /// 通常敵作成
    /// </summary>
    private void CreateNormalEnemy() {
        if (!nowCreateId.Equals(beforeId)) {
            nowNormalEnemyFormation.Clear();
            foreach(NormalEnemyData.EnemyFormation enemyData in normalFormData.Values.Where(val => val.id == nowCreateId)){
                nowNormalEnemyFormation.Add(enemyData);
            }
            beforeId = nowCreateId;
        }
        CreateNormalEnemyPri();
    }

    /// <summary>
    /// 通常敵作成
    /// </summary>
    /// <param name="formation"></param>
    private void CreateNormalEnemyPri() {

        nowNormalEnemyFormation.ForEach(data =>
        {
            if (data.move_time < timer) {
                if (CreateNormalEnemy(data)) {
                    nowNormalEnemyFormation.Remove(data);
                }
            }
        });

        if (nowNormalEnemyFormation.Count <= 0) {
            nowCreateId++;
            timer = 0f;
        }
    }

    public bool CreateNormalEnemy(NormalEnemyData.EnemyFormation enemy) {
        GameObject obj = null;
        Dictionary<int, GameObject>.ValueCollection readyEnemyObjects = readyNormalEnemyObjectDic[enemy.prefab.name].Values;
        if (isNormalEnemyUnenable(readyEnemyObjects)) {
            obj = getNormalEnemyUnenableGObj(readyEnemyObjects);
            if (obj.GetComponent<Enemy>().renderEnable != null) obj.GetComponent<Enemy>().renderEnable.enabled = false;
            obj.SetActive(true);
        }

        if (obj != null) {
            float x = enemy.pos;
            float y = enemy.pos;
            float scale = enemy.scale;
            obj.transform.localScale = new Vector3(scale, scale, 1);

            switch ((WallType)enemy.trans_id) {
                case WallType.UP:
                    obj.transform.position = new Vector3(x, WallObjects[enemy.trans_id].transform.position.y + 1, 0);
                    break;

                case WallType.DOWN:
                    obj.transform.position = new Vector3(x, WallObjects[enemy.trans_id].transform.position.y, 0);
                    obj.transform.Rotate(0, 0, 180);
                    break;

                case WallType.RIGHT:
                    obj.transform.position = new Vector3(WallObjects[enemy.trans_id].transform.position.x, y, 0);
                    obj.transform.Rotate(0, 0, -90);
                    break;

                case WallType.LEFT:
                    obj.transform.position = new Vector3(WallObjects[enemy.trans_id].transform.position.x, y, 0);
                    obj.transform.Rotate(0, 0, 90);
                    break;
            }
            // 敵を生成
            obj.GetComponent<Enemy>().SetData(enemy, EnemyBulletBaseObject, this);
            return true;
        }
        return false;
    }

    private bool isNormalEnemyUnenable(Dictionary<int, GameObject>.ValueCollection data){
        return data.Any(enemy => enemy.activeSelf == false);
    }

    private GameObject getNormalEnemyUnenableGObj(Dictionary<int, GameObject>.ValueCollection data) {
        return data.FirstOrDefault(enemyObj => enemyObj.activeSelf == false);
    }

    /// <summary>
    /// 通常敵のデータを取得
    /// </summary>
    /// <returns></returns>
    public Dictionary<int, NormalEnemyData.EnemyFormation> getNormalEnemyData() {
        return normalFormData;
    }

    /// <summary>
    /// ボス作成
    /// </summary>
    private void CreateBossEnemy() {
        // 現在のステージのボス隊列データを読み込み
        BossEnemyData.BossEnemyFormation formData = bossFormData[YkSys.nowStage];
        GameObject obj = bossObject;
        if (obj == null) {
            obj = CommonUtil.PrefabInstance(formData.prefab, WallObjects[formData.trans_id].transform);
        }
        if (obj != null) {
            float x = formData.pos;
            float y = formData.pos;
            float scale = formData.scale;
            obj.transform.localScale = new Vector3(scale, scale, 1);

            switch ((WallType)formData.trans_id) {
                case WallType.UP:
                    obj.transform.position = new Vector3(x, WallObjects[formData.trans_id].transform.position.y + 1.5f, 0);
                    break;

                case WallType.DOWN:
                    obj.transform.position = new Vector3(x, WallObjects[formData.trans_id].transform.position.y, 0);
                    obj.transform.Rotate(0, 0, 180);
                    break;

                case WallType.RIGHT:
                    obj.transform.position = new Vector3(WallObjects[formData.trans_id].transform.position.x, y, 0);
                    obj.transform.Rotate(0, 0, -90);
                    break;

                case WallType.LEFT:
                    obj.transform.position = new Vector3(WallObjects[formData.trans_id].transform.position.x, y, 0);
                    obj.transform.Rotate(0, 0, 90);
                    break;
            }

            // ここまできたら生成フラグをなくす
            state = EnemyFactoryState.none;

            // ボスを生成
            obj.GetComponent<BossEnemy>().SetData(formData, EnemyBulletBaseObject, WallObjects, this);
            obj.SetActive(true);
            BossCautionAnim.gameObject.SetActive(false);
        }
    }

    public void setExplosionObject(GameObject obj) {
        explosionObjectList.Add(obj);
    }

    public GameObject getExplosionObject() {
        return explosionObjectList.FirstOrDefault(explosion => explosion.activeSelf == false);
    }

    public void Reset() {
        normalFormData = new Dictionary<int, NormalEnemyData.EnemyFormation>();
        bossFormData = new Dictionary<Stage, BossEnemyData.BossEnemyFormation>();
        normalEnemyAiData = new Dictionary<int, NormalEnemyData.NormalEnemyBulletAI>();
    }
}


text:
package com.performize.compfut.examples;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import static com.performize.compfut.Util.sleep;
import static java.util.concurrent.CompletableFuture.supplyAsync;

/**
 * Created by life on 29/4/14.
 */
public class thenComposeExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> f1 = supplyAsync(
                () -> {sleep(2100);if (false) throw new RuntimeException();return 42;});

        CompletableFuture<Integer> f2 = f1.thenCompose(
                (v) -> supplyAsync(() -> {
                    System.out.println("start f2");sleep(2100);return v+42;}))  ;
        System.out.println(f2.get());

    }

}

redpajama_set_name: RedPajamaGithub


text:
using System.Collections.Generic;
using System.ComponentModel;

namespace System.Collections.Immutable
{
    public sealed partial class ImmutableQueue<T>
    {
        /// <summary>
        /// A memory allocation-free enumerator of <see cref="ImmutableQueue{T}"/>.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public struct Enumerator
        {
            /// <summary>
            /// The original queue being enumerated.
            /// </summary>
            private readonly ImmutableQueue<T> _originalQueue;

            /// <summary>
            /// The remaining forwards stack of the queue being enumerated.
            /// </summary>
            private ImmutableStack<T> _remainingForwardsStack;

            /// <summary>
            /// The remaining backwards stack of the queue being enumerated.
            /// Its order is reversed when the field is first initialized.
            /// </summary>
            private ImmutableStack<T> _remainingBackwardsStack;

            /// <summary>
            /// Initializes a new instance of the <see cref="Enumerator"/> struct.
            /// </summary>
            /// <param name="queue">The queue to enumerate.</param>
            internal Enumerator(ImmutableQueue<T> queue)
            {
                _originalQueue = queue;

                // The first call to MoveNext will initialize these.
                _remainingForwardsStack = null;
                _remainingBackwardsStack = null;
            }

            /// <summary>
            /// The current element.
            /// </summary>
            public T Current
            {
                get
                {
                    if (_remainingForwardsStack == null)
                    {
                        // The initial call to MoveNext has not yet been made.
                        throw new InvalidOperationException();
                    }

                    if (!_remainingForwardsStack.IsEmpty)
                    {
                        return _remainingForwardsStack.Peek();
                    }
                    else if (!_remainingBackwardsStack.IsEmpty)
                    {
                        return _remainingBackwardsStack.Peek();
                    }
                    else
                    {
                        // We've advanced beyond the end of the queue.
                        throw new InvalidOperationException();
                    }
                }
            }

            /// <summary>
            /// Advances enumeration to the next element.
            /// </summary>
            /// <returns>A value indicating whether there is another element in the enumeration.</returns>
            public bool MoveNext()
            {
                if (_remainingForwardsStack == null)
                {
                    // This is the initial step.
                    // Empty queues have no forwards or backwards
                    _remainingForwardsStack = _originalQueue._forwards;
                    _remainingBackwardsStack = _originalQueue.BackwardsReversed;
                }
                else if (!_remainingForwardsStack.IsEmpty)
                {
                    _remainingForwardsStack = _remainingForwardsStack.Pop();
                }
                else if (!_remainingBackwardsStack.IsEmpty)
                {
                    _remainingBackwardsStack = _remainingBackwardsStack.Pop();
                }

                return !_remainingForwardsStack.IsEmpty || !_remainingBackwardsStack.IsEmpty;
            }
        }

        /// <summary>
        /// A memory allocation-free enumerator of <see cref="ImmutableQueue{T}"/>.
        /// </summary>
        private class EnumeratorObject : IEnumerator<T>
        {
            /// <summary>
            /// The original queue being enumerated.
            /// </summary>
            private readonly ImmutableQueue<T> _originalQueue;

            /// <summary>
            /// The remaining forwards stack of the queue being enumerated.
            /// </summary>
            private ImmutableStack<T> _remainingForwardsStack;

            /// <summary>
            /// The remaining backwards stack of the queue being enumerated.
            /// Its order is reversed when the field is first initialized.
            /// </summary>
            private ImmutableStack<T> _remainingBackwardsStack;

            /// <summary>
            /// A value indicating whether this enumerator has been disposed.
            /// </summary>
            private bool _disposed;

            /// <summary>
            /// Initializes a new instance of the <see cref="Enumerator"/> struct.
            /// </summary>
            /// <param name="queue">The queue to enumerate.</param>
            internal EnumeratorObject(ImmutableQueue<T> queue)
            {
                _originalQueue = queue;
            }

            /// <summary>
            /// The current element.
            /// </summary>
            public T Current
            {
                get
                {
                    this.ThrowIfDisposed();
                    if (_remainingForwardsStack == null)
                    {
                        // The initial call to MoveNext has not yet been made.
                        throw new InvalidOperationException();
                    }

                    if (!_remainingForwardsStack.IsEmpty)
                    {
                        return _remainingForwardsStack.Peek();
                    }
                    else if (!_remainingBackwardsStack.IsEmpty)
                    {
                        return _remainingBackwardsStack.Peek();
                    }
                    else
                    {
                        // We've advanced beyond the end of the queue.
                        throw new InvalidOperationException();
                    }
                }
            }

            /// <summary>
            /// The current element.
            /// </summary>
            object IEnumerator.Current
            {
                get { return this.Current; }
            }

            /// <summary>
            /// Advances enumeration to the next element.
            /// </summary>
            /// <returns>A value indicating whether there is another element in the enumeration.</returns>
            public bool MoveNext()
            {
                this.ThrowIfDisposed();
                if (_remainingForwardsStack == null)
                {
                    // This is the initial step.
                    // Empty queues have no forwards or backwards
                    _remainingForwardsStack = _originalQueue._forwards;
                    _remainingBackwardsStack = _originalQueue.BackwardsReversed;
                }
                else if (!_remainingForwardsStack.IsEmpty)
                {
                    _remainingForwardsStack = _remainingForwardsStack.Pop();
                }
                else if (!_remainingBackwardsStack.IsEmpty)
                {
                    _remainingBackwardsStack = _remainingBackwardsStack.Pop();
                }

                return !_remainingForwardsStack.IsEmpty || !_remainingBackwardsStack.IsEmpty;
            }

            /// <summary>
            /// Restarts enumeration.
            /// </summary>
            public void Reset()
            {
                this.ThrowIfDisposed();
                _remainingBackwardsStack = null;
                _remainingForwardsStack = null;
            }

            /// <summary>
            /// Disposes this instance.
            /// </summary>
            public void Dispose()
            {
                _disposed = true;
            }

            /// <summary>
            /// Throws an <see cref="ObjectDisposedException"/> if this
            /// enumerator has already been disposed.
            /// </summary>
            private void ThrowIfDisposed()
            {
                if (_disposed)
                {
                    Requires.FailObjectDisposed(this);
                }
            }
        }
    }
}


text:
@implementation WCSymbolContainer
- (BOOL)isLeafNode {
	return YES;
}

+ (id)symbolContainerWithSourceSymbol:(WCSourceSymbol *)sourceSymbol; {
	return [[[[self class] alloc] initWithSourceSymbol:sourceSymbol] autorelease];
}
- (id)initWithSourceSymbol:(WCSourceSymbol *)sourceSymbol; {
	if (!(self = [super initWithRepresentedObject:sourceSymbol]))
		return nil;

	return self;
}
@end


text:
class AllowedPeers:
    """
    Defines the type of allowed peers.
    """
    PEER_CRM = "virtualisation"
    PEER_SDNRM = "sdn_networking"
    PEER_TNRM = "transport_network"
    PEER_SERM = "stitching_entity"
    PEER_RO = "island_ro"

    @staticmethod
    def get_peers_key():
        return list(filter((lambda x: x.startswith("PEER_")),
                    AllowedPeers.__dict__))

    @staticmethod
    def get_peers_type():
        return list(AllowedPeers.__dict__.get(x) for x
                    in AllowedPeers.get_peers_key())

    @staticmethod
    def get_peers():
        keys = AllowedPeers.get_peers_key()
        peers = dict()
        for key in keys:
            peers[key] = AllowedPeers.__dict__.get(key)
        return peers


text:
'use strict';

module.exports = function(app) {
	var users = require('../../app/controllers/users.server.controller');
	var orderEnquiryForms = require('../../app/controllers/order-enquiry-forms.server.controller');

	// Order enquiry forms Routes
	app.route('/order-enquiry-forms')
		.get(orderEnquiryForms.list)
		.post(users.requiresLogin, orderEnquiryForms.create);

	app.route('/order-enquiry-forms/:orderEnquiryFormId')
		.get(orderEnquiryForms.read)
		.put(users.requiresLogin, orderEnquiryForms.hasAuthorization, orderEnquiryForms.update)
		.delete(users.requiresLogin, orderEnquiryForms.hasAuthorization, orderEnquiryForms.delete);

	// Finish by binding the Order enquiry form middleware
	app.param('orderEnquiryFormId', orderEnquiryForms.orderEnquiryFormByID);
};


text:
"use strict";

var Relay = lib("relay");

describe("Relay", function() {
  var driver;

  beforeEach(function() {
    driver = new Relay({
      name: "switchy",
      connection: { digitalWrite: spy(), pwmWrite: spy() },
      pin: 13
    });
  });

  describe("constructor", function() {
    it("sets @pin to the value of the passed pin", function() {
      expect(driver.pin).to.be.eql(13);
    });

    it("sets @isOn to false by default", function() {
      expect(driver.isOn).to.be.false;
    });

    context("if no pin is specified", function() {
      it("throws an error", function() {
        var fn = function() { return new Relay({ name: "hi" }); };
        expect(fn).to.throw("No pin specified for Relay. Cannot proceed");
      });
    });
  });

  it("has Relay commands", function() {
    for (var c in driver.commands) {
      expect(driver.commands[c]).to.be.a("function");
    }
  });

  describe("#start", function() {
    var callback = spy();

    beforeEach(function() {
      driver.start(callback);
    });

    it("triggers the callback", function() {
      expect(callback).to.be.calledOnce;
    });
  });

  describe("#halt", function() {
    var callback = spy();

    beforeEach(function() {
      driver.halt(callback);
    });

    it("triggers the callback", function() {
      expect(callback).to.be.calledOnce;
    });
  });

  describe("#turnOn", function() {
    it("writes a high value to the pin", function() {
      driver.isOn = false;
      driver.turnOn();

      expect(driver.isOn).to.be.true;
      expect(driver.connection.digitalWrite).to.be.calledWith(13, 1);
    });
  });

  describe("#turnOff", function() {
    it("writes a high value to the pin", function() {
      driver.isOn = true;
      driver.turnOff();

      expect(driver.isOn).to.be.false;
      expect(driver.connection.digitalWrite).to.be.calledWith(13, 0);
    });
  });

  describe("#toggle", function() {
    context("when @isOn is true", function() {
      beforeEach(function() {
        driver.isOn = true;
        stub(driver, "turnOff");
      });

      after(function() {
        driver.turnOff.restore();
      });

      it("turns the Relay off", function() {
        driver.toggle();
        expect(driver.turnOff).to.be.called;
      });
    });

    context("when @isOn is false", function() {
      beforeEach(function() {
        driver.isOn = false;
        stub(driver, "turnOn");
      });

      after(function() {
        driver.turnOn.restore();
      });

      it("turns the Relay on", function() {
        driver.toggle();
        expect(driver.turnOn).to.be.called;
      });
    });
  });

  describe("normally closed relays", function() {
    context("when type is 'closed'", function() {
      beforeEach(function() {
        driver.type = "closed";
        driver.isOn = true;
        stub(driver, "turnOff");
      });

      after(function() {
        driver.turnOff.restore();
      });

      it("turns the Relay off", function() {
        driver.toggle();
        expect(driver.turnOff).to.be.called;
      });
    });
  });
});


text:
<?php

namespace Produto\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * ProdutoPerspectivas
 *
 * @ORM\Table(name="produto_perspectivas", indexes={@ORM\Index(name="fk_produto_perspectivas_produto_tenis_idx", columns={"produto_tenis"})})
 * @ORM\Entity
 */
class ProdutoPerspectivas
{
    /**
     * @var integer
     *
     * @ORM\Column(name="id_perspectivas", type="integer", nullable=false)
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    private $idPerspectivas;

    /**
     * @var string
     *
     * @ORM\Column(name="src", type="string", length=255, nullable=true)
     */
    private $src;

    /**
     * @var \ProdutoTenis
     *
     * @ORM\ManyToOne(targetEntity="ProdutoTenis")
     * @ORM\JoinColumns({
     *   @ORM\JoinColumn(name="produto_tenis", referencedColumnName="idtenis")
     * })
     */
    private $produtoTenis;
	/**
	 * @return the $idPerspectivas
	 */
	public function getIdPerspectivas() {
		return $this->idPerspectivas;
	}

	/**
	 * @return the $src
	 */
	public function getSrc() {
		return $this->src;
	}

	/**
	 * @return the $produtoTenis
	 */
	public function getProdutoTenis() {
		return $this->produtoTenis;
	}

	/**
	 * @param number $idPerspectivas
	 */
	public function setIdPerspectivas($idPerspectivas) {
		$this->idPerspectivas = $idPerspectivas;
	}

	/**
	 * @param string $src
	 */
	public function setSrc($src) {
		$this->src = $src;
	}

	/**
	 * @param ProdutoTenis $produtoTenis
	 */
	public function setProdutoTenis($produtoTenis) {
		$this->produtoTenis = $produtoTenis;
	}

}


text:
package io.confluent.kafka.schemaregistry.maven;

import org.apache.avro.Schema;
import org.junit.After;
import org.junit.Before;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class SchemaRegistryTest {
  protected File tempDirectory;

  @Before
  public void createTempDirectory() throws IOException {
    this.tempDirectory = File.createTempFile(this.getClass().getSimpleName(), "tmp");
    this.tempDirectory.delete();
    this.tempDirectory.mkdirs();
  }

  protected void writeSchema(File outputPath, Schema schema) throws IOException {
    try (FileWriter writer = new FileWriter(outputPath)) {
      writer.write(schema.toString(true));
    }
  }

  protected void writeMalformedFile(File file) throws IOException {
    try (FileWriter writer = new FileWriter(file)) {
      writer.write("[");
    }
  }

  @After
  public void cleanupTempDirectory() throws IOException {
    for (File tempFile : this.tempDirectory.listFiles()) {
      tempFile.delete();
    }
    this.tempDirectory.delete();
  }
}


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>org.codehaus.mojo</groupId>
    <artifactId>webstart</artifactId>
    <version>1.0.0-SNAPSHOT</version>
  </parent>

  <artifactId>webstart-maven-plugin</artifactId>
  <packaging>maven-plugin</packaging>

  <name>MWEBSTART :: Webstart Maven Plugin</name>
  <description>Maven plugin that supports webstart application development. Helps generate JNLP files and supports the
    JnlpDownloadServlet.
  </description>

  <contributors>
    <contributor>
      <name>David Boden</name>
      <email>dave@daveboden.com</email>
    </contributor>
    <contributor>
      <name>Kevin Stembridge</name>
      <email>kevin.stembridge.dev@gmail.com</email>
      <timezone>0</timezone>
    </contributor>
    <contributor>
      <name>Claude Humard</name>
      <email>NOTSHOWN@nospam.com</email>
    </contributor>
  </contributors>

  <prerequisites>
    <maven>${mavenVersion}</maven>
  </prerequisites>

  <properties>
    <javadocPluginVersion>3.2.0</javadocPluginVersion>

    <!-- versions of javadoc tagglets -->
    <mavenPluginToolsJavadocVersion>3.6.0</mavenPluginToolsJavadocVersion>
    <plexusComponentJavadocVersion>2.1.0</plexusComponentJavadocVersion>
  </properties>

  <dependencies>

	<dependency>
	  <groupId>org.codehaus.mojo</groupId>
	  <artifactId>keytool-api-1.7</artifactId>
	</dependency>

    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-artifact</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-plugin-api</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-compat</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-core</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-settings</artifactId>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.apache.maven.plugin-tools</groupId>
      <artifactId>maven-plugin-annotations</artifactId>
    </dependency>

    <!-- dependencies to plexus annotations -->
    <dependency>
      <groupId>org.codehaus.plexus</groupId>
      <artifactId>plexus-component-annotations</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.maven.reporting</groupId>
      <artifactId>maven-reporting-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.reporting</groupId>
      <artifactId>maven-reporting-impl</artifactId>
      <exclusions>
        <exclusion>
          <groupId>velocity</groupId>
          <artifactId>velocity</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.apache.maven.shared</groupId>
      <artifactId>maven-shared-utils</artifactId>
    </dependency>

    <dependency>
      <groupId>org.sonatype.plexus</groupId>
      <artifactId>plexus-sec-dispatcher</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.maven.shared</groupId>
      <artifactId>maven-jarsigner</artifactId>
    </dependency>

    <dependency>
      <groupId>org.codehaus.plexus</groupId>
      <artifactId>plexus-archiver</artifactId>
    </dependency>

    <dependency>
      <groupId>org.codehaus.plexus</groupId>
      <artifactId>plexus-utils</artifactId>
    </dependency>

    <dependency>
      <groupId>org.apache.velocity</groupId>
      <artifactId>velocity-engine-core</artifactId>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>xmlunit</groupId>
      <artifactId>xmlunit</artifactId>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>webstart-jnlp-servlet</artifactId>
      <version>${project.version}</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.apache.maven.plugin-testing</groupId>
      <artifactId>maven-plugin-testing-harness</artifactId>
      <scope>test</scope>
    </dependency>

    <!-- for JarUnsign... -->
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-embedder</artifactId>
      <scope>test</scope>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-plugin-plugin</artifactId>
      </plugin>

      <!-- expose new plexus components -->
      <plugin>
        <groupId>org.codehaus.plexus</groupId>
        <artifactId>plexus-component-metadata</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>generate-metadata</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <plugin>
        <artifactId>maven-antrun-plugin</artifactId>
        <executions>
          <execution>
            <id>site</id>
            <phase>pre-site</phase>
            <goals>
              <goal>run</goal>
            </goals>
            <configuration>
              <tasks>
                <copy todir="${project.build.directory}/site/examples/">
                  <fileset dir="${basedir}/src/main/resources">
                    <include name="**/*.vm" />
                  </fileset>
                  <mapper type="flatten" />
                </copy>
              </tasks>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>run-its</id>
      <activation>
        <property>
          <name>skipITs</name>
          <value>!true</value>
        </property>
      </activation>
      <build>
        <defaultGoal>verify</defaultGoal>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-invoker-plugin</artifactId>
						<version>3.3.0</version>
            <configuration>
              <cloneProjectsTo>${project.build.directory}/it</cloneProjectsTo>
              <settingsFile>src/it/settings.xml</settingsFile>
              <localRepositoryPath>${project.build.directory}/local-repo</localRepositoryPath>
              <postBuildHookScript>validate.groovy</postBuildHookScript>
              <addTestClassPath>true</addTestClassPath>
            </configuration>
            <executions>
              <execution>
                <goals>
                  <goal>install</goal>
                  <goal>run</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>

    <profile>
      <id>reporting</id>
      <activation>
        <property>
          <name>skipReports</name>
          <value>!true</value>
        </property>
      </activation>

      <reporting>
        <plugins>

          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-plugin-plugin</artifactId>
            <version>${mavenPluginPluginVersion}</version>
          </plugin>

          <plugin>
            <artifactId>maven-invoker-plugin</artifactId>
			<version>3.3.0</version>
          </plugin>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>l10n-maven-plugin</artifactId>
            <version>1.0.0</version>
            <configuration>
              <locales>
                <locale>fr</locale>
              </locales>
            </configuration>
          </plugin>
        </plugins>
      </reporting>
    </profile>
  </profiles>
</project>


text:
<?xml version="1.0" encoding="UTF-8"?>
<?relations relSet="Martin1992" lexURL="jar:file:/home/lisa/Arbeit/Conano-Distrib/conano.jar!/de/uni_potsdam/ling/coli/resources/ConnectorLexicon.xml"?>
<discourse>
   Keine Garantie
   <unit type="ext" id="1">Euphorische Beifallsstürme gab es in Fröhden nicht für die Dorferneuerungsplanung .</unit>
  <unit type="ext" id="3">
   <unit type="int" id="1">
	<unit type="ext" id="2">
         Das war
         <connective id="1" relation="addition">auch</connective>
         kaum zu erwarten ,</unit></unit>
 <unit type="int" id="2">handelt es sich <connective id="2" relation="consequence">doch</connective> um ein Gemeinschaftswerk , an dem die Einwohner mitgewirkt haben .</unit>
   </unit>
   <unit type="int" id="3">
      <connective id="3" relation="consequence">Deshalb</connective>
      blieben auch kaum Fragen offen , zumindest nicht solche , die die Gestaltung der beiden Jüterboger Ortsteile betrifft .
   </unit>
   <unit type="ext" id="5">Das Interesse an der Planung war groß , die Beteiligung an den Arbeitskreisen hat es gezeigt .</unit>
   <unit type="int" id="5">
      <unit type="ext" id="6">
         <connective id="5" relation="contrast">Doch</connective>
         die Freude hält sich in Grenzen ,
      </unit>
      </unit>
      <unit type="int" id="6">
         <connective id="6" relation="consequence">denn</connective>
         inzwischen weiß jeder , dass die Fördermittelgießkanne nur noch tröpfchenweise austeilt .
   </unit>
   <unit type="ext" id="7">Wer auf das Ja-Wort aus Brieselang warten kann , keine Scheu vor seitenlangen Fragebögen hat</unit>
   <unit type="int" id="7">
      <connective id="7" relation="addition">und</connective>
      in Kauf nimmt , dass er wahrscheinlich nicht billiger wegkommt , als wenn er nach eigenen Vorstellungen die Fassade gestrichen hätte -
   </unit>
   dem kann bescheinigt werden , dass ihm sein Dorf und dessen Erscheinungsbild am Herzen liegt .
   <unit type="ext" id="13"><unit type="ext" id="11">Schweren Herzens wird sich die Stadt von ihrem Geld trennen ,</unit></unit>
   <unit type="int" id="13">
     <unit type="int" id="11">
      <connective id="13" relation="condition">wenn</connective>
      es <connective id="11" relation="consequence">nämlich</connective> darum geht , die Eigenanteile für bestimmte Vorhaben zur Verfügung zu stellen .
   </unit>
   </unit>
   <unit type="ext" id="12">Die Dorferneuerungsplanung ist längst keine Garantie mehr für grenzenlosen Geldsegen .</unit> <unit type="int" id="12"><connective id="12" relation="consequence">So</connective> könnte es passieren , dass viele schöne Vorhaben nur Visionen bleiben .</unit>
</discourse>


text:
from airflow.operators import BranchPythonOperator, DummyOperator
from airflow.models import DAG
from datetime import datetime, timedelta
import random

seven_days_ago = datetime.combine(datetime.today() - timedelta(7),
                                  datetime.min.time())
args = {
    'owner': 'airflow',
    'start_date': seven_days_ago,
}

dag = DAG(
    dag_id='example_branch_operator',
    default_args=args,
    schedule_interval="@daily")

cmd = 'ls -l'
run_this_first = DummyOperator(task_id='run_this_first', dag=dag)

options = ['branch_a', 'branch_b', 'branch_c', 'branch_d']

branching = BranchPythonOperator(
    task_id='branching',
    python_callable=lambda: random.choice(options),
    dag=dag)
branching.set_upstream(run_this_first)

join = DummyOperator(
    task_id='join',
    trigger_rule='one_success',
    dag=dag
)

for option in options:
    t = DummyOperator(task_id=option, dag=dag)
    t.set_upstream(branching)
    dummy_follow = DummyOperator(task_id='follow_' + option, dag=dag)
    t.set_downstream(dummy_follow)
    dummy_follow.set_downstream(join)


text:
pf_sys::ThreadLock g_thread_lock;

namespace pf_sys {

uint16_t g_thread_quit_count = 0;

//-- thread class
Thread::Thread() {
  __ENTER_FUNCTION
    id_ = 0;
    status_ = kReady;
#if __WINDOWS__
    thread_handle_ = NULL;
#endif
  __LEAVE_FUNCTION
}

Thread::~Thread() {
  //do nothing
}

void Thread::start() {
  __ENTER_FUNCTION
    if (status_ != kReady) return;
#if __LINUX__
    int32_t result = pthread_create(reinterpret_cast<pthread_t *>(&id_),
                                    NULL,
                                    ps_thread_process,
                                    this);
    if (result != 0) {
      char msg[32] = {0};
      snprintf(msg,
               sizeof(msg) - 1,
               "pthread_create failed, result: %d",
               result);
      AssertEx(false, msg);
    }
#elif __WINDOWS__
    thread_handle_ =
      ::CreateThread(NULL, 0, ps_thread_process, this, CREATE_SUSPENDED, &id_);
    Assert(thread_handle_ != NULL);
    id_ *= 1000; //???
    ResumeThread(thread_handle_);
#endif
  __LEAVE_FUNCTION
}

void Thread::stop() {
  //do nothing
}

void Thread::exit(void *retval) {
  __ENTER_FUNCTION
#if __LINUX__
    pthread_exit(retval);
#elif __WINDOWS__
    USE_PARAM(retval);
    ::CloseHandle(thread_handle_);
#endif
  __LEAVE_FUNCTION
}

void Thread::run() {
  //do nothing
}

#if __LINUX__
void *ps_thread_process(void *derived_thread) {
#elif __WINDOWS__
DWORD WINAPI ps_thread_process(void *derived_thread) {
#endif
  __ENTER_FUNCTION
    Thread* thread = static_cast<Thread*>(derived_thread);
    if (NULL == thread) return NULL;
    thread->set_status(Thread::kRunning);
    thread->run();
    thread->set_status(Thread::kExit);
#if __WINDOWS__
    thread->exit(NULL);
#endif
    g_thread_lock.lock();
    ++g_thread_quit_count;
    g_thread_lock.unlock();
  __LEAVE_FUNCTION
    return NULL;
}
#if __LINUX__
uint64_t Thread::get_id() {
#elif __WINDOWS__
DWORD Thread::get_id() {
#endif
  return id_;
}

Thread::status_t Thread::get_status() {
  return status_;
}

void Thread::set_status(status_t status) {
  __ENTER_FUNCTION
    status_ = status;
  __LEAVE_FUNCTION
}

//thread class --

//-- thread lock class
ThreadLock::ThreadLock() {
  __ENTER_FUNCTION
#if __LINUX__
    pthread_mutex_init(&mutex_, NULL);
#elif __WINDOWS__
    InitializeCriticalSection(&lock_);
#endif
  __LEAVE_FUNCTION
}

ThreadLock::~ThreadLock() {
  __ENTER_FUNCTION
#if __LINUX__
    pthread_mutex_destroy(&mutex_);
#elif __WINDOWS__
    DeleteCriticalSection(&lock_);
#endif
  __LEAVE_FUNCTION
}

void ThreadLock::lock() {
  __ENTER_FUNCTION
#if __LINUX__
    pthread_mutex_lock(&mutex_);
#elif __WINDOWS__
    EnterCriticalSection(&lock_);
#endif
  __LEAVE_FUNCTION
}

void ThreadLock::unlock() {
  __ENTER_FUNCTION
#if __LINUX__
    pthread_mutex_unlock(&mutex_);
#elif __WINDOWS__
    LeaveCriticalSection(&lock_);
#endif
  __LEAVE_FUNCTION
}

//thread lock class --
uint64_t get_current_thread_id() {
  __ENTER_FUNCTION
    uint64_t result = 0;
#if __LINUX__
    result = static_cast<uint64_t>(pthread_self());
#elif __WINDOWS__
    result = static_cast<uint64_t>(GetCurrentThreadId());
#endif
    return result;
  __LEAVE_FUNCTION
    return NULL;
}

} //namespace pf_sys


text:
using LinqInfer.Learning.Classification.NeuralNetworks;
using System;
using System.Collections.Generic;

namespace LinqInfer.Learning.Classification
{
    class ClassifierCluster<TClass, TInput>
        where TClass : IEquatable<TClass>
    {
        IList<(INetworkClassifier<TClass, TInput> classifier, Func<TInput[], bool>)> classifiers;

        public ClassifierCluster(int maxSize)
        {
            classifiers = new List<(INetworkClassifier<TClass, TInput> classifier, Func<TInput[], bool>)>();
        }

        public void Train(TInput[] trainingData)
        {

        }
    }
}


text:
namespace Microsoft.Win32
{

#if CONFIG_WIN32_SPECIFICS

using System;
using System.IO;
using System.Security;
using System.Security.AccessControl;

public sealed class RegistryKey : MarshalByRefObject, IDisposable
{
	// Internal state.
	private String name;
	private IRegistryKeyProvider provider;
	private bool writable;

	// Standard hive names.
	private static readonly String[] hiveNames = {
			"HKEY_CLASSES_ROOT",
			"HKEY_CURRENT_USER",
			"HKEY_LOCAL_MACHINE",
			"HKEY_USERS",
			"HKEY_PERFORMANCE_DATA",
			"HKEY_CURRENT_CONFIG",
			"HKEY_DYN_DATA"
		};

	// Constructor.
	private RegistryKey(IRegistryKeyProvider provider, bool writable)
			{
				this.name = provider.Name;
				this.provider = provider;
				this.writable = writable;
			}

	// Destructor.
	~RegistryKey()
			{
				Close();
			}

	// Implement the IDisposable interface.
	void IDisposable.Dispose()
			{
				Close();
			}

	// Close this key and flush any modifications to disk.
	public void Close()
			{
				if(provider != null)
				{
					provider.Close(writable);
					provider = null;
				}
			}

	// Resolve a subkey to its parent and last component.
	private static RegistryKey Resolve(RegistryKey start, String subkey,
									   bool create, out String last)
			{
				int index;
				String temp;
				IRegistryKeyProvider key;
				RegistryKey savedStart = start;
				RegistryKey prevStart;

				last = String.Empty;
				while((index = subkey.IndexOf('\\')) != -1 ||
				      (index = subkey.IndexOf('/')) != -1)
				{
					// Extract the name of this component.
					temp = subkey.Substring(0, index);
					subkey = subkey.Substring(index + 1);

					// Bail out if "start" does not have a provider.
					if(start.provider == null)
					{
						throw new IOException(_("IO_RegistryKeyClosed"));
					}

					// Create or open a new component.
					prevStart = start;
					if(create)
					{
						key = start.provider.OpenSubKey(temp, true);
						if(key == null)
						{
							key = start.provider.CreateSubKey(temp);
						}
						start = new RegistryKey(key, true);
					}
					else
					{
						key = start.provider.OpenSubKey(temp, false);
						if(key == null)
						{
							return null;
						}
						start = new RegistryKey(key, false);
					}
					if(prevStart != savedStart)
					{
						// Intermediate registry key that we won't be needing
						// any more, so clean up its resources.
						prevStart.Close();
					}
				}
				last = subkey;
				if(start.provider == null)
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
				return start;
			}

	// Create a subkey underneath this particular registry key.
	public RegistryKey CreateSubKey(String subkey)
			{
				// Validate the parameters.
				if(subkey == null)
				{
					throw new ArgumentNullException("subkey");
				}
				if(provider == null)
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
				if(!writable)
				{
					throw new UnauthorizedAccessException
						(_("IO_RegistryReadOnly"));
				}

				// Resolve the subkey to a parent and last component.
				String last;
				RegistryKey parent;
				parent = Resolve(this, subkey, true, out last);

				// Open or create the subkey and make it writable.
				IRegistryKeyProvider key;
				key = parent.provider.OpenSubKey(last, true);
				if(key == null)
				{
					key = parent.provider.CreateSubKey(last);
				}
				return new RegistryKey(key, true);
			}
#if CONFIG_ACCESS_CONTROL
	public RegistryKey CreateSubKey
				(String subkey, RegistrySecurity registrySecurity)
			{
				return CreateSubKey(subkey);
			}
#endif

	// Delete a particular subkey.
	public void DeleteSubKey(String subkey, bool throwOnMissingSubKey)
			{
				// Validate the parameters.
				if(subkey == null)
				{
					throw new ArgumentNullException("subkey");
				}
				if(provider == null)
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}

				// Take a shortcut if we need to "delete from parents".
				if(provider.DeleteFromParents)
				{
					if(!provider.DeleteSubKey(subkey) && throwOnMissingSubKey)
					{
						throw new ArgumentException
							(_("IO_RegistryKeyNotExist"));
					}
					return;
				}

				// Resolve the subkey to a parent and last component.
				String last;
				RegistryKey parent;
				parent = Resolve(this, subkey, false, out last);
				if(parent == null)
				{
					if(throwOnMissingSubKey)
					{
						throw new ArgumentException
							(_("IO_RegistryKeyNotExist"));
					}
					return;
				}

				// Find and delete the subkey.
				IRegistryKeyProvider key;
				key = parent.provider.OpenSubKey(last, false);
				if(key == null)
				{
					if(throwOnMissingSubKey)
					{
						throw new ArgumentException
							(_("IO_RegistryKeyNotExist"));
					}
					return;
				}
				key.Close(false);
				key.Delete();
			}
	public void DeleteSubKey(String subkey)
			{
				DeleteSubKey(subkey, true);
			}

	// Delete a particular subkey and all of its descendents.
	public void DeleteSubKeyTree(String subkey)
			{
				// Validate the parameters.
				if(subkey == null)
				{
					throw new ArgumentNullException("subkey");
				}
				if(provider == null)
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}

				// Take a shortcut if we need to "delete from parents".
				if(provider.DeleteFromParents)
				{
					if(!provider.DeleteSubKeyTree(subkey))
					{
						throw new ArgumentException
							(_("IO_RegistryKeyNotExist"));
					}
					return;
				}

				// Resolve the subkey to a parent and last component.
				String last;
				RegistryKey parent;
				parent = Resolve(this, subkey, false, out last);
				if(parent == null)
				{
					throw new ArgumentException(_("IO_RegistryKeyNotExist"));
				}

				// Find and delete the subkey.
				IRegistryKeyProvider key;
				key = parent.provider.OpenSubKey(last, false);
				if(key == null)
				{
					throw new ArgumentException(_("IO_RegistryKeyNotExist"));
				}
				key.Close(false);
				key.DeleteTree();
			}

	// Delete a particular value underneath this registry key.
	public void DeleteValue(String name, bool throwOnMissingValue)
			{
				if(name == null)
				{
					name = String.Empty;
				}
				if(!writable)
				{
					throw new UnauthorizedAccessException
						(_("IO_RegistryReadOnly"));
				}
				if(provider != null)
				{
					if(!provider.DeleteValue(name))
					{
						if(throwOnMissingValue)
						{
							throw new ArgumentException
								(_("IO_RegistryKeyNotExist"));
						}
					}
				}
				else
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
			}
	public void DeleteValue(String name)
			{
				DeleteValue(name, true);
			}

	// Flush all modifications to this registry key.
	public void Flush()
			{
				if(provider != null)
				{
					provider.Flush();
				}
			}

#if CONFIG_ACCESS_CONTROL

	// Get the access control information for this key.
	[TODO]
	public RegistrySecurity GetAccessControl()
			{
				// TODO
				return null;
			}
	[TODO]
	public RegistrySecurity GetAccessControl(AccessControlSections ruleInfo)
			{
				// TODO
				return null;
			}

	// Set the access control information for this key.
	[TODO]
	public void SetAccessControl(RegistrySecurity registrySecurity)
			{
				if(registrySecurity == null)
				{
					throw new ArgumentNullException("registrySecurity");
				}
				// TODO
			}

#endif

	// Get the names of all subkeys underneath this registry key.
	public String[] GetSubKeyNames()
			{
				if(provider != null)
				{
					return provider.GetSubKeyNames();
				}
				else
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
			}

	// Get a value from underneath this registry key.
	public Object GetValue(String name, Object defaultValue)
			{
				if(name == null)
				{
					name = String.Empty;
				}
				if(provider != null)
				{
					return provider.GetValue(name, defaultValue);
				}
				else
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
			}
	public Object GetValue(String name)
			{
				return GetValue(name, null);
			}
#if CONFIG_FRAMEWORK_1_2
	[Obsolete("Use the RegisterValueOptions variant of GetValue instead")]
	public Object GetValue(String name, Object defaultValue, bool doNotExpand)
			{
				if(doNotExpand)
				{
					return GetValue
						(name, defaultValue,
						 RegistryValueOptions.DoNotExpandedEnvironmentNames);
				}
				else
				{
					return GetValue
						(name, defaultValue, RegistryValueOptions.None);
				}
			}
	[TODO]
	public Object GetValue(String name, Object defaultValue,
						   RegistryValueOptions options)
			{
				// TODO
				return GetValue(name, defaultValue);
			}

	// Get the kind associated with a value.
	[TODO]
	public RegistryValueKind GetValueKind(String name)
			{
				// TODO
				return RegistryValueKind.String;
			}
#endif

	// Get the names of all values underneath this registry key.
	public String[] GetValueNames()
			{
				if(provider != null)
				{
					return provider.GetValueNames();
				}
				else
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
			}

	// Open a registry key for a local or remote machine.
	public static RegistryKey OpenRemoteBaseKey(RegistryHive hKey,
												String machineName)
			{
				// Validate the parameters.
				if(hKey < RegistryHive.ClassesRoot ||
				   hKey > RegistryHive.DynData)
				{
					throw new ArgumentException(_("Arg_InvalidHive"));
				}
				if(machineName == null)
				{
					throw new ArgumentNullException("machineName");
				}

				// Get the name of the hive to be accessed.
				String name = hiveNames
					[((int)hKey) - (int)(RegistryHive.ClassesRoot)];

				// Is this a remote hive reference?
				if(machineName != String.Empty)
				{
					if(Win32KeyProvider.IsWin32())
					{
						// Attempt to connect to the remote registry.
						IntPtr newKey;
						if(Win32KeyProvider.RegConnectRegistry
								(machineName,
								 Win32KeyProvider.HiveToHKey(hKey),
								 out newKey) != 0)
						{
							throw new SecurityException
								(_("Invalid_RemoteRegistry"));
						}
						return new RegistryKey
							(new Win32KeyProvider(name, newKey), true);
					}
					else
					{
						// Not Win32 - cannot access remote registries.
						throw new SecurityException
							(_("Invalid_RemoteRegistry"));
					}
				}

				// Open a local hive.
				return new RegistryKey
					(Registry.GetProvider(hKey, name), true);
			}

	// Open a subkey.
	public RegistryKey OpenSubKey(String name, bool writable)
			{
				// Validate the parameters.
				if(name == null)
				{
					throw new ArgumentNullException("name");
				}
				if(provider == null)
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}

				// Resolve the subkey to a parent and last component.
				String last;
				RegistryKey parent;
				parent = Resolve(this, name, false, out last);
				if(parent == null)
				{
					return null;
				}

				// Open the subkey in the specified mode.
				IRegistryKeyProvider key;
				key = parent.provider.OpenSubKey(last, writable);
				if(key == null)
				{
					return null;
				}
				return new RegistryKey(key, writable);
			}
	public RegistryKey OpenSubKey(String name)
			{
				return OpenSubKey(name, false);
			}

	// Set a value under this registry key.
	public void SetValue(String name, Object value)
			{
				if(name == null)
				{
					name = String.Empty;
				}
				if(value == null)
				{
					throw new ArgumentNullException("value");
				}
				if(!writable)
				{
					throw new UnauthorizedAccessException
						(_("IO_RegistryReadOnly"));
				}
				if(provider != null)
				{
					provider.SetValue(name, value);
				}
				else
				{
					throw new IOException(_("IO_RegistryKeyClosed"));
				}
			}
#if CONFIG_FRAMEWORK_1_2
	public void SetValue
				(String name, Object value, RegistryValueKind valueKind)
			{
				// TODO
				SetValue(name, value);
			}
#endif

	// Get the string form of this registry key.
	public override String ToString()
			{
				return name;
			}

	// Get the name of the registry key.
	public String Name
			{
				get
				{
					return name;
				}
			}

	// Get the number of subkeys underneath this key.
	public int SubKeyCount
			{
				get
				{
					if(provider != null)
					{
						return provider.SubKeyCount;
					}
					else
					{
						throw new IOException(_("IO_RegistryKeyClosed"));
					}
				}
			}

	// Get the number of values that are associated with this key.
	public int ValueCount
			{
				get
				{
					if(provider != null)
					{
						return provider.ValueCount;
					}
					else
					{
						throw new IOException(_("IO_RegistryKeyClosed"));
					}
				}
			}

}; // class RegistryKey

#endif // CONFIG_WIN32_SPECIFICS

}; // namespace Microsoft.Win32


text:
(function () {
"use strict";

angular.module('common')
.service('MenuService', MenuService);

MenuService.$inject = ['$http', 'ApiPath'];
function MenuService($http, ApiPath) {
  var service = this;

  service.getCategories = function () {
    return $http.get(ApiPath + '/categories.json').then(function (response) {
      console.log("resolving from", ApiPath, "/categories.json");
      return response.data;
    });
  };

  service.getMenuItems = function (category) {
    var config = {};
    if (category) {
      config.params = {'category': category};
    }

    return $http.get(ApiPath + '/menu_items.json', config).then(function (response) {
      console.log("resolving from", ApiPath, "/menu_items.json");
      return response.data;
    });
  };

}

})();


text:
package org.ovirt.engine.ui.common.widget.uicommon.vm;

import org.ovirt.engine.core.common.businessentities.VM;
import org.ovirt.engine.ui.common.CommonApplicationConstants;
import org.ovirt.engine.ui.common.gin.AssetProvider;
import org.ovirt.engine.ui.common.system.ClientStorage;
import org.ovirt.engine.ui.common.uicommon.model.SearchableTableModelProvider;
import org.ovirt.engine.ui.common.widget.table.column.AbstractTextColumn;
import org.ovirt.engine.ui.common.widget.uicommon.AbstractModelBoundTableWidget;
import org.ovirt.engine.ui.uicommonweb.models.vms.VmAppListModel;
import com.google.gwt.event.shared.EventBus;

public class VmAppListModelTable extends AbstractModelBoundTableWidget<String, VmAppListModel<VM>> {

    private static final CommonApplicationConstants constants = AssetProvider.getConstants();

    public VmAppListModelTable(
            SearchableTableModelProvider<String, VmAppListModel<VM>> modelProvider,
            EventBus eventBus, ClientStorage clientStorage) {
        super(modelProvider, eventBus, clientStorage, false);
    }

    @Override
    public void initTable() {
        AbstractTextColumn<String> appNameColumn = new AbstractTextColumn<String>() {
            @Override
            public String getValue(String appName) {
                return appName;
            }
        };
        getTable().addColumn(appNameColumn, constants.installedApp());
    }

}


text:
<!DOCTYPE HTML>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Jasmine Spec Runner v2.0.2</title>

  <link rel="shortcut icon" type="image/png" href="lib/jasmine-2.0.2/jasmine_favicon.png">
  <link rel="stylesheet" type="text/css" href="lib/jasmine-2.0.2/jasmine.css">

  <!-- jasmine-jquery source file -->
  <script type="text/javascript" src='lib/jasmine-2.0.2/jasmine-jquery.js'></script>

  <script type="text/javascript" src="lib/jasmine-2.0.2/jasmine.js"></script>
  <script type="text/javascript" src="lib/jasmine-2.0.2/jasmine-html.js"></script>
  <script type="text/javascript" src="lib/jasmine-2.0.2/boot.js"></script>

  <!-- include source files here... -->
  <script type="text/javascript" src="src/Donation.js"></script>
  <script type="application/html" src="views/index.html"></script>

  <!-- include spec files here... -->
  <script type="text/javascript" src="spec/SpecHelper.js"></script>
  <script type="text/javascript" src="spec/DonationSpec.js"></script>
  <script type="text/javascript" src="spec/DisplaySpec.js"></script>

</head>

<body>
</body>
</html>


text:
package org.apache.spark.sql.catalyst.optimizer

import org.apache.spark.sql.catalyst.analysis.{Analyzer, EmptyFunctionRegistry}
import org.apache.spark.sql.catalyst.catalog.{InMemoryCatalog, SessionCatalog}
import org.apache.spark.sql.catalyst.dsl.expressions._
import org.apache.spark.sql.catalyst.dsl.plans._
import org.apache.spark.sql.catalyst.expressions.Literal
import org.apache.spark.sql.catalyst.plans.PlanTest
import org.apache.spark.sql.catalyst.plans.logical.{LocalRelation, LogicalPlan}
import org.apache.spark.sql.catalyst.rules.RuleExecutor
import org.apache.spark.sql.internal.SQLConf
import org.apache.spark.sql.internal.SQLConf.{CASE_SENSITIVE, GROUP_BY_ORDINAL}

class AggregateOptimizeSuite extends PlanTest {
  override val conf = new SQLConf().copy(CASE_SENSITIVE -> false, GROUP_BY_ORDINAL -> false)
  val catalog = new SessionCatalog(new InMemoryCatalog, EmptyFunctionRegistry, conf)
  val analyzer = new Analyzer(catalog, conf)

  object Optimize extends RuleExecutor[LogicalPlan] {
    val batches = Batch("Aggregate", FixedPoint(100),
      FoldablePropagation,
      RemoveLiteralFromGroupExpressions,
      RemoveRepetitionFromGroupExpressions) :: Nil
  }

  val testRelation = LocalRelation('a.int, 'b.int, 'c.int)

  test("remove literals in grouping expression") {
    val query = testRelation.groupBy('a, Literal("1"), Literal(1) + Literal(2))(sum('b))
    val optimized = Optimize.execute(analyzer.execute(query))
    val correctAnswer = testRelation.groupBy('a)(sum('b)).analyze

    comparePlans(optimized, correctAnswer)
  }

  test("do not remove all grouping expressions if they are all literals") {
    val query = testRelation.groupBy(Literal("1"), Literal(1) + Literal(2))(sum('b))
    val optimized = Optimize.execute(analyzer.execute(query))
    val correctAnswer = analyzer.execute(testRelation.groupBy(Literal(0))(sum('b)))

    comparePlans(optimized, correctAnswer)
  }

  test("Remove aliased literals") {
    val query = testRelation.select('a, Literal(1).as('y)).groupBy('a, 'y)(sum('b))
    val optimized = Optimize.execute(analyzer.execute(query))
    val correctAnswer = testRelation.select('a, Literal(1).as('y)).groupBy('a)(sum('b)).analyze

    comparePlans(optimized, correctAnswer)
  }

  test("remove repetition in grouping expression") {
    val input = LocalRelation('a.int, 'b.int, 'c.int)
    val query = input.groupBy('a + 1, 'b + 2, Literal(1) + 'A, Literal(2) + 'B)(sum('c))
    val optimized = Optimize.execute(analyzer.execute(query))
    val correctAnswer = input.groupBy('a + 1, 'b + 2)(sum('c)).analyze

    comparePlans(optimized, correctAnswer)
  }
}


text:
import { BASE_API, DELETE, POST } from '../../constants';
import day from 'dayjs/esm';

export class LectureManagementPage {
    clickCreateLecture() {
        cy.get('#jh-create-entity').click();
    }

    deleteLecture(lectureTitle: string, lectureIndex: number) {
        this.getLectureRow(lectureIndex).find('#delete-lecture').click();
        cy.get('#delete').should('be.disabled');
        cy.get('#confirm-exercise-name').type(lectureTitle);
        cy.intercept(DELETE, `${BASE_API}lectures/*`).as('deleteLecture');
        cy.get('#delete').click();
        return cy.wait('@deleteLecture');
    }

    getLectureRow(lectureIndex: number) {
        const selector = '#lecture-row-' + lectureIndex;
        cy.reloadUntilFound(selector);
        return cy.get(selector);
    }

    getLectureSelector(lectureTitle: string) {
        return this.getLectureContainer().contains(lectureTitle);
    }

    getLectureContainer() {
        return cy.get('#lecture-preview');
    }

    openUnitsPage(lectureIndex: number) {
        this.getLectureRow(lectureIndex).find('#units').click();
    }

    openCreateUnit(type: UnitType) {
        this.getUnitCreationCard().find(type).click();
    }

    getUnitCreationCard() {
        return cy.get('#unit-creation');
    }

    addTextUnit(name: string, text: string, releaseDate = day()) {
        this.openCreateUnit(UnitType.TEXT);
        cy.get('#name').type(name);
        cy.get('#release-date').find('#date-input-field').type(releaseDate.toString());
        cy.get('.ace_content').type(text, { parseSpecialCharSequences: false });
        return this.submitUnit();
    }

    addExerciseUnit(exerciseId: number) {
        this.openCreateUnit(UnitType.EXERCISE);
        const exerciseRow = '#exercise-' + exerciseId;
        cy.reloadUntilFound(exerciseRow);
        cy.get(exerciseRow).click();
        return this.submitUnit('#createButton');
    }

    submitUnit(buttonId = '#submitButton') {
        cy.intercept(POST, BASE_API + 'lectures/*/*').as('createUnit');
        cy.get(buttonId).click();
        return cy.wait('@createUnit');
    }
}

enum UnitType {
    TEXT = '#createTextUnitButton',
    EXERCISE = '#createExerciseUnitButton',
    VIDEO = '#createVideoUnitButton',
    FILE = '#createFileUploadUnitButton',
}


text:
echo $CLUSTER_DNS

ssh -i workshop.pem docker@$CLUSTER_IP

curl -o jenkins-agent.yml https://raw.githubusercontent.com/vfarcic/docker-flow-stacks/master/jenkins/vfarcic-jenkins-agent.yml

docker node ls

PRIVATE_IP=[...]

export JENKINS_URL="http://$PRIVATE_IP/jenkins"

LABEL=prod docker stack deploy -c jenkins-agent.yml jenkins-agent-prod

PUBLIC_IP=[...]

export JENKINS_URL="http://$PUBLIC_IP/jenkins"

LABEL=test EXECUTORS=3 docker stack deploy -c jenkins-agent.yml jenkins-agent-test

exit

open "http://$CLUSTER_DNS/jenkins/computer"


text:
from django.forms import ModelForm
from django import forms
from .models import Contact

class ContactForm(forms.Form):
    name = forms.CharField(max_length=10, label=u'名称', required=False)
    phone = forms.CharField(max_length=18, label=u'电话号码', required=False)
    email = forms.EmailField(max_length=150, label=u'邮箱地址', required=False)
    description = forms.CharField(label=u'留言内容', widget=forms.Textarea, required=False)

    def clean_name(self):
        name = self.cleaned_data.get('name')
        if not name:
            raise forms.ValidationError(u'请输入名称!!')
        return name

    def clean_phone(self):
        phone = self.cleaned_data.get('phone')
        if not phone:
            raise forms.ValidationError(u'请输入号码!!')
        return phone

    def clean_email(self):
        email = self.cleaned_data.get('email')
        if not email:
            raise forms.ValidationError(u'请输入邮箱啊')
        return email

    def clean_description(self):
        description = self.cleaned_data.get('description')
        if not description:
            raise forms.ValidationError(u'请输入描述呢')
        return description

    # class Meta:
    #     model = Contact
    #     fields = ('name', 'phone', 'email', 'description')


text:
			<a aria-label="Inicio" href="<?= base_url(); ?>index">Inicio
			Instalaciones

Instalaciones
 y Equipamiento técnico

Para una mejor atención del paciente contamos con una importante y moderna infraestructura, edificio de 4 plantas totalmente renovados, más de 20 consultorios, 5 sectores de internación, nuevos y amplios quirófanos, nueva sala de parto y pre-parto, ampliación de la unidad de cuidados intensivos y sector de esterilización. Todos ellos cuentan con tecnología de última generación.

Clínica Los Cedros de tapiales ofrece una infraestructura de de 4 plantas totalmente renovados.

Posee 5 sectores de internación clínica, quirúrgica y de obstetricia.

				<img src="<?= base_url(); ?>img/presentacion.jpg" alt="Sanatorio Privado Madero"/>

Recorrido por las instalaciones

	      <?
					foreach($categorias->result() as $key=>$categoria):
						if ($key === 0) { ?>
							<li class="item-container item-active" id="<?= $categoria->id ?>">
						<? } else { ?>
							<li class="item-container" id="<?= $categoria->id ?>">
						<? } ?>

									<span class="item-category" title="<?= $categoria->nombre ?>"><?= $categoria->nombre ?>
									<? if ($categoria->descripcion !== '') {
										?>
<?= $categoria->descripcion ?>
<?
									} ?>

								<? if ($key === 0) { ?>
									<div class="container-slider slider-active" id="slider-<?= $categoria->id ?>">
								<? } else { ?>
		      				<div class="container-slider" id="slider-<?= $categoria->id ?>">
								<? } ?>

											 <button class="button-prev disabled" id="button-prev" title="Anterior"></button>
											 <button class="button-next" id="button-next" title="Siguiente"></button>

						              <?
														foreach($instalaciones->result() as $instalacion):
															if($instalacion->idCategoria === $categoria->id) {
																?>

								                    <img alt="<?= $instalacion->imagen ?>" src="<?= base_url(); ?>img/slider/<?= $instalacion->imagen ?>"/>

<?= $instalacion->descripcion ?>

						                  	<?
															}
														endforeach;
													?>

						        <?
											foreach($instalaciones->result() as $instalacion):
												if($instalacion->idCategoria === $categoria->id) {
													?>
								            <button class="image-secondary" id="image-<?= $categoria->id ?>">
															<img alt="" src="<?= base_url(); ?>img/slider/<?= $instalacion->imagen ?>"/>
														</button>
							          	<?
												}
											endforeach;
										?>

	      		<?
					endforeach;
				?>


text:
<!DOCTYPE HTML>

	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
	<meta name="viewport" content="width=device-width, initial-scale = 1.0, user-scalable = no">
	<link href='http://fonts.googleapis.com/css?family=Lato:100,300,400,700' rel='stylesheet' type='text/css'>
	<link rel="stylesheet" href="css/style.css" type="text/css" media="screen">
	<link rel="stylesheet" href="../../css/style.css" type="text/css" media="screen">

	<ui-icons></ui-icons>

TYPOGRAPHY

Header 01

Nos mueve el deseo de ayudar a los demás

Header 02

Nos mueve el deseo de ayudar a los demás

Subtitle 01

¿Quién es Pentcloud?

Subtitle 02

¿Quién es Pentcloud?

Paragraph Min

Biscuit sugar plum bear claw. Sweet roll unerdwear.com cheesecake candy. Chocolate bar candy halvah gummies lollipop toffee donut. Cheesecake tiramisu applicake halvah oat cake carrot cake sesame snaps topping jujubes. Powder cake muffin marshmallow danish lollipop gummi bears powder. Jelly beans pastry gingerbread sweet. Jelly-o applicake oat cake. Biscuit liquorice apple pie biscuit liquorice apple pie biscuit lollipop sugar plum sugar plum liquorice caramels.

Paragraph Max

Biscuit sugar plum bear claw. Sweet roll unerdwear.com cheesecake candy. Chocolate bar candy halvah gummies lollipop toffee donut. Cheesecake tiramisu applicake halvah oat cake carrot cake sesame snaps topping jujubes. Powder cake muffin marshmallow danish lollipop gummi bears powder. Jelly beans pastry gingerbread sweet. Jelly-o applicake oat cake. Biscuit liquorice apple pie biscuit liquorice apple pie biscuit lollipop sugar plum sugar plum liquorice caramels.

COLORS

Nightsky

#1d2841

#12192c

#2b374e

Jeans

#34495d

#2c3e50

#44596b

Ocean Soul

#34495d

#2c3e50

#44596b

Breeze

#34495d

#2c3e50

#44596b

Blueberry

#34495d

#2c3e50

#44596b

Weirdplum

#34495d

#2c3e50

#44596b

Leaf

#34495d

#2c3e50

#44596b

Fresh Mint

#34495d

#2c3e50

#44596b

Aquarium

#34495d

#2c3e50

#44596b

Sour Orange

#34495d

#2c3e50

#44596b

Autumn

#34495d

#2c3e50

#44596b

Cherry

#34495d

#2c3e50

#44596b

Juice

#34495d

#2c3e50

#44596b

Sunny Days

#34495d

#2c3e50

#44596b

Sunflower

#f7d153

#f8e493

#f8d57c

Silver

#34495d

#2c3e50

#44596b

Fluffy Clouds

#34495d

#2c3e50

#44596b

Cardigan

#34495d

#2c3e50

#44596b

Buttons

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

<icon img="img" size="l">

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

Aceptar

<icon img="img" size="l">

Aceptar

				<ui-switch switch-id="hola2"></ui-switch>

				<ui-flip switch-id="hola1"></ui-flip>

				<ui-radio radio-id="radio1" radio-name="radio1" radio-label="asdf"></ui-radio>
				<ui-radio radio-id="radio2" radio-name="radio1" radio-label="asdf"></ui-radio>
				<ui-checkbox checkbox-id="check1" checkbox-name="checkbox1" checkbox-label="Esto es un check">

				<icon img="device-text" size="xl" color="dark-breeze"></icon>
				<icon img="conf"></icon>
				<icon img="conf" color="leaf" size="m"></icon>
				<icon img="conf" color="breeze" size="l"></icon>

				<input type="text" placeholder="Text placeholder"></input>

Aceptar

				<input type="text" placeholder="Text placeholder"></input>
				<input type="text" disabled placeholder="Text placeholder"></input>