text:
using System.Collections.Generic;
using System.ComponentModel.Composition.Factories;
using System.ComponentModel.Composition.Hosting;
using System.Linq;
using System.UnitTesting;
using Xunit;

namespace System.ComponentModel.Composition
{
    public interface ITrans_ExportableTest
    {
        string Var1 { get; }
    }

    public interface ITrans_CollectionOfStrings
    {
        IEnumerable<string> Values { get; }
    }

    public class AdvancedValueComposition
    {
        [Fact]
        public void RepeatedContainerUse()
        {
            var container = ContainerFactory.Create();
            TrivialExporter e = new TrivialExporter();

            CompositionBatch batch = new CompositionBatch();
            batch.AddPart(e);
            container.Compose(batch);

            batch = new CompositionBatch();
            batch.AddPart(new TrivialImporter());
            container.Compose(batch);

            Assert.True(e.done, "Initialization of importer should have set the done flag on E");
        }

        [Fact]
        public void FunctionsFieldsAndProperties()
        {
            Consumer c;
            var container = ContainerFactory.Create();

            CompositionBatch batch = new CompositionBatch();
            batch.AddPart(new RealAddProvider());
            batch.AddPart(c = new Consumer());
            container.Compose(batch);

            Assert.Equal(3, c.op(c.a, c.b));
        }

        [Fact]
        public void FunctionsFieldsAndProperties2()
        {
            Consumer c;
            var container = ContainerFactory.Create();

            CompositionBatch batch = new CompositionBatch();
            batch.AddPart(new SubtractProvider());
            batch.AddPart(c = new Consumer());
            container.Compose(batch);

            Assert.Equal(-1, c.op(c.a, c.b));
        }

        [Fact]
        [ActiveIssue(25498)]
        public void FunctionsFieldsAndProperties2_WithCatalog()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();

            ConsumerOfMultiple c = new ConsumerOfMultiple();
            CompositionBatch batch = new CompositionBatch();
            batch.AddPart(c);
            container.Compose(batch);

            foreach (Lazy<Func<int,int,int>, IDictionary<string, object>> export in c.opInfo)
            {
                if ((string)export.Metadata["Var1"] == "add")
                {
                    Assert.Equal(3, export.Value(1, 2));
                }
                else if ((string)export.Metadata["Var1"] == "sub")
                {
                    Assert.Equal(-1, export.Value(1, 2));
                }
                else
                {
                    throw new NotImplementedException();
                }
            }
        }

        [Fact]
        [ActiveIssue(25498, TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void FunctionsFieldsAndProperties2_StronglyTypedMetadata()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();

            var exports = container.GetExports<Func<int, int, int>, ITrans_ExportableTest>("Add");

            foreach (var export in exports)
            {
                if (export.Metadata.Var1 == "add")
                {
                    Assert.Equal(3, export.Value(1, 2));
                }
                else if (export.Metadata.Var1 == "sub")
                {
                    Assert.Equal(-1, export.Value(1, 2));
                }
                else
                {
                    throw new NotImplementedException();
                }
            }
        }

        [Fact]
        [ActiveIssue(25498, TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void InAdditionToCatalogTest()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();

            IDictionary<string, object> multMetadata = new Dictionary<string, object>();
            multMetadata["Var1"] = "mult";
            multMetadata[CompositionConstants.ExportTypeIdentityMetadataName] = AttributedModelServices.GetTypeIdentity(typeof(Func<int, int, int>));
            var basicValue = ExportFactory.Create("Add", multMetadata, (() => (Func<int, int, int>)delegate (int a, int b)
            { return a * b; }));

            CompositionBatch batch = new CompositionBatch();
            batch.AddExport(basicValue);
            container.Compose(batch);

            var exports = container.GetExports<Func<int, int, int>, ITrans_ExportableTest>("Add");

            Assert.Equal(3, exports.Count());

            foreach (var export in exports)
            {
                if (export.Metadata.Var1 == "mult")
                {
                    Assert.Equal(2, export.Value(1, 2));
                }
                else if (export.Metadata.Var1 == "add")
                {
                    Assert.Equal(3, export.Value(1, 2));
                }
                else if (export.Metadata.Var1 == "sub")
                {
                    Assert.Equal(-1, export.Value(1, 2));
                }
                else
                {
                    throw new NotImplementedException();
                }
            }
        }

        [Fact]
        [ActiveIssue(25498)]
        public void CollectionMetadataPropertyTest()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();
            var export = container.GetExport<ComponentWithCollectionProperty, ITrans_CollectionOfStrings>();

            Assert.NotNull(export.Metadata);
            Assert.NotNull(export.Metadata.Values);
            Assert.Equal(export.Metadata.Values.Count(), 3);
            Assert.Equal(export.Metadata.Values.First(), "One");
            Assert.Equal(export.Metadata.Values.Skip(1).First(), "two");
            Assert.Equal(export.Metadata.Values.Skip(2).First(), "3");
        }

        [Fact]
        [ActiveIssue(25498, TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void ImportExportSansNameTest()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();

            UnnamedImportAndExport unnamed = container.GetExportedValue<UnnamedImportAndExport>();
            Assert.NotNull(unnamed);
            Assert.NotNull(unnamed.ImportedValue);
        }

        [Fact]
        [ActiveIssue(25498, TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void MultipleInstantiationOfStaticCatalogItem()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();
            var unnamedVI = container.GetExport<StaticExport, object>();

            StaticExport first = unnamedVI.Value;
            StaticExport second = unnamedVI.Value;

            Assert.NotNull(first);
            Assert.NotNull(second);
            Assert.True(object.ReferenceEquals(first, second), "Instances should be the same");

            var exports = container.GetExports<StaticExport, object>();

            Assert.Equal(1, exports.Count());
        }

        [Fact]
        [ActiveIssue(25498, TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
        public void MultipleInstantiationOfNonStaticCatalogItem()
        {
            var container = ContainerFactory.CreateWithDefaultAttributedCatalog();
            var export1 = container.GetExport<NonStaticExport, object>();
            var export2 = container.GetExport<NonStaticExport, object>();

            NonStaticExport first = export1.Value;
            NonStaticExport second = export2.Value;

            Assert.NotNull(first);
            Assert.NotNull(second);
            Assert.False(object.ReferenceEquals(first, second), "Instances should be different");
        }

        [Fact]
        [ActiveIssue(25498)]
        public void ImportIntoUntypedExportTest()
        {
            var container = ContainerFactory.Create();

            CompositionBatch batch = new CompositionBatch();
            batch.AddExportedValue("untyped", 42);

            var u = new UntypedExportImporter();
            var rb = AttributedModelServices.CreatePart(u);

            batch.AddPart(rb);
            container.Compose(batch);

            Assert.Equal(42, u.Export.Value);

            var us = new UntypedExportsImporter();
            batch = new CompositionBatch();
            batch.AddExportedValue("untyped", 19);
            batch.RemovePart(rb);
            batch.AddPart(us);
            container.Compose(batch);

            Assert.NotNull(us.Exports);
            Assert.Equal(2, us.Exports.Count());
        }

        [Fact]
        public void ImportIntoDerivationOfExportException()
        {
            var container = ContainerFactory.Create();

            CompositionBatch batch = new CompositionBatch();
            batch.AddExportedValue("derived", typeof(DerivedExport), 42);
            var d = new DerivedExportImporter();
            batch.AddPart(d);

            CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,
                                          ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () =>
            {
                container.Compose(batch);
            });
        }

        [Fact]
        public void ImportIntoDerivationOfExportsException()
        {
            var container = ContainerFactory.Create();

            CompositionBatch batch = new CompositionBatch();
            batch.AddExportedValue("derived", typeof(DerivedExport), 42);
            var d = new DerivedExportsImporter();
            batch.AddPart(d);

            CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,
                                          ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () =>
            {
                container.Compose(batch);
            });
        }
    }
}


text:
using System;
using System.IO;
using System.Threading;
using System.Collections;
using System.Collections.Generic;

namespace Forseti
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Console.WriteLine ("PiEMOS-Configer starting...");

			Dictionary<int, string> filenames = new Dictionary<int, string>();

			filenames[1] = "working.cfg";
			filenames[2] = "working.cfg";
			filenames[3] = "working.cfg";
			filenames[4] = "working.cfg";

			Dictionary<int, bool> blues = new Dictionary<int, bool>();
			blues[1] = true;
			blues[2] = true;
			blues[3] = false;
			blues[4] = false;

			Dictionary<int, string> names = new Dictionary<int, string>();
			names[1] = "Impact";
			names[2] = "Ell Cerito";
			names[3] = "Lighthouse";
			names[4] = "Oakland Tech";

			Dictionary<int, int> numbers = new Dictionary<int, int>();
			numbers[1] = 15;
			numbers[2] = 28;
			numbers[3] = 30;
			numbers[4] = 29;
			//blues[1]

			for(int i = 1; i<=4; i++)
			{
//				string config = File.ReadAllText("" + i + ".cfg");
				string config = File.ReadAllText(filenames[i]);
				//Console.WriteLine ("config=" + config);

				PiEMOSConfiger configer = new PiEMOSConfiger("10.20.34.10" + i, 6000 + i, 6000 + i, config);

				configer.ConfigIsBlueAlliance = blues[i];
				configer.ConfigTeamName = names[i];
				configer.ConfigTeamNumber = numbers[i];

				configer.Start();

				configer.Start ();
//				while(true)
//				{
//					Console.WriteLine ("Sending");
//					configer.SendConfigData(config);
//					Thread.Sleep (500);
//				}
			}

			//configer.Start ();
		}
	}
}

redpajama_set_name: RedPajamaGithub


text:
#!/usr/bin/env node

'use strict';

const fs = require('fs');
const [arg] = process.argv.slice(2);

if (!arg)
    usage();
else if (/^(-v|--v)$/.test(arg))
    version();
else if (/^(-h|--help)$/.test(arg))
    help();
else
    checkFile(arg, (error) => {
        if (!error)
            return main(arg);

        console.error(error.message);
    });

function getPath(name) {
    const reg = /^(~|\/)/;

    if (!reg.test(name))
        name = process.cwd() + '/' + name;

    return name;
}

function main(name) {
    const filename = getPath(name);
    const DIR = __dirname + '/../assets/';
    const dword = require('..');
    const http = require('http');
    const express = require('express');
    const io = require('socket.io');

    const app = express();
    const server = http.createServer(app);

    const {env} = process;

    const port = env.PORT /* c9           */
                    || env.VCAP_APP_PORT /* cloudfoundry */
                    || 1337;

    const ip = env.IP /* c9           */
                || '0.0.0.0';

    app .use(express.static(DIR))
        .use(dword({
            online: false,
            diff: true,
            zip: true,
        }));

    server.listen(port, ip);

    const socket = io(server);
    const edSocket = dword.listen(socket);

    edSocket.on('connection', () => {
        fs.readFile(name, 'utf8', (error, data) => {
            if (error)
                return console.error(error.message);

            edSocket.emit('file', filename, data);
        });
    });

    console.log('url: http://' + ip + ':' + port);
}

function checkFile(name, callback) {
    fs.stat(name, (error, stat) => {
        let msg;

        if (error && error.code === 'ENOENT')
            msg = Error(`no such file or directory: '${name}'`);
        else if (stat.isDirectory())
            msg = Error(`'${name}' is directory`);

        callback(msg);
    });
}

function version() {
    console.log(`v${info().version}`);
}

function info() {
    return require('../package');
}

function usage() {
    console.log(`Usage: ${info().name} [filename]`);
}

function help() {
    const bin = require('../json/bin');

    usage();
    console.log('Options:');

    for (const name of Object.keys(bin)) {
        console.log(`  ${name} ${bin[name]}`);
    }
}


text:
<?php namespace App\Modules\School\Controllers\Api\DataTables;

use App\Modules\School\Models\School;
use App\Modules\School\Base\Controllers\ModuleDataTableController;

class SchoolDataTable extends ModuleDataTableController {

  protected $columns = ['name'];

  protected $common_columns = ['created_at', 'updated_at'];
  protected $options = ['edit'];
  public function query()
  {
      $school = School::Query();
      return $this->applyScopes($school);
  }

}


text:
#ifndef __UTIL_TASK_H__
#define __UTIL_TASK_H__

#include "util_list.h"
#include "util_thread.h"
#include "util_vector.h"

CCL_NAMESPACE_BEGIN

class Task;
class TaskPool;
class TaskScheduler;

typedef boost::function<void(void)> TaskRunFunction;

/* Task
 *
 * Base class for tasks to be executed in threads. */

class Task
{
public:
	Task() {};
	Task(const TaskRunFunction& run_) : run(run_) {}

	virtual ~Task() {}

	TaskRunFunction run;
};

/* Task Pool
 *
 * Pool of tasks that will be executed by the central TaskScheduler.For each
 * pool, we can wait for all tasks to be done, or cancel them before they are
 * done.
 *
 * The run callback that actually executes the task may be created like this:
 * function_bind(&MyClass::task_execute, this, _1, _2) */

class TaskPool
{
public:
	TaskPool();
	~TaskPool();

	void push(Task *task, bool front = false);
	void push(const TaskRunFunction& run, bool front = false);

	void wait_work();	/* work and wait until all tasks are done */
	void cancel();		/* cancel all tasks, keep worker threads running */
	void stop();		/* stop all worker threads */

	bool canceled();	/* for worker threads, test if canceled */

protected:
	friend class TaskScheduler;

	void num_decrease(int done);
	void num_increase();

	thread_mutex num_mutex;
	thread_condition_variable num_cond;

	int num;
	bool do_cancel;
};

/* Task Scheduler
 *
 * Central scheduler that holds running threads ready to execute tasks. A singe
 * queue holds the task from all pools. */

class TaskScheduler
{
public:
	static void init(int num_threads = 0);
	static void exit();

	/* number of threads that can work on task */
	static int num_threads() { return threads.size(); }

	/* test if any session is using the scheduler */
	static bool active() { return users != 0; }

protected:
	friend class TaskPool;

	struct Entry {
		Task *task;
		TaskPool *pool;
	};

	static thread_mutex mutex;
	static int users;
	static vector<thread*> threads;
	static bool do_exit;

	static list<Entry> queue;
	static thread_mutex queue_mutex;
	static thread_condition_variable queue_cond;

	static void thread_run(int thread_id);
	static bool thread_wait_pop(Entry& entry);

	static void push(Entry& entry, bool front);
	static void clear(TaskPool *pool);
};

/* Dedicated Task Pool
 *
 * Like a TaskPool, but will launch one dedicated thread to execute all tasks.
 *
 * The run callback that actually executes the task may be created like this:
 * function_bind(&MyClass::task_execute, this, _1, _2) */

class DedicatedTaskPool
{
public:
	DedicatedTaskPool();
	~DedicatedTaskPool();

	void push(Task *task, bool front = false);
	void push(const TaskRunFunction& run, bool front = false);

	void wait();        /* wait until all tasks are done */
	void cancel();		/* cancel all tasks, keep worker thread running */
	void stop();		/* stop worker thread */

	bool canceled();	/* for worker thread, test if canceled */

protected:
	void num_decrease(int done);
	void num_increase();

	void thread_run();
	bool thread_wait_pop(Task*& entry);

	void clear();

	thread_mutex num_mutex;
	thread_condition_variable num_cond;

	list<Task*> queue;
	thread_mutex queue_mutex;
	thread_condition_variable queue_cond;

	int num;
	bool do_cancel;
	bool do_exit;

	thread *worker_thread;
};

CCL_NAMESPACE_END

#endif


text:
/*
 * Created by JFormDesigner on Sat Feb 13 16:51:30 ICT 2016
 */

package net.openbyte.gui;

import net.openbyte.gui.logger.Consumer;

import java.awt.*;
import javax.swing.*;

/**
 * @author Gary Lee
 */
public class OutputFrame extends JDialog implements Consumer {
    public OutputFrame(Frame owner) {
        super(owner);
        initComponents();
    }

    public OutputFrame(Dialog owner) {
        super(owner);
        initComponents();
    }

    private void initComponents() {
        // JFormDesigner - Component initialization - DO NOT MODIFY  //GEN-BEGIN:initComponents
        // Generated using JFormDesigner Evaluation license - Gary Lee
        scrollPane1 = new JScrollPane();
        textArea1 = new JTextArea();

        //======== this ========
        setTitle("Output");
        Container contentPane = getContentPane();
        contentPane.setLayout(new BorderLayout());

        //======== scrollPane1 ========
        {

            //---- textArea1 ----
            textArea1.setEditable(false);
            scrollPane1.setViewportView(textArea1);
        }
        contentPane.add(scrollPane1, BorderLayout.CENTER);
        setSize(1000, 370);
        setLocationRelativeTo(getOwner());
        // JFormDesigner - End of component initialization  //GEN-END:initComponents
    }

    @Override
    public void appendText(String text) {
        this.textArea1.append(text);
    }

    // JFormDesigner - Variables declaration - DO NOT MODIFY  //GEN-BEGIN:variables
    // Generated using JFormDesigner Evaluation license - Gary Lee
    private JScrollPane scrollPane1;
    private JTextArea textArea1;
    // JFormDesigner - End of variables declaration  //GEN-END:variables
}


text:
package com.rssaggregator.desktop.model;

import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

/**
 * Return of the API Request Add Feed.
 *
 * @author Irina
 *
 */
public class FeedAddedWrapper {

	@Expose
	private String status;
	@SerializedName("id_feed")
	@Expose
	private Integer channelId;

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public Integer getChannelId() {
		return channelId;
	}

	public void setChannelId(Integer channelId) {
		this.channelId = channelId;
	}
}


text:
'use strict'
var request = require('request');
var cheerio = require('cheerio');
var scrapper = (function () {
    return {
        scrapPetrolPrice: function (city, callback) {
            var searchPhrase = city + ' petrol price';
            request('https://www.mypetrolprice.com/petrol-price-in-india.aspx', function (error, response, html) {
                if (error) {
                    console.error('request main page error : ' + JSON.stringify(error));
                    callback(null);
                }
                else {
                    var $ = cheerio.load(html);
                    var target = $('a').filter(function () {
                        var title = $(this).attr('title');
                        if (title) {
                            return title.toLowerCase().indexOf(searchPhrase) > -1;
                        }
                    });
                    var cityLink = target.attr('href');
                    if (!cityLink) {
                        callback(null);
                    }
                    else {
                        request(cityLink, function (error, response, html) {
                            if (error) {
                                console.error('request city page error : ' + JSON.stringify(error));
                                callback(null);
                            }
                            else {
                                var $ = cheerio.load(html);
                                var price = $('#CPH1_lblCurrent').text();
                                price = price.substring(price.indexOf('=') + 1, price.indexOf('Rs')).trim()
                                callback({
                                    price: price,
                                    city: city,
                                    date: new Date().toISOString().replace('T', ' ').substr(0, 10)
                                });
                            }
                        });
                    }
                }
            });
        }
    }
})();

module.exports = scrapper;


text:
<!--
The following sections may be removed if there is nothing to
put in them.
-->
### Issues addressed
<!--
Describe problems or include GitHub issue links here.
Recommended that you have something to say here.
-->
### Design considerations
<!--
If you had any special thoughts about why you wrote the code
the way that you did, put them here.
The larger the change, the more it would be preferred if you
had something to say here.
-->
### Follow-up changes needed
<!--
If you've written a feature but don't have formal tests or documentation
for it, mention that here.
-->


text:
<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:sling="http://sling.apache.org/jcr/sling/1.0" xmlns:cq="http://www.day.com/jcr/cq/1.0" xmlns:jcr="http://www.jcp.org/jcr/1.0" xmlns:nt="http://www.jcp.org/jcr/nt/1.0"
    jcr:primaryType="cq:Page">
    <jcr:content
        cq:designPath="/etc/designs/phonegap/brucelefebvre/pgday-talk"
        cq:lastModified="{Date}2016-01-29T00:15:52.180-05:00"
        cq:lastModifiedBy="admin"
        cq:template="/apps/brucelefebvre/pgday-talk/templates/prez-page"
        jcr:primaryType="cq:PageContent"
        jcr:title="AEM+PG highlights"
        sling:resourceType="brucelefebvre/pgday-talk/components/prez-page"
        page-transition="slide-animation">
        <content-par
            jcr:primaryType="nt:unstructured"
            sling:resourceType="foundation/components/parsys">
            <title
                jcr:created="{Date}2014-10-23T01:26:32.004-07:00"
                jcr:createdBy="admin"
                jcr:lastModified="{Date}2014-10-23T01:26:38.339-07:00"
                jcr:lastModifiedBy="admin"
                jcr:primaryType="nt:unstructured"
                jcr:title="Highlights"
                sling:resourceType="brucelefebvre/pgday-talk/components/title"
                type="h2"/>
            <text
                jcr:created="{Date}2014-10-23T01:26:40.263-07:00"
                jcr:createdBy="admin"
                jcr:lastModified="{Date}2016-01-29T00:15:52.177-05:00"
                jcr:lastModifiedBy="admin"
                jcr:primaryType="nt:unstructured"
                sling:resourceType="brucelefebvre/pgday-talk/components/text"
                text="
• Manage metadata with the Apps Dashboard

• Author content as a non-technical user

• Update app content Over-The-Air

• Analyze usage with Adobe Mobile Services

• Personalize with Adobe Target

"
                textIsRich="true"/>
        </content-par>
    </jcr:content>
</jcr:root>


text:
RSpec.describe Track, type: :model do
  describe "Factory" do
    it "can create" do
      create(:track)
      expect(Track.count).to eq(1)
    end
  end
end


text:
package com.edgar.designpattern.factory;

import java.util.ArrayList;
import java.util.List;

public abstract class Pizza {

	String name;
	String dough;
	String sauce;
	List toppings = new ArrayList();

	public void prepare() {
		System.out.println("prepareing " + name);
		System.out.println("tossing dough...");
		System.out.println("adding sauce...");
		System.out.println("adding toppings ");
		for (int i = 0; i < toppings.size(); i++) {
			System.out.print("     " + toppings.get(i));
		}
	}

	public void bake() {
		System.out.println("bake Pizza");
	}

	public void cut() {
		System.out.println("cut Pizza");
	}

	public void box() {
		System.out.println("box Pizza");
	}

	public String getName() {
		return name;
	}
}


text:
/**
 * Autogenerated by Thrift Compiler (0.9.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.apache.hive.service.cli.thrift;

import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.thrift.scheme.IScheme;
import org.apache.thrift.scheme.SchemeFactory;
import org.apache.thrift.scheme.StandardScheme;

import org.apache.thrift.scheme.TupleScheme;
import org.apache.thrift.protocol.TTupleProtocol;
import org.apache.thrift.protocol.TProtocolException;
import org.apache.thrift.EncodingUtils;
import org.apache.thrift.TException;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.EnumMap;
import java.util.Set;
import java.util.HashSet;
import java.util.EnumSet;
import java.util.Collections;
import java.util.BitSet;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TStructTypeEntry implements org.apache.thrift.TBase<TStructTypeEntry, TStructTypeEntry._Fields>, java.io.Serializable, Cloneable {
  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TStructTypeEntry");

  private static final org.apache.thrift.protocol.TField NAME_TO_TYPE_PTR_FIELD_DESC = new org.apache.thrift.protocol.TField("nameToTypePtr", org.apache.thrift.protocol.TType.MAP, (short)1);

  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
  static {
    schemes.put(StandardScheme.class, new TStructTypeEntryStandardSchemeFactory());
    schemes.put(TupleScheme.class, new TStructTypeEntryTupleSchemeFactory());
  }

  private Map<String,Integer> nameToTypePtr; // required

  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
    NAME_TO_TYPE_PTR((short)1, "nameToTypePtr");

    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

    static {
      for (_Fields field : EnumSet.allOf(_Fields.class)) {
        byName.put(field.getFieldName(), field);
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    public static _Fields findByThriftId(int fieldId) {
      switch(fieldId) {
        case 1: // NAME_TO_TYPE_PTR
          return NAME_TO_TYPE_PTR;
        default:
          return null;
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, throwing an exception
     * if it is not found.
     */
    public static _Fields findByThriftIdOrThrow(int fieldId) {
      _Fields fields = findByThriftId(fieldId);
      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
      return fields;
    }

    /**
     * Find the _Fields constant that matches name, or null if its not found.
     */
    public static _Fields findByName(String name) {
      return byName.get(name);
    }

    private final short _thriftId;
    private final String _fieldName;

    _Fields(short thriftId, String fieldName) {
      _thriftId = thriftId;
      _fieldName = fieldName;
    }

    public short getThriftFieldId() {
      return _thriftId;
    }

    public String getFieldName() {
      return _fieldName;
    }
  }

  // isset id assignments
  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
  static {
    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
    tmpMap.put(_Fields.NAME_TO_TYPE_PTR, new org.apache.thrift.meta_data.FieldMetaData("nameToTypePtr", org.apache.thrift.TFieldRequirementType.REQUIRED,
        new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32            , "TTypeEntryPtr"))));
    metaDataMap = Collections.unmodifiableMap(tmpMap);
    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TStructTypeEntry.class, metaDataMap);
  }

  public TStructTypeEntry() {
  }

  public TStructTypeEntry(
    Map<String,Integer> nameToTypePtr)
  {
    this();
    this.nameToTypePtr = nameToTypePtr;
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public TStructTypeEntry(TStructTypeEntry other) {
    if (other.isSetNameToTypePtr()) {
      Map<String,Integer> __this__nameToTypePtr = new HashMap<String,Integer>();
      for (Map.Entry<String, Integer> other_element : other.nameToTypePtr.entrySet()) {

        String other_element_key = other_element.getKey();
        Integer other_element_value = other_element.getValue();

        String __this__nameToTypePtr_copy_key = other_element_key;

        Integer __this__nameToTypePtr_copy_value = other_element_value;

        __this__nameToTypePtr.put(__this__nameToTypePtr_copy_key, __this__nameToTypePtr_copy_value);
      }
      this.nameToTypePtr = __this__nameToTypePtr;
    }
  }

  public TStructTypeEntry deepCopy() {
    return new TStructTypeEntry(this);
  }

  @Override
  public void clear() {
    this.nameToTypePtr = null;
  }

  public int getNameToTypePtrSize() {
    return (this.nameToTypePtr == null) ? 0 : this.nameToTypePtr.size();
  }

  public void putToNameToTypePtr(String key, int val) {
    if (this.nameToTypePtr == null) {
      this.nameToTypePtr = new HashMap<String,Integer>();
    }
    this.nameToTypePtr.put(key, val);
  }

  public Map<String,Integer> getNameToTypePtr() {
    return this.nameToTypePtr;
  }

  public void setNameToTypePtr(Map<String,Integer> nameToTypePtr) {
    this.nameToTypePtr = nameToTypePtr;
  }

  public void unsetNameToTypePtr() {
    this.nameToTypePtr = null;
  }

  /** Returns true if field nameToTypePtr is set (has been assigned a value) and false otherwise */
  public boolean isSetNameToTypePtr() {
    return this.nameToTypePtr != null;
  }

  public void setNameToTypePtrIsSet(boolean value) {
    if (!value) {
      this.nameToTypePtr = null;
    }
  }

  public void setFieldValue(_Fields field, Object value) {
    switch (field) {
    case NAME_TO_TYPE_PTR:
      if (value == null) {
        unsetNameToTypePtr();
      } else {
        setNameToTypePtr((Map<String,Integer>)value);
      }
      break;

    }
  }

  public Object getFieldValue(_Fields field) {
    switch (field) {
    case NAME_TO_TYPE_PTR:
      return getNameToTypePtr();

    }
    throw new IllegalStateException();
  }

  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
  public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME_TO_TYPE_PTR:
      return isSetNameToTypePtr();
    }
    throw new IllegalStateException();
  }

  @Override
  public boolean equals(Object that) {
    if (that == null)
      return false;
    if (that instanceof TStructTypeEntry)
      return this.equals((TStructTypeEntry)that);
    return false;
  }

  public boolean equals(TStructTypeEntry that) {
    if (that == null)
      return false;

    boolean this_present_nameToTypePtr = true && this.isSetNameToTypePtr();
    boolean that_present_nameToTypePtr = true && that.isSetNameToTypePtr();
    if (this_present_nameToTypePtr || that_present_nameToTypePtr) {
      if (!(this_present_nameToTypePtr && that_present_nameToTypePtr))
        return false;
      if (!this.nameToTypePtr.equals(that.nameToTypePtr))
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    HashCodeBuilder builder = new HashCodeBuilder();

    boolean present_nameToTypePtr = true && (isSetNameToTypePtr());
    builder.append(present_nameToTypePtr);
    if (present_nameToTypePtr)
      builder.append(nameToTypePtr);

    return builder.toHashCode();
  }

  public int compareTo(TStructTypeEntry other) {
    if (!getClass().equals(other.getClass())) {
      return getClass().getName().compareTo(other.getClass().getName());
    }

    int lastComparison = 0;
    TStructTypeEntry typedOther = (TStructTypeEntry)other;

    lastComparison = Boolean.valueOf(isSetNameToTypePtr()).compareTo(typedOther.isSetNameToTypePtr());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetNameToTypePtr()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nameToTypePtr, typedOther.nameToTypePtr);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }

  public _Fields fieldForId(int fieldId) {
    return _Fields.findByThriftId(fieldId);
  }

  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
  }

  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder("TStructTypeEntry(");
    boolean first = true;

    sb.append("nameToTypePtr:");
    if (this.nameToTypePtr == null) {
      sb.append("null");
    } else {
      sb.append(this.nameToTypePtr);
    }
    first = false;
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws org.apache.thrift.TException {
    // check for required fields
    if (!isSetNameToTypePtr()) {
      throw new org.apache.thrift.protocol.TProtocolException("Required field 'nameToTypePtr' is unset! Struct:" + toString());
    }

    // check for sub-struct validity
  }

  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
    try {
      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
    try {
      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private static class TStructTypeEntryStandardSchemeFactory implements SchemeFactory {
    public TStructTypeEntryStandardScheme getScheme() {
      return new TStructTypeEntryStandardScheme();
    }
  }

  private static class TStructTypeEntryStandardScheme extends StandardScheme<TStructTypeEntry> {

    public void read(org.apache.thrift.protocol.TProtocol iprot, TStructTypeEntry struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TField schemeField;
      iprot.readStructBegin();
      while (true)
      {
        schemeField = iprot.readFieldBegin();
        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
          break;
        }
        switch (schemeField.id) {
          case 1: // NAME_TO_TYPE_PTR
            if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map10 = iprot.readMapBegin();
                struct.nameToTypePtr = new HashMap<String,Integer>(2*_map10.size);
                for (int _i11 = 0; _i11 < _map10.size; ++_i11)
                {
                  String _key12; // required
                  int _val13; // required
                  _key12 = iprot.readString();
                  _val13 = iprot.readI32();
                  struct.nameToTypePtr.put(_key12, _val13);
                }
                iprot.readMapEnd();
              }
              struct.setNameToTypePtrIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          default:
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      struct.validate();
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot, TStructTypeEntry struct) throws org.apache.thrift.TException {
      struct.validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (struct.nameToTypePtr != null) {
        oprot.writeFieldBegin(NAME_TO_TYPE_PTR_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, struct.nameToTypePtr.size()));
          for (Map.Entry<String, Integer> _iter14 : struct.nameToTypePtr.entrySet())
          {
            oprot.writeString(_iter14.getKey());
            oprot.writeI32(_iter14.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }

  private static class TStructTypeEntryTupleSchemeFactory implements SchemeFactory {
    public TStructTypeEntryTupleScheme getScheme() {
      return new TStructTypeEntryTupleScheme();
    }
  }

  private static class TStructTypeEntryTupleScheme extends TupleScheme<TStructTypeEntry> {

    @Override
    public void write(org.apache.thrift.protocol.TProtocol prot, TStructTypeEntry struct) throws org.apache.thrift.TException {
      TTupleProtocol oprot = (TTupleProtocol) prot;
      {
        oprot.writeI32(struct.nameToTypePtr.size());
        for (Map.Entry<String, Integer> _iter15 : struct.nameToTypePtr.entrySet())
        {
          oprot.writeString(_iter15.getKey());
          oprot.writeI32(_iter15.getValue());
        }
      }
    }

    @Override
    public void read(org.apache.thrift.protocol.TProtocol prot, TStructTypeEntry struct) throws org.apache.thrift.TException {
      TTupleProtocol iprot = (TTupleProtocol) prot;
      {
        org.apache.thrift.protocol.TMap _map16 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32());
        struct.nameToTypePtr = new HashMap<String,Integer>(2*_map16.size);
        for (int _i17 = 0; _i17 < _map16.size; ++_i17)
        {
          String _key18; // required
          int _val19; // required
          _key18 = iprot.readString();
          _val19 = iprot.readI32();
          struct.nameToTypePtr.put(_key18, _val19);
        }
      }
      struct.setNameToTypePtrIsSet(true);
    }
  }

}


text:
cask 'bluestacks' do
  version '4.70.0.2803'
  sha256 'dc1af2237854d9edf6b63bc8fac17a4df58b8ab6b107673106b30cb506589d0f'

  url "https://cdn3.bluestacks.com/downloads/mac/bgp_mac/#{version}/BlueStacksInstaller_#{version}.dmg"
  name 'BlueStacks'
  homepage 'https://www.bluestacks.com/'

  depends_on macos: '>= :sierra'

  installer manual: 'BlueStacks Installer.app'

  uninstall_preflight do
    set_ownership "#{appdir}/BlueStacks.app"
  end

  uninstall launchctl: [
                         'com.BlueStacks.AppPlayer.bstservice_helper',
                         'com.BlueStacks.AppPlayer.Service',
                         'com.BlueStacks.AppPlayer.UninstallWatcher',
                         'com.BlueStacks.AppPlayer.Updater',
                       ],
            delete:    '/Library/PrivilegedHelperTools/com.BlueStacks.AppPlayer.bstservice_helper'

  zap trash: [
               '~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/com.bluestacks.bluestacks.sfl*',
               '~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/com.bluestacks.bluestacks-support-tool.sfl*',
               '~/Library/BlueStacks',
               '~/Library/Caches/com.bluestacks.BlueStacks',
               '~/Library/Caches/com.bluestacks.BlueStacks-Support-Tool',
               '~/Library/Caches/KSCrashReports/BlueStacks',
               '~/Library/Logs/BlueStacks',
               '~/Library/Preferences/com.BlueStacks.AppPlayer.DiagnosticTimestamp.txt',
               '~/Library/Preferences/com.BlueStacks.AppPlayer.plist',
               '~/Library/Preferences/com.BlueStacks.AppPlayer.SavedFrame.plist',
               '~/Library/Preferences/com.bluestacks.BlueStacks.plist',
             ],
      rmdir: '~/Library/Caches/KSCrashReports'
end


text:
/**
 *
 */
package rocks.bottery.bot.dialogs;

import rocks.bottery.bot.IActivity;
import rocks.bottery.bot.ISession;
import rocks.bottery.bot.util.IModel;
import rocks.bottery.bot.util.Model;

/**
 * Base dialog that just outputs a sentence and finishes without expecting any user input
 *
 * @author Harald Kuhn
 *
 */
public class Utterance extends DialogBase {

	private IModel<String> text;

	public Utterance(String text) {
		this(new Model<String>(text));
	}

	public Utterance(IModel<String> text) {
		this.text = text;
	}

	protected Utterance() {
	}

	@Override
	public void handle(ISession session, IActivity request) {
		session.activeDialogFinished();
		super.handle(session, request);
	}

	@Override
	public IModel<String> getText(IActivity request, ISession session) {
		return text;
	}

}


text:
/* NOTE: This file is autogenerated, do not edit this file directly.*/

#include <TRChartsJNI/LineSeries.hpp>
#include <TRChartsJNI/Support/Marshallers.hpp>
#include <TRChartsJNI/Support/Handle.hpp>
#include <TRChartsJNI/Support/Utils.hpp>
#include <TRCharts/LineSeries.hpp>

using namespace TRChartsJNI;

JNIEXPORT jlong JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeCreate(JNIEnv *env, jobject obj)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		Charts::LineSeries * const nativeObject = new Charts::LineSeries();
		Handle * const handle = new Handle(env, nativeObject, obj);
		nativeObject->setHandle(handle);
		return reinterpret_cast<jlong>(handle);
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT void JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeDestroy(JNIEnv *env, jobject obj, jlong ptr)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		delete handle;
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT jobject JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeGetLineStyle(JNIEnv * env, jobject obj, jlong ptr)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		return TRChartsJNI::getLineStyleMarshaller().unmarshall(env, handle->getNativeObject<Charts::LineSeries>(env)->getLineStyle());
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT void JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeSetLineStyle(JNIEnv * env, jobject obj, jlong ptr, jobject value)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		handle->getNativeObject<Charts::LineSeries>(env)->setLineStyle(TRChartsJNI::getLineStyleMarshaller().marshall(env, value));
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}
JNIEXPORT jobject JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeGetLineStyleSource(JNIEnv * env, jobject obj, jlong ptr)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		return TRChartsJNI::getLineStyleSourceMarshaller().unmarshall(env, handle->getNativeObject<Charts::LineSeries>(env)->getLineStyleSource());
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT void JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeSetLineStyleSource(JNIEnv * env, jobject obj, jlong ptr, jobject value)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		handle->getNativeObject<Charts::LineSeries>(env)->setLineStyleSource(TRChartsJNI::getLineStyleSourceMarshaller().marshall(env, value));
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}
JNIEXPORT jobject JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeGetDataSource(JNIEnv * env, jobject obj, jlong ptr)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		return TRChartsJNI::getContinuousDataSource_ScalarDatumMarshaller().unmarshall(env, handle->getNativeObject<Charts::LineSeries>(env)->getDataSource());
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT void JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeSetDataSource(JNIEnv * env, jobject obj, jlong ptr, jobject value)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		handle->getNativeObject<Charts::LineSeries>(env)->setDataSource(TRChartsJNI::getContinuousDataSource_ScalarDatumMarshaller().marshall(env, value));
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT jobject JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeGetDatum(JNIEnv * env, jobject obj, jlong ptr, jlong index)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		return TRChartsJNI::getScalarDatumMarshaller().unmarshall(env, handle->getNativeObject<Charts::LineSeries>(env)->getDatum(TRChartsJNI::getIntegerMarshaller().marshall(env, index)));
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}

JNIEXPORT jobject JNICALL Java_com_thomsonreuters_corptech_charts_LineSeries_nativeInterpolateDatum(JNIEnv * env, jobject obj, jlong ptr, jdouble abscissa)
{
	try {
		Utils::threadEnter(env);
		Utils::EndScopeAction threadExitAction(Utils::threadExit);
		TRChartsJNI::Handle * const handle = reinterpret_cast<TRChartsJNI::Handle *>(ptr);
		return TRChartsJNI::getScalarDatumMarshaller().unmarshall(env, handle->getNativeObject<Charts::LineSeries>(env)->interpolateDatum(TRChartsJNI::getNumberMarshaller().marshall(env, abscissa)));
	} catch (const std::exception & e) {
		Utils::throwJavaException(env, e.what());
	} catch (...) {
		Utils::throwJavaException(env, nullptr);
	}
}


text:
using UnityEngine;

namespace HoloToolkit.Unity.InputModule
{
    public class GamePadHandlerBase : MonoBehaviour, ISourceStateHandler
    {
        [SerializeField]
        [Tooltip("True, if gaze is not required for Input")]
        protected bool IsGlobalListener = true;

        protected string GamePadName = string.Empty;

        private void OnEnable()
        {
            if (IsGlobalListener)
            {
                InputManager.Instance.AddGlobalListener(gameObject);
            }
        }

        protected virtual void OnDisable()
        {
            if (IsGlobalListener && InputManager.Instance != null)
            {
                InputManager.Instance.RemoveGlobalListener(gameObject);
            }
        }

        public virtual void OnSourceDetected(SourceStateEventData eventData)
        {
            // Override and name your GamePad source.
        }

        public virtual void OnSourceLost(SourceStateEventData eventData)
        {
            GamePadName = string.Empty;
        }
    }
}


text:
package depoi.austral.dao.interfaces;

import depoi.austral.model.Tournament;

import java.util.List;

import javax.jdo.PersistenceManagerFactory;

import org.springframework.dao.DataAccessException;

public interface TournamentDAO {
    List<Tournament> retrieveCurrentTournaments();

	public void setPersistenceManagerFactory(PersistenceManagerFactory persistenceManagerFactory);

	public void makePersistent(Tournament tournament)throws DataAccessException;

	public void remove(Tournament tournament)throws DataAccessException;

	public Tournament loadTournament(Tournament tournament)throws DataAccessException;

	public void modifyTournament(Tournament tournament)throws DataAccessException;

	public Tournament byName(String name)throws Exception;

	public boolean exist(Long id)throws Exception;

	public Tournament byId(Long id)throws Exception;
}


text:
package org.jetbrains.plugins.groovy.lang.psi.stubs.elements;

import com.intellij.psi.stubs.EmptyStub;
import com.intellij.psi.stubs.EmptyStubElementType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.groovy.GroovyLanguage;
import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotationArgumentList;
import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.annotation.GrAnnotationArgumentListImpl;

public class GrAnnotationArgumentListElementType extends EmptyStubElementType<GrAnnotationArgumentList> {

  public GrAnnotationArgumentListElementType(String debugName) {
    super(debugName, GroovyLanguage.INSTANCE);
  }

  @Override
  public boolean isLeftBound() {
    return true;
  }

  @Override
  public GrAnnotationArgumentList createPsi(@NotNull EmptyStub stub) {
    return new GrAnnotationArgumentListImpl(stub);
  }
}


text:
module("test module");
test("fail test", function(){
	ok( false, "Will failed!" );
});

module("test module2");
test("fail test", function(){
	ok( false, "Will failed!" );
});


text:
require 'spec_helper'

describe GitlabRuby do
  let(:client) { GitlabRuby::Client.new(token: TEST_API_KEY, version: "v4") }

  before do
    GitlabRuby::Client.debug = true # Toggle DEBUG for additional logs
  end

  it 'has a version number' do
    expect(GitlabRuby::VERSION).not_to be nil
  end

  it 'get single project', vcr: true do
    project = client.get.projects.id(2868483).execute
    expect(project.name).to eq 'rn.absent'
  end

  it 'restarts a new chain of queries' do
    project1 = client.get.projects.id(2868483).issues
    project2 = client.get.projects.id(2868483)
    expect(project1.urlstring).to eq 'projects/2868483/issues/'
    expect(project2.urlstring).to eq 'projects/2868483/'
  end

  describe 'Pagination' do
    it 'next_page?', vcr: true do
      projects = client.get.projects.execute
      expect(projects.next_page?).to be true
    end
    it 'fetches the next page', vcr: true do
      projects = client.get.projects.execute
      projects = projects.next_page
      expect(projects.prev_page?).to be true
    end
  end

  describe 'Errors' do
    it 'raises bad request error', vcr: true do
      expect{ client.post.projects.execute }.to raise_error GitlabRuby::BadRequestError
    end

    it 'raises unauthorized error', vcr: true do
      invalid_client = GitlabRuby::Client.new(token: "INVALID KEY")
      expect{ invalid_client.post.projects.execute }.to raise_error GitlabRuby::UnauthorizedError
    end

    it 'raises forbidden error', vcr: true do
      expect{ client.put.projects.id(2868483).execute(name: "UPDATE") }.to raise_error GitlabRuby::ForbiddenError
    end

    it 'raises not found error', vcr: true do
      expect{ client.get.projects.id(100).execute }.to raise_error GitlabRuby::NotFoundError
    end

    # it 'raises method not allowed error' do
    #   skip "NOT IMPLEMENTED"
    # end

    it 'raises conflict error', vcr: true do
      expect{ client.put.projects.id(2868483).execute(name: "UPDATE") }.to raise_error GitlabRuby::ForbiddenError
    end

    # it 'raises unprocessable error' do
    #   skip "NOT IMPLEMENTED"
    # end

    # it 'raises server error' do
    #   skip "NOT IMPLEMENTED"
    # end
  end
end


text:
from datetime import datetime, timedelta

from tests import base
from tests import factories as f
from wye.base.constants import WorkshopStatus, WorkshopLevel
from wye.regions.models import RegionalLead

outbox_len = 0
password = '123123'

def test_workshop_list(base_url, browser, outbox):
    """
    Following testcases will be checked:
    - Check workshop listing for user with usertype poc
    - Check workshop listing for user with usertype tutor
    - Check workshop listing for user with usertype lead
    - Check workshop listing for user with no usertype
    """

    # Create usertypes
    regional_lead_type = f.create_usertype(
        slug='lead', display_name='regional lead')
    f.create_usertype(slug='tutor', display_name='tutor')
    poc_type = f.create_usertype(slug='poc', display_name='poc')
    state = f.create_state()
    # Testcase with usertyep poc
    user = base.create_user(password)
    url = base_url + '/workshop/'
    base.login_and_confirm(browser, url, outbox, user, password)
    user.profile.usertype.clear()
    user.profile.usertype.add(poc_type)
    user.profile.interested_states.add(state)
    user.profile.save()
    user.save()

    # Create org
    location = f.create_locaiton(state=state)
    org = f.create_organisation(location=location)
    org.user.add(user)
    user.profile.interested_locations.add(location)
    user.profile.location = org.location
    user.profile.save()
    org.save()

    # Create workshop
    workshop = f.create_workshop(requester=org)
    workshop.expected_date = datetime.now() + timedelta(days=20)
    workshop.status = WorkshopStatus.REQUESTED
    workshop.level = WorkshopLevel.BEGINNER
    workshop.location = org.location
    workshop.save()

    url = base_url + '/workshop/'
    base.login(browser, url, user, password)
    data_check = browser.find_by_text(org.name)
    assert data_check

    browser.visit(url + "?location={}".format(org.location.id))
    data_check = browser.find_by_text(org.name)
    assert data_check

    browser.visit(url + "?location={}".format(org.location.id + 1))
    data_check = browser.find_by_text(org.name)
    assert not data_check

    browser.visit(url + "?level={}".format(WorkshopStatus.ACCEPTED))
    data_check = browser.find_by_text(org.name)
    assert not data_check

    # Testcase for usertype tutor
    browser.visit(base_url + "/accounts/logout")
    user = base.create_user(password)
    url = base_url + '/workshop/'
    base.login_and_confirm(browser, url, outbox, user, password)
    # user.profile.usertype.add(tutor_type)
    # user.save()

    # User associated with workshop
    workshop.presenter.add(user)
    browser.visit(url)
    # data_check = browser.find_by_text(org.name)
    # assert data_check

    # Testcase for lead
    browser.visit(base_url + "/accounts/logout")
    user = base.create_user(password)
    url = base_url + '/workshop/'
    base.login_and_confirm(browser, url, outbox, user, password)

    user.profile.usertype.add(regional_lead_type)
    user.save()
    lead = RegionalLead.objects.create(location=org.location)
    lead.leads.add(user)

    url = base_url + '/workshop/'
    base.login(browser, url, user, password)
    # data_check = browser.find_by_text(org.name)
    # assert data_check

    # Testcase for user with no usertype
    browser.visit(base_url + "/accounts/logout")
    user = base.create_user(password)
    url = base_url + '/workshop/'
    base.login_and_confirm(browser, url, outbox, user, password)

    url = base_url + '/workshop/'
    base.login(browser, url, user, password)
    # data_check = browser.find_by_text(org.name)
    # assert [] == data_check
    browser.visit(base_url + "/accounts/logout")


text:
package org.apache.flink.runtime.executiongraph;

import static org.apache.flink.runtime.executiongraph.ExecutionGraphTestUtils.*;
import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;

import java.util.ArrayList;
import java.util.Arrays;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.runtime.blob.BlobKey;
import org.apache.flink.runtime.execution.librarycache.BlobLibraryCacheManager;
import org.apache.flink.runtime.instance.AllocatedSlot;
import org.apache.flink.runtime.jobgraph.AbstractJobVertex;
import org.apache.flink.runtime.jobgraph.JobID;
import org.apache.flink.runtime.jobgraph.JobStatus;
import org.apache.flink.runtime.jobgraph.JobVertexID;
import org.apache.flink.runtime.jobgraph.tasks.AbstractInvokable;
import org.apache.flink.runtime.protocols.TaskOperationProtocol;
import org.junit.Test;

public class ExecutionStateProgressTest {

	@Test
	public void testAccumulatedStateFinished() {
		try {
			final JobID jid = new JobID();
			final JobVertexID vid = new JobVertexID();

			AbstractJobVertex ajv = new AbstractJobVertex("TestVertex", vid);
			ajv.setParallelism(3);
			ajv.setInvokableClass(mock(AbstractInvokable.class).getClass());

			ExecutionGraph graph = new ExecutionGraph(jid, "test job", new Configuration());
			graph.attachJobGraph(Arrays.asList(ajv));

			setGraphStatus(graph, JobStatus.RUNNING);

			ExecutionJobVertex ejv = graph.getJobVertex(vid);

			// mock resources and mock taskmanager
			TaskOperationProtocol taskManager = getSimpleAcknowledgingTaskmanager();
			for (ExecutionVertex ee : ejv.getTaskVertices()) {
				AllocatedSlot slot = getInstance(taskManager).allocateSlot(jid);
				ee.deployToSlot(slot);
			}

			// finish all
			for (ExecutionVertex ee : ejv.getTaskVertices()) {
				ee.executionFinished();
			}

			assertTrue(ejv.isInFinalState());
			assertEquals(JobStatus.FINISHED, graph.getState());
		}
		catch (Exception e) {
			e.printStackTrace();
			fail(e.getMessage());
		}
	}
}


text:
<?xml version="1.0"?>

<project name="dependencies" basedir="." xmlns:ivy="antlib:org.apache.ivy.ant">
	<property file="project.properties" />

	<!-- OVERLOADED-->
	<property name="ivy.resolve.configurations" value="processor,impl-test" />
	<property name="ivy.generated.artifacts.pattern" value="${ivy.generated.artifacts.dir}/lib/[artifact]-[revision].[ext]" />

	<property name="ivy-shared-targets.file" location="${basedir}/../../antfiles/ivy/ivy-shared-targets.xml" />
	<import file="${ivy-shared-targets.file}" />

	<target name="do.resolve-dependencies" depends="pre.resolve-dependencies">
		<ivy:retrieve conf="impl-test" pattern="${ivy.resolved.artifacts.dir}/dependencies/test/jars/[originalname](.[ext])" sync="true" type="jar"/>
		<ivy:retrieve conf="impl-test" pattern="${ivy.resolved.artifacts.dir}/dependencies/test/xsds/[artifact](.[ext])" sync="true" type="xsd"/>
		<ivy:retrieve conf="processor" pattern="${ivy.resolved.artifacts.dir}/dependencies/jars/[originalname](.[ext])" sync="true" type="jar" />
	</target>

	<!-- Overloaded to support multiple artifact patterns  -->
	<target name="do.publish" depends="pre.publish">
		<publish-artifacts>
			<artifacts-list>
				<artifacts pattern="${ivy.generated.artifacts.dir}/lib/[artifact]-[revision].[ext]" />
				<artifacts pattern="${basedir}/test/docs/[artifact].[ext]" />
			</artifacts-list>
		</publish-artifacts>
	</target>
</project>


text:
// Generated by CoffeeScript 1.3.3

/*
dry-observer
v0.2.1

LICENSE: http://github.com/arbales/dry-observer/raw/master/LICENSE
*/

(function() {
  var InvalidBindingError, Observers, capitalize, createListener, deprecatedBackbone, destroyListener, eventSplitter, exports, root, _,
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    __slice = [].slice;

  root = this;

  _ = root._;

  if (!_ && (typeof require !== "undefined" && require !== null)) {
    _ = require('underscore');
  }

  InvalidBindingError = (function(_super) {

    __extends(InvalidBindingError, _super);

    function InvalidBindingError(event, handler) {
      this.name = "InvalidBindingError";
      this.message = "Unable create binding for `" + event + "` due unimplemented handler: `#" + handler + "`";
    }

    return InvalidBindingError;

  })(Error);

  capitalize = function(string) {
    if (!string) {
      return "";
    }
    return string.charAt(0).toUpperCase() + string.slice(1);
  };

  deprecatedBackbone = (typeof Backbone !== "undefined" && Backbone !== null) && parseFloat(Backbone.VERSION) < 0.9;

  eventSplitter = /\s+/;

  createListener = function(target, events, callback, context) {
    var event, _i, _j, _len, _len1, _ref, _ref1, _results, _results1;
    if (target.addListener) {
      _ref = events.split(eventSplitter);
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        event = _ref[_i];
        _results.push(target.addListener(event, callback));
      }
      return _results;
    } else if (deprecatedBackbone) {
      _ref1 = events.split(eventSplitter);
      _results1 = [];
      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
        event = _ref1[_j];
        _results1.push(target.bind(event, callback, context));
      }
      return _results1;
    } else if (target.on) {
      return target.on(events, handler, context);
    } else {
      throw new TypeError("Expected an EventEmitter or Backbone.Events-compatible target.");
    }
  };

  destroyListener = function(target, events, callback) {
    var event, _i, _j, _len, _len1, _ref, _ref1, _results, _results1;
    if (target.removeListener) {
      _ref = events.split(eventSplitter);
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        event = _ref[_i];
        _results.push(target.removeListener(event, callback));
      }
      return _results;
    } else if (deprecatedBackbone) {
      _ref1 = events.split(eventSplitter);
      _results1 = [];
      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
        event = _ref1[_j];
        _results1.push(target.unbind(event, callback));
      }
      return _results1;
    } else if (target.off) {
      return target.off(events, handler);
    } else {
      throw new TypeError("Expected an EventEmitter or Backbone.Events-compatible target.");
    }
  };

  Observers = {
    _observedObjects: null,
    _observers: null,
    observe: function() {
      var context, event, events, handler, parsedEvents, target, targetEvents, _base, _name,
        _this = this;
      target = arguments[0], events = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
      context = null;
      this._eventHandlerPrefix || (this._eventHandlerPrefix = 'on');
      if (events.length === 1) {
        if ((_(events[0])).isString()) {
          events = events[0].split(" ");
        }
        if ((_(events[0])).isObject()) {
          events = events[0];
        }
      } else if (_.isObject(_.last(events))) {
        context = events.pop();
      }
      if (_.isString(events[0])) {
        parsedEvents = {};
        _.each(events, function(e) {
          var action, handler, scope, _ref;
          _ref = e.split(':'), action = _ref[0], scope = _ref[1];
          handler = [_this._eventHandlerPrefix, capitalize(action), capitalize(scope)].join('');
          handler = _this[handler] || _this[e] || (function() {
            throw new InvalidBindingError(e, handler);
          })();
          return parsedEvents[e] = handler;
        });
        events = parsedEvents;
      }
      if (!_.isObject(events)) {
        throw new TypeError("Observe accepts either a String, an Array of Strings, or an Object.");
      }
      if (!target.cid) {
        target.cid = _.uniqueId('observed');
      }
      this._observedObjects = _.union((this._observedObjects || (this._observedObjects = [])), target);
      targetEvents = (_base = (this._observers || (this._observers = {})))[_name = target.cid] || (_base[_name] = {});
      for (event in events) {
        if (!__hasProp.call(events, event)) continue;
        handler = events[event];
        createListener(target, event, handler, context);
        (targetEvents[event] || (targetEvents[event] = [])).push(handler);
      }
      return true;
    },
    stopObserving: function(target) {
      var event, events, handler, handlers, index, _i, _j, _len, _len1, _ref;
      if (target == null) {
        target = false;
      }
      if (!(this._observedObjects && this._observers)) {
        return false;
      }
      if (!target) {
        _ref = this._observedObjects;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          target = _ref[_i];
          if (target) {
            this.stopObserving(target);
          }
        }
        return false;
      }
      events = this._observers[target.cid];
      for (event in events) {
        if (!__hasProp.call(events, event)) continue;
        handlers = events[event];
        for (index = _j = 0, _len1 = handlers.length; _j < _len1; index = ++_j) {
          handler = handlers[index];
          destroyListener(target, event, handler);
          delete [handlers][index];
        }
      }
      delete this._observedObjects[_.indexOf(this._observedObjects, target)];
      delete this._observers[target.cid];
      return true;
    },
    removeObserver: function(target, event, handlerToRemove) {
      var events, handler, handlers, index, _i, _j, _len, _len1, _ref;
      if (!target) {
        _ref = this._observedObjects;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          target = _ref[_i];
          this.removeObserver(target);
        }
      }
      events = _observers[target.cid];
      for (event in events) {
        if (!__hasProp.call(events, event)) continue;
        handlers = events[event];
        for (index = _j = 0, _len1 = handlers.length; _j < _len1; index = ++_j) {
          handler = handlers[index];
          if (handlerToRemove && handler !== handlerToRemove) {
            continue;
          }
          target.off(event, handler);
          events[event][index] = null;
          delete events[event][index];
        }
      }
      return true;
    }
  };

  exports = (typeof module !== "undefined" && module !== null ? module.exports : void 0) || this;

  exports.Observers = Observers;

}).call(this);


text:
using System;
using NetOffice;
using NetOffice.Attributes;
namespace NetOffice.WordApi.Enums
{
	 /// <summary>
	 /// SupportByVersion Word 12, 14, 15, 16
	 /// </summary>
	 ///<remarks> MSDN Online Documentation: <see href="https://docs.microsoft.com/en-us/office/vba/api/Word.WdGranularity"/> </remarks>
	[SupportByVersion("Word", 12,14,15,16)]
	[EntityType(EntityType.IsEnum)]
	public enum WdGranularity
	{
		 /// <summary>
		 /// SupportByVersion Word 12, 14, 15, 16
		 /// </summary>
		 /// <remarks>0</remarks>
		 [SupportByVersion("Word", 12,14,15,16)]
		 wdGranularityCharLevel = 0,

		 /// <summary>
		 /// SupportByVersion Word 12, 14, 15, 16
		 /// </summary>
		 /// <remarks>1</remarks>
		 [SupportByVersion("Word", 12,14,15,16)]
		 wdGranularityWordLevel = 1
	}
}


text:
// Copyright 2020 The XLS Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "xls/passes/ternary_query_engine.h"

#include <limits>

#include "absl/container/inlined_vector.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "xls/common/status/status_macros.h"
#include "xls/data_structures/leaf_type_tree.h"
#include "xls/ir/abstract_node_evaluator.h"
#include "xls/ir/bits_ops.h"
#include "xls/ir/dfs_visitor.h"
#include "xls/ir/node_iterator.h"
#include "xls/passes/ternary_evaluator.h"

namespace xls {

// Returns whether the operation will be computationally expensive to
// compute. The ternary query engine is intended to be fast so the analysis of
// these expensive operations is skipped with the effect being all bits are
// considered unknown. Operations and limits can be added as needed when
// pathological cases are encountered.
static bool IsExpensiveToEvaluate(Node* node) {
  // Shifts are quadratic in the width of the operand so wide shifts are very
  // slow to evaluate in the abstract evaluator.
  return (node->op() == Op::kShrl || node->op() == Op::kShra ||
          node->op() == Op::kShll) &&
         node->GetType()->GetFlatBitCount() > 256;
}

Bits TernaryVectorToKnownBits(const TernaryEvaluator::Vector& ternary_vector) {
  // Use InlinedVector to avoid std::vector<bool> specialization madness.
  absl::InlinedVector<bool, 1> bits(ternary_vector.size());
  for (int64_t i = 0; i < bits.size(); ++i) {
    bits[i] = (ternary_vector[i] == TernaryValue::kKnownOne ||
               ternary_vector[i] == TernaryValue::kKnownZero);
  }
  return Bits(bits);
}

Bits TernaryVectorToValueBits(const TernaryEvaluator::Vector& ternary_vector) {
  // Use InlinedVector to avoid std::vector<bool> specialization madness.
  absl::InlinedVector<bool, 1> bits(ternary_vector.size());
  for (int64_t i = 0; i < bits.size(); ++i) {
    bits[i] = ternary_vector[i] == TernaryValue::kKnownOne;
  }
  return Bits(bits);
}

absl::StatusOr<ReachedFixpoint> TernaryQueryEngine::Populate(FunctionBase* f) {
  TernaryEvaluator evaluator;
  absl::flat_hash_map<Node*, TernaryEvaluator::Vector> values;
  for (Node* node : TopoSort(f)) {
    if (!node->GetType()->IsBits()) {
      continue;
    }
    auto create_unknown_vector = [](Node* n) {
      return TernaryEvaluator::Vector(n->BitCountOrDie(),
                                      TernaryValue::kUnknown);
    };
    if (IsExpensiveToEvaluate(node) ||
        std::any_of(node->operands().begin(), node->operands().end(),
                    [](Node* o) { return !o->GetType()->IsBits(); })) {
      values[node] = create_unknown_vector(node);
      continue;
    }

    std::vector<TernaryEvaluator::Vector> operand_values;
    for (Node* operand : node->operands()) {
      operand_values.push_back(values.at(operand));
    }
    XLS_ASSIGN_OR_RETURN(
        values[node],
        AbstractEvaluate(node, operand_values, &evaluator,
                         /*default_handler=*/create_unknown_vector));
  }

  ReachedFixpoint rf = ReachedFixpoint::Unchanged;
  for (Node* node : f->nodes()) {
    // TODO(meheff): Handle types other than bits.
    if (node->GetType()->IsBits()) {
      if (!known_bits_.contains(node)) {
        known_bits_[node] = Bits(values.at(node).size());
        bits_values_[node] = Bits(values.at(node).size());
      }
      Bits combined_known_bits = bits_ops::Or(
          known_bits_[node], TernaryVectorToKnownBits(values.at(node)));
      Bits combined_bits_values = bits_ops::Or(
          bits_values_[node], TernaryVectorToValueBits(values.at(node)));
      if ((combined_known_bits != known_bits_[node]) ||
          (combined_bits_values != bits_values_[node])) {
        rf = ReachedFixpoint::Changed;
      }
      known_bits_[node] = combined_known_bits;
      bits_values_[node] = combined_bits_values;
    }
  }
  return rf;
}

bool TernaryQueryEngine::AtMostOneTrue(
    absl::Span<TreeBitLocation const> bits) const {
  int64_t maybe_one_count = 0;
  for (const TreeBitLocation& location : bits) {
    if (!IsKnown(location) || IsOne(location)) {
      maybe_one_count++;
    }
  }
  return maybe_one_count <= 1;
}

bool TernaryQueryEngine::AtLeastOneTrue(
    absl::Span<TreeBitLocation const> bits) const {
  for (const TreeBitLocation& location : bits) {
    if (IsOne(location)) {
      return true;
    }
  }
  return false;
}

bool TernaryQueryEngine::KnownEquals(const TreeBitLocation& a,
                                     const TreeBitLocation& b) const {
  return IsKnown(a) && IsKnown(b) && IsOne(a) == IsOne(b);
}

bool TernaryQueryEngine::KnownNotEquals(const TreeBitLocation& a,
                                        const TreeBitLocation& b) const {
  return IsKnown(a) && IsKnown(b) && IsOne(a) != IsOne(b);
}

}  // namespace xls


text:
#pragma once

#include <aws/core/client/AWSError.h>
#include <aws/core/client/CoreErrors.h>
#include <aws/elastictranscoder/ElasticTranscoder_EXPORTS.h>

namespace Aws
{
namespace ElasticTranscoder
{
enum class ElasticTranscoderErrors
{
  //From Core//
  //////////////////////////////////////////////////////////////////////////////////////////
  INCOMPLETE_SIGNATURE = 0,
  INTERNAL_FAILURE = 1,
  INVALID_ACTION = 2,
  INVALID_CLIENT_TOKEN_ID = 3,
  INVALID_PARAMETER_COMBINATION = 4,
  INVALID_QUERY_PARAMETER = 5,
  INVALID_PARAMETER_VALUE = 6,
  MISSING_ACTION = 7, // SDK should never allow
  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
  MISSING_PARAMETER = 9, // SDK should never allow
  OPT_IN_REQUIRED = 10,
  REQUEST_EXPIRED = 11,
  SERVICE_UNAVAILABLE = 12,
  THROTTLING = 13,
  VALIDATION = 14,
  ACCESS_DENIED = 15,
  RESOURCE_NOT_FOUND = 16,
  UNRECOGNIZED_CLIENT = 17,
  MALFORMED_QUERY_STRING = 18,
  SLOW_DOWN = 19,
  REQUEST_TIME_TOO_SKEWED = 20,
  INVALID_SIGNATURE = 21,
  SIGNATURE_DOES_NOT_MATCH = 22,
  INVALID_ACCESS_KEY_ID = 23,
  REQUEST_TIMEOUT = 24,
  NETWORK_CONNECTION = 99,

  UNKNOWN = 100,
  ///////////////////////////////////////////////////////////////////////////////////////////

  INCOMPATIBLE_VERSION= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
  INTERNAL_SERVICE,
  LIMIT_EXCEEDED,
  RESOURCE_IN_USE
};

class AWS_ELASTICTRANSCODER_API ElasticTranscoderError : public Aws::Client::AWSError<ElasticTranscoderErrors>
{
public:
  ElasticTranscoderError() {}
  ElasticTranscoderError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<ElasticTranscoderErrors>(rhs) {}
  ElasticTranscoderError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<ElasticTranscoderErrors>(rhs) {}
  ElasticTranscoderError(const Aws::Client::AWSError<ElasticTranscoderErrors>& rhs) : Aws::Client::AWSError<ElasticTranscoderErrors>(rhs) {}
  ElasticTranscoderError(Aws::Client::AWSError<ElasticTranscoderErrors>&& rhs) : Aws::Client::AWSError<ElasticTranscoderErrors>(rhs) {}

  template <typename T>
  T GetModeledError();
};

namespace ElasticTranscoderErrorMapper
{
  AWS_ELASTICTRANSCODER_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
}

} // namespace ElasticTranscoder
} // namespace Aws


text:
![](https://github.com/DreamCatcherJ/JCNewFeatureVC/blob/master/demo.gif?raw=true)

#演示项目
查看并运行 JCNewFeatureVCDemo.xcodeproj

#安装#
CocoaPods

- 在 Podfile 中添加 pod "JCNewFeatureVC"。
- 执行 pod install 或 pod update。
- 导入 \<JCNewFeatureNormalVC.h\> 或者 \<JCNewFeatureNormalVC.h\>

#如何使用#
在AppDelegate中的`- (BOOL)application:didFinishLaunchingWithOptions:`方法中

```
BOOL needShow = [JCNewFeatureNormalVC needShowNewFeature];// 根据程序是否第一次运行来显示新特性页面
if(needShow){
    // 先创建好需要展示的新特性图片
    UIImage *image1 = [UIImage imageNamed:@"image1"];
    UIImage *image2 = [UIImage imageNamed:@"image2"];
  下面的代码放在这里👇
}
```

#####普通效果初始化方法1
传入需要展示的图片,最后一页用controller来管理

```
UIStoryboard *sb = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
        ViewController *vc = [sb instantiateInitialViewController];
        JCNewFeatureNormalVC *newContr =[JCNewFeatureNormalVC newFeatureWithImages:@[image1,image2] andLastVC:vc];
        self.window.rootViewController = newContr;
```

- 初始化控制器放入新特性页面的图片
- 因为通常在新特性最后一张图片会有点击按钮,所以最后一个页面传入一个控制器进行点击等事件处理

#####普通效果初始化方法2
只需传入需要展示的图片

```
JCNewFeatureNormalVC *newContr =[JCNewFeatureNormalVC newFeatureWithImages:@[page1,page2,page3] enterBlock:^{
            NSLog(@"enter");
            [self enterHomeVC];
        }];
        self.window.rootViewController = newContr;
```
- 点击最后一张图片的block回调

#####普通效果初始化方法3
传入每一页对应的控制器

```
UIViewController *oneVC = [[UIViewController alloc] init];
        oneVC.view.backgroundColor = [UIColor orangeColor];

        UIViewController *twoVC = [[UIViewController alloc] init];
        twoVC.view.backgroundColor = [UIColor blueColor];

        UIStoryboard *sb = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
        ViewController *threeVC = [sb instantiateInitialViewController];

        window.rootViewController = [JCNewFeatureNormalVC newFeatureWithControllers:@[oneVC,twoVC,threeVC]];
```
- 每一个页面都是由一个控制器管理,高度自定义每一个页面

####如果想换成gif中的翻页效果,只需要把上面方法中的`JCNewFeatureNormalVC` 换成 `JCNewFeaturePagingVC `

<b>简书地址:[http://www.jianshu.com/p/8f267c9b9565)


text: A simple solution for deploying micro services


text:
package skinny.micro.response

import skinny.micro.cookie.Cookie

/**
 * skinny.micro's action result.
 */
case class ActionResult(
  status: ResponseStatus,
  body: Any,
  headers: Map[String, String] = Map.empty,
  contentType: Option[String] = None,
  charset: Option[String] = None,
  cookies: Seq[Cookie] = Seq.empty)


text:
```[in root folder] npm test```

### Browser

```[in spec folder] make & open spec.html```


text:
package jp.relx

import org.scalatra.test.specs2._

// For more on Specs2, see http://etorreborre.github.com/specs2/guide/org.specs2.guide.QuickStart.html
class SearchSpec extends ScalatraSpec { def is =
  "GET / on Search"                     ^
    "should return status 200"                  ! root200^
                                                end

  addServlet(classOf[Search], "/*")

  def root200 = get("/") {
    status must_== 200
  }
}


text:
<!DOCTYPE frameset SYSTEM "frameset.dtd">
<frameset>
    <predicate lemma="breed">
        <note>
            Frames file for 'breed' based on survey of sentences in the WSJ
            corpus.
        </note>

        <roleset id="breed.01" name="to cause to reproduce" vncls="-">
            <roles>
                <role descr="causer, agent" n="0"/>
                <role descr="entity bred" n="1"/>
            </roles>

            <example name="transitive">
                <inflection aspect="ns" form="full" person="ns" tense="past" voice="active"/>
                <text>
                    Charles O. Givens of Mount Vernon , Ind. - investment broker , ex-accountant , and son of a former stable owner - bred Tennessee Walking Horses for six years , raised cattle for four , and never made a profit on either .
                </text>
                <arg n="0">Charles O. Givens of Mount Vernon , Ind. - investment broker , ex-accountant , and son of a former stable owner -</arg>
                <rel>bred</rel>
                <arg n="1">Tennessee Walking Horses</arg>
                <arg f="TMP" n="M">for six years</arg>
            </example>

        </roleset>
    </predicate>

    <note>
        frames created by Olga
    </note>

</frameset>


text:
<?php

namespace SAT\TranslationBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class SatTranslationBundle extends Bundle
{

    public function boot() {
        parent::boot();

        /* @var $kernel \AppKernel */
        $kernel = $this->container->get('kernel');

        if( $kernel->getEnvironment() == 'dev' ){
            $this->clearTranslationCache();
        }
    }

    protected function clearTranslationCache(){
        /* @var $eventDispatcher \Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher */
        $eventDispatcher = $this->container->get('event_dispatcher');
        $eventDispatcher->dispatch( SatTranslationEvents::CLEAR_CACHE, null );
    }
}


text:
(function () {
    'use strict';
	var useCDN = false;
	require.config({

		paths: {
//      	jquery			: ['//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min','libs/jquery/jquery.min'],
//      	jquery.smooth   : ['//cdnjs.cloudflare.com/ajax/libs/jquery-smooth-scroll/1.4.10/jquery.smooth-scroll.min','libs/jquery.smooth-scroll/jquery.smooth-scroll.min'],
			jquery			: useCDN?'//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min':'libs/jquery/jquery.min',
			b				: useCDN?'//netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2' : 'libs/bootstrap',
			f				: useCDN?'//netdna.bootstrapcdn.com/font-awesome/3.2.1':'libs/font-awesome',
			k				: useCDN?'//cdn.kendostatic.com/2013.1.514':'libs/kendo',
			'jquery.smooth' : useCDN?'//cdnjs.cloudflare.com/ajax/libs/jquery-smooth-scroll/1.4.10/jquery.smooth-scroll.min':'libs/jquery.smooth-scroll/jquery.smooth-scroll.min',
			holder			: 'libs/holder/holder',
			/** RequireJS Plugins **/
			domReady		: 'libs/require/domReady',
			css				: 'libs/require/css',
			normalize		: 'libs/require/normalize',
			i18n			: 'labs/require/i18n',
			text			: 'labs/require/text',
			json			: 'labs/require/json'
		},

		shim: {
			'jquery.smooth': ['jquery']
		},

		packages: [
			{
				name: 'bootstrap',
				location: 'libs/bootstrap'
			},
			{
				name: 'font-awesome',
				location: 'libs/font-awesome'
			},
			{
				name: 'kendo',
				location: 'libs/kendo'
			},
			{
				name: 'console',
				location: 'libs/console'
			},
			{
				name: 'led',
				location: 'libs/led'
			},
			'dashboard',
            'utils'
		]

	});
})();


text:
@implementation AESCrypt

+ (NSData *)encryptData:(NSData *)data usingKey:(NSData *)key error:(NSError * _Nullable __autoreleasing *)error
{
    NSMutableData *dataOut = [NSMutableData dataWithLength: data.length + kCCBlockSizeAES128];

    CCCryptorStatus status = CCCrypt(kCCEncrypt,
                                     kCCAlgorithmAES,
                                     kCCOptionECBMode,
                                     key.bytes,
                                     key.length,
                                     NULL,
                                     data.bytes,
                                     data.length,
                                     dataOut.mutableBytes,
                                     dataOut.length,
                                     NULL);

    return status == kCCSuccess ? dataOut : nil;
}

@end


text:
namespace System
{
    using System.Collections;
    using System.Collections.Generic;
    using System.Globalization;

    [Serializable]
    public abstract class StringComparer : IComparer, IEqualityComparer, IComparer<string>, IEqualityComparer<string>
    {
////    private static StringComparer _invariantCulture           = new CultureAwareComparer( CultureInfo.InvariantCulture, false );
////    private static StringComparer _invariantCultureIgnoreCase = new CultureAwareComparer( CultureInfo.InvariantCulture, true );
        private static StringComparer _ordinal                    = new OrdinalComparer();
////    private static StringComparer _ordinalIgnoreCase          = new OrdinalComparerIgnoreCase();

////    public static StringComparer InvariantCulture
////    {
////        get
////        {
////            return _invariantCulture;
////        }
////    }
////
////    public static StringComparer InvariantCultureIgnoreCase
////    {
////        get
////        {
////            return _invariantCultureIgnoreCase;
////        }
////    }
////
////    public static StringComparer CurrentCulture
////    {
////        get
////        {
////            return new CultureAwareComparer( CultureInfo.CurrentCulture, false );
////        }
////    }
////
////    public static StringComparer CurrentCultureIgnoreCase
////    {
////        get
////        {
////            return new CultureAwareComparer( CultureInfo.CurrentCulture, true );
////        }
////    }

        public static StringComparer Ordinal
        {
            get
            {
                return _ordinal;
            }
        }

////    public static StringComparer OrdinalIgnoreCase
////    {
////        get
////        {
////            return _ordinalIgnoreCase;
////        }
////    }
////
////    public static StringComparer Create( CultureInfo culture, bool ignoreCase )
////    {
////        if(culture == null)
////        {
////            throw new ArgumentNullException( "culture" );
////        }
////
////        return new CultureAwareComparer( culture, ignoreCase );
////    }

        public int Compare( object x, object y )
        {
            if(x == y) return 0;
            if(x == null) return -1;
            if(y == null) return 1;

            String sa = x as String;
            if(sa != null)
            {
                String sb = y as String;
                if(sb != null)
                {
                    return Compare( sa, sb );
                }
            }

            IComparable ia = x as IComparable;
            if(ia != null)
            {
                return ia.CompareTo( y );
            }

#if EXCEPTION_STRINGS
            throw new ArgumentException( Environment.GetResourceString( "Argument_ImplementIComparable" ) );
#else
            throw new ArgumentException();
#endif
        }

        public new bool Equals( Object x, Object y )
        {
            if(x == y) return true;
            if(x == null || y == null) return false;

            String sa = x as String;
            if(sa != null)
            {
                String sb = y as String;
                if(sb != null)
                {
                    return Equals( sa, sb );
                }
            }
            return x.Equals( y );
        }

        public int GetHashCode( object obj )
        {
            if(obj == null)
            {
#if EXCEPTION_STRINGS
                throw new ArgumentNullException( "obj" );
#else
                throw new ArgumentNullException();
#endif
            }

            string s = obj as string;
            if(s != null)
            {
                return GetHashCode( s );
            }
            return obj.GetHashCode();
        }

        public abstract int Compare( String x, String y );
        public abstract bool Equals( String x, String y );
        public abstract int GetHashCode( string obj );
    }

////[Serializable()]
////internal sealed class CultureAwareComparer : StringComparer
////{
////    private CompareInfo _compareInfo;
////    private bool _ignoreCase;
////
////    internal CultureAwareComparer( CultureInfo culture, bool ignoreCase )
////    {
////        _compareInfo = culture.CompareInfo;
////        _ignoreCase = ignoreCase;
////    }
////
////    public override int Compare( string x, string y )
////    {
////        if(Object.ReferenceEquals( x, y )) return 0;
////        if(x == null) return -1;
////        if(y == null) return 1;
////        return _compareInfo.Compare( x, y, _ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None );
////    }
////
////    public override bool Equals( string x, string y )
////    {
////        if(Object.ReferenceEquals( x, y )) return true;
////        if(x == null || y == null) return false;
////
////        return (_compareInfo.Compare( x, y, _ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None ) == 0);
////    }
////
////    public override int GetHashCode( string obj )
////    {
////        if(obj == null)
////        {
////            throw new ArgumentNullException( "obj" );
////        }
////
////        if(_ignoreCase)
////        {
////            return _compareInfo.GetHashCodeOfString( obj, CompareOptions.IgnoreCase );
////        }
////
////        return _compareInfo.GetHashCodeOfString( obj, CompareOptions.None );
////    }
////
////    // Equals method for the comparer itself.
////    public override bool Equals( Object obj )
////    {
////        CultureAwareComparer comparer = obj as CultureAwareComparer;
////        if(comparer == null)
////        {
////            return false;
////        }
////        return (this._ignoreCase == comparer._ignoreCase) && (this._compareInfo.Equals( comparer._compareInfo ));
////    }
////
////    public override int GetHashCode()
////    {
////        int hashCode = _compareInfo.GetHashCode();
////        return _ignoreCase ? (~hashCode) : hashCode;
////    }
////}

    // Provide x more optimal implementation of ordinal comparison.
    [Serializable()]
    internal sealed class OrdinalComparer : StringComparer
    {
        internal OrdinalComparer()
        {
        }

        public override int Compare( string x ,
                                     string y )
        {
            if(Object.ReferenceEquals( x, y )) return 0;

            if(x == null) return -1;
            if(y == null) return  1;

            return String.CompareOrdinal( x, y );
        }

        public override bool Equals( string x ,
                                     string y )
        {
            if(Object.ReferenceEquals( x, y )) return true;

            if(x == null || y == null) return false;

            return x.Equals( y );
        }

        public override int GetHashCode( string obj )
        {
            if(obj == null)
            {
#if EXCEPTION_STRINGS
                throw new ArgumentNullException( "obj" );
#else
                throw new ArgumentNullException();
#endif
            }

            return obj.GetHashCode();
        }

        // Equals method for the comparer itself.
        public override bool Equals( Object obj )
        {
            OrdinalComparer comparer = obj as OrdinalComparer;
            if(comparer == null)
            {
                return false;
            }

            return true;
        }

        public override int GetHashCode()
        {
            return "OrdinalComparer".GetHashCode();
        }
    }

////// Provide x more optimal implementation of ordinal comparison.
////[Serializable]
////internal sealed class OrdinalComparerIgnoreCase : StringComparer
////{
////    internal OrdinalComparerIgnoreCase()
////    {
////    }
////
////    public override int Compare( string x, string y )
////    {
////        if(Object.ReferenceEquals( x, y )) return 0;
////        if(x == null) return -1;
////        if(y == null) return 1;
////
////        return TextInfo.CompareOrdinalIgnoreCase( x, y );
////    }
////
////    public override bool Equals( string x, string y )
////    {
////        if(Object.ReferenceEquals( x, y )) return true;
////
////        if(x == null || y == null) return false;
////
////        if(x.Length != y.Length)
////        {
////            return false;
////        }
////
////        return (TextInfo.CompareOrdinalIgnoreCase( x, y ) == 0);
////    }
////
////    public override int GetHashCode( string obj )
////    {
////        if(obj == null)
////        {
////            throw new ArgumentNullException( "obj" );
////        }
////
////        return TextInfo.GetHashCodeOrdinalIgnoreCase( obj );
////    }
////
////    // Equals method for the comparer itself.
////    public override bool Equals( Object obj )
////    {
////        OrdinalComparerIgnoreCase comparer = obj as OrdinalComparerIgnoreCase;
////        if(comparer == null)
////        {
////            return false;
////        }
////
////        return true;
////    }
////
////    public override int GetHashCode()
////    {
////        return "OrdinalComparerIgnoreCase".GetHashCode();
////    }
////}
}


text:
module.exports = function() {
  Creep.prototype.is_range_attacker = function() {
      return this.memory.role == 'range_attacker';
  };

  Creep.prototype.execute_range_attack = function() {
    let creeps = this.room.hostile_creeps();
    let creep = Engine.closest_to_position(this.pos, creeps);
    if (creep) {
      if (this.rangedAttack(creep) == ERR_NOT_IN_RANGE) {
        this.moveTo(creep);
      }
      return;
    }
  };

  Creep.role_executors['range_attacker'] = function() {
    if (this.sleep()) return;

    if (this.hits < this.hits && this.body_parts_heal() > 0) {
      this.heal(this);
    }

    let stage_flag = _.first(_.filter(Game.flags, (flag) => flag.color == COLOR_WHITE));
    let attack_flag = _.first(_.filter(Game.flags, (flag) => flag.color == COLOR_RED));

    if (stage_flag) {
      if (this.follow_path() || this.move_to_room(stage_flag.pos.roomName)) {
        return;
      }
      if (this.follow_path_to_target(stage_flag, attack_flag ? 10 : 4)) {
        return;
      }
      this.execute_range_attack();
      return;
    }

    if (attack_flag) {
      if (this.follow_path() || this.move_to_room(attack_flag.pos.roomName)) {
        return;
      }

      this.execute_range_attack();
      return;
    }

    let flag = Game.flags[this.memory.target_flag_name];
    if (flag) {
      if (this.follow_path() || this.follow_path_to_target(flag, 0)) {
        return;
      }

      this.sleep(15);
      return;
    }
	};

};


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

	$(document).ready(function() {

		var enable_testimonial_slider = function( content ){
			var elements = content.find('.testimonials_carousel');
			if(elements && (typeof($.fn.carouFredSel) != 'undefined')){
			    $.each(elements, function(i, e){
			        var self = $(e),
			           speed = self.data('speed');
			        self.carouFredSel({
		                responsive: true,
		                items: {
		                	width: 360,
			            	visible: {
			            		min: 1,
			            		max: 1
			            	}
			            },
		                auto: {timeoutDuration: speed},
		                prev	: {
		                    button	: function(){return self.closest('.testimonials-carousel').find('.prev');},
		                    key		: "left"
		                },
		                next	: {
		                    button	: function(){return self.closest('.testimonials-carousel').find('.next');},
		                    key		: "right"
		                },
		                swipe: {
							onTouch: true,
							onMouse: true,
							options: {
								excludedElements: "button, input, select, textarea, .noSwipe",
							}

						}
			        });
			    });
			}
		};
		var testimonial_carousel = $('.testimonials-carousel');
		if(testimonial_carousel){
			enable_testimonial_slider( testimonial_carousel );
		}

	});// end of document ready

})(jQuery);


text:
package com.thaiopensource.xml.dtd.parse;

/**
 * Thrown for a syntax error in parsing the prolog.
 * @see PrologParser
 */
public class PrologSyntaxException extends Exception { }


text:
.class Landroid/text/HtmlToSpannedConverter$Bold;
.super Ljava/lang/Object;
.source "Html.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/text/HtmlToSpannedConverter;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0xa
    name = "Bold"
.end annotation

# direct methods
.method private constructor <init>()V
    .locals 0

    .prologue
    .line 810
    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    return-void
.end method

.method synthetic constructor <init>(Landroid/text/HtmlToSpannedConverter$1;)V
    .locals 0
    .parameter "x0"

    .prologue
    .line 810
    invoke-direct {p0}, Landroid/text/HtmlToSpannedConverter$Bold;-><init>()V

    return-void
.end method


text:
<!DOCTYPE html>
<meta charset="UTF-8">
<title>Ruby should not support transform</title>
<link rel="author" title="L. David Baron" href="https://dbaron.org/">
<link rel="author" title="Mozilla" href="https://www.mozilla.org">
<link rel="help" href="https://drafts.csswg.org/css-transforms-1/#transform-property">
<link rel="match" href="ruby-no-transform-ref.html">
<link rel="stylesheet" href="support/ruby-common.css">
<style>
ruby, rbc, rb, rtc, rt {
  transform: translateX(50px);
}
</style>
<ruby>
  <rbc><rb>a</rb><rb>b</rb></rbc>
  <rtc><rt>A</rt><rt>B</rt></rtc>
</ruby>


text:
const argv     = require('yargs') .alias('s', 'self') .argv;
const cached   = require('gulp-cached');
const debug    = require('gulp-debug');
const gulp     = require('gulp');
const jsonlint = require('gulp-json-lint');

gulp.task('lint:json', function() {

  if (argv.self) {
    src = ['package.json', 'src/config.json'];
   } else {
    src = 'src/config.json';
   }

   gulp.src(src)
  .pipe(cached('lint:json'))
  .pipe(debug())
  .pipe(jsonlint())
  .pipe(jsonlint.report('verbose'));
});