text:
#ifndef _UAPI_MSM_AUDIO_WMAPRO_H
#define _UAPI_MSM_AUDIO_WMAPRO_H

#define AUDIO_GET_WMAPRO_CONFIG  _IOR(AUDIO_IOCTL_MAGIC, \
	  (AUDIO_MAX_COMMON_IOCTL_NUM+0), unsigned)
#define AUDIO_SET_WMAPRO_CONFIG  _IOW(AUDIO_IOCTL_MAGIC, \
	  (AUDIO_MAX_COMMON_IOCTL_NUM+1), unsigned)

struct msm_audio_wmapro_config {
	unsigned short 	armdatareqthr;
	uint8_t         validbitspersample;
	uint8_t         numchannels;
	unsigned short  formattag;
	unsigned short  samplingrate;
	unsigned short  avgbytespersecond;
	unsigned short  asfpacketlength;
	unsigned short 	channelmask;
	unsigned short 	encodeopt;
	unsigned short	advancedencodeopt;
	uint32_t	advancedencodeopt2;
};
#endif /* _UAPI_MSM_AUDIO_WMAPRO_H */


text:
import * as React from 'react';
import { render } from '@testing-library/react';

import { createMockProvidedAxis } from '../../test-utils';
import AxisTitle from '../../../src/components/Axis/AxisTitle';
import * as useAxis from '../../../src/components/UseAxis';

describe('<Axis.Title />', () => {
  let testContext;
  let useAxisSpy;

  beforeEach(() => {
    testContext = {};

    const { axisStubs, providedAxis } = createMockProvidedAxis({
      id: 'myAxis',
      type: 'yAxis'
    });
    testContext.axisStubs = axisStubs;
    useAxisSpy = jest
      .spyOn(useAxis, 'default')
      .mockImplementation(() => providedAxis);
  });

  afterEach(() => {
    useAxisSpy.mockRestore();
  });

  describe('when mounted', () => {
    it('sets the correct axis title', () => {
      render(<AxisTitle>My Axis Title</AxisTitle>);
      expect(testContext.axisStubs.setTitle).toHaveBeenCalledWith(
        {
          text: 'My Axis Title'
        },
        expect.any(Boolean)
      );
    });

    it('should pass additional props too', () => {
      render(<AxisTitle align="high">My Axis Title</AxisTitle>);
      expect(testContext.axisStubs.setTitle).toHaveBeenCalledWith(
        {
          text: 'My Axis Title',
          align: 'high'
        },
        expect.any(Boolean)
      );
    });
  });

  describe('update', () => {
    it('should setTitle the correct axis title if the component props change', () => {
      const wrapper = render(<AxisTitle>My Axis Title</AxisTitle>);
      testContext.axisStubs.setTitle.mockClear();

      wrapper.rerender(
        <AxisTitle axisId="myAxis" dimension="x">
          New Title
        </AxisTitle>
      );

      expect(testContext.axisStubs.setTitle).toHaveBeenCalledWith(
        {
          text: 'New Title',
          dimension: 'x'
        },
        expect.any(Boolean)
      );
    });
  });

  describe('when unmounted', () => {
    it('removes the correct axis title (if the axis still exists)', () => {
      const wrapper = render(<AxisTitle>My Axis Title</AxisTitle>);
      wrapper.unmount();
      expect(testContext.axisStubs.setTitle).toHaveBeenCalledWith(
        {
          text: null
        },
        expect.any(Boolean)
      );
    });
  });
});

redpajama_set_name: RedPajamaGithub


text:
var path = require('path');
var fs = require('fs');
var assign = require('object-assign');
var liveServer = require("./index");

var opts = {
	port: process.env.PORT,
	open: true,
	mount: [],
	logLevel: 2
};

var homeDir = process.env[(process.platform == 'win32') ? 'USERPROFILE' : 'HOME'];
var configPath = path.join(homeDir, '.live-server.json');
if (fs.existsSync(configPath)) {
	var userConfig = fs.readFileSync(configPath, 'utf8');
	assign(opts, JSON.parse(userConfig));
}

for (var i = process.argv.length - 1; i >= 2; --i) {
	var arg = process.argv[i];
	if (arg.indexOf("--port=") > -1) {
		var portString = arg.substring(7);
		var portNumber = parseInt(portString, 10);
		if (portNumber == portString) {
			opts.port = portNumber;
			process.argv.splice(i, 1);
		}
	}
	else if (arg.indexOf("--host=") > -1) {
		opts.host = arg.substring(7);
		process.argv.splice(i, 1);
	}
	else if (arg.indexOf("--open=") > -1) {
		var open = arg.substring(7);
		if (open.indexOf('/') !== 0) {
			open = '/' + open;
		}
		opts.open = open;
		process.argv.splice(i, 1);
	}
	else if (arg.indexOf("--ignore=") > -1) {
		// Will be modified later when cwd is known
		opts.ignore = arg.substring(9).split(",");
		process.argv.splice(i, 1);
	}
	else if (arg == "--no-browser") {
		opts.open = false;
		process.argv.splice(i, 1);
	}
	else if (arg.indexOf("--browser=") > -1) {
		opts.browser = arg.substring(10).split(",");
		process.argv.splice(i, 1);
	}
	else if (arg.indexOf("--entry-file=") > -1) {
		var file = arg.substring(13);
		if (file.length) {
			opts.file = file;
			process.argv.splice(i, 1);
		}
	}
	else if (arg == "--quiet" || arg == "-q") {
		opts.logLevel = 0;
		process.argv.splice(i, 1);
	}
	else if (arg.indexOf("--mount=") > -1) {
		// e.g. "--mount=/components:./node_modules" will be ['/components', '<process.cwd()>/node_modules']
		var mountRule = arg.substring(8).split(":");
		mountRule[1] = path.resolve(process.cwd(), mountRule[1]);
		opts.mount.push(mountRule);
		process.argv.splice(i, 1);
	}
	else if (arg.indexOf("--wait=") > -1) {
		var waitString = arg.substring(7);
		var waitNumber = parseInt(waitString, 10);
		if (waitNumber == waitString) {
			opts.wait = waitNumber;
			process.argv.splice(i, 1);
		}
	}
	else if (arg == "--version" || arg == "-v") {
		var packageJson = require('./package.json');
		console.log(packageJson.name, packageJson.version);
		process.exit();
	}
	else if (arg == "--help" || arg == "-h") {
		console.log('Usage: live-server [-v|--version] [-h|--help] [-q|--quiet] [--port=PORT] [--host=HOST] [--open=PATH] [--no-browser] [--browser=BROWSER] [--ignore=PATH] [--entry-file=PATH] [--mount=ROUTE:PATH] [--wait=MILLISECONDS] [PATH]');
		process.exit();
	}
	else if (arg == "--test") {
		// Hidden param for tests to exit automatically
		setTimeout(liveServer.shutdown, 500);
		process.argv.splice(i, 1);
	}
}

if (process.argv[2]) {
	process.chdir(process.argv[2]);
}

if (opts.ignore) { // Patch ignore paths
	var cwd = process.cwd();
	opts.ignore = opts.ignore.map(function(relativePath) {
		return path.join(cwd, relativePath);
	});
}

liveServer.start(opts);


text:
package net.sf.jasperreports.engine;

import net.sf.jasperreports.engine.fill.DatasetFillContext;

/**
 * A dataset row filter.
 *
 *

 * Such a filter can be used in addition to the dataset filter expression to
 * match dataset rows based on a programmatic criteria.
 *

 *
 * @author Lucian Chirita (lucianc@users.sourceforge.net)
 * @version $Id: DatasetFilter.java 7199 2014-08-27 13:58:10Z teodord $
 * @see JRParameter#FILTER
 * @see JRDataset#getFilterExpression()
 */
public interface DatasetFilter
{

	/**
	 * Initializes the filter.
	 *
	 * @param context dataset context information
	 */
	void init(DatasetFillContext context);

	/**
	 * Determines whether the current row matches the filter criteria.
	 *
	 * Matching rows are included in the report, while non-matching rows are skipped.
	 *
	 * @param evaluation the evaluation type.
	 * Currently only {@link EvaluationType#ESTIMATED} is used.
	 * @return true if the row is to be included in the report.
	 */
	boolean matches(EvaluationType evaluation);

}


text:
import django

if django.VERSION < (3, 2):
    default_app_config = "admin_interface.apps.AdminInterfaceConfig"


text:
package org.lilyproject.repository.api;

/**
 * Creates records which can be written to a {@link Repository}. Created records have no persistence until they have
 * been written to a {@code Repository}.
 */
public interface RecordFactory {

    /**
     * Instantiates a new Record object.
     *
     *

     * This is only a factory method, nothing is created in the repository.
     */
    Record newRecord();

    /**
     * Instantiates a new Record object with the RecordId already filled in.
     *
     *

     * This is only a factory method, nothing is created in the repository.
     */
    Record newRecord(RecordId recordId);

}


text:
package com.purity.site.core.model;

import java.util.Date;

public class SitemapUrl {
	private String loc;
	private Date lastmod;
	private String changefreq;
	private Double priority;

	public String getLoc() {
		return loc;
	}
	public void setLoc(String loc) {
		this.loc = loc;
	}
	public Date getLastmod() {
		return lastmod;
	}
	public void setLastmod(Date lastmod) {
		this.lastmod = lastmod;
	}
	public String getChangefreq() {
		return changefreq;
	}
	public void setChangefreq(String changefreq) {
		this.changefreq = changefreq;
	}
	public Double getPriority() {
		return priority;
	}
	public void setPriority(Double priority) {
		this.priority = priority;
	}
}


text:
package org.apache.logging.log4j.core.pattern;

import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.plugins.Plugin;

/**
 * Returns the event's line location information in a StringBuilder.
 */
@Plugin(name = "LineLocationPatternConverter", category = PatternConverter.CATEGORY)
@ConverterKeys({ "L", "line" })
public final class LineLocationPatternConverter extends LogEventPatternConverter {
    /**
     * Singleton.
     */
    private static final LineLocationPatternConverter INSTANCE =
        new LineLocationPatternConverter();

    /**
     * Private constructor.
     */
    private LineLocationPatternConverter() {
        super("Line", "line");
    }

    /**
     * Obtains an instance of pattern converter.
     *
     * @param options options, may be null.
     * @return instance of pattern converter.
     */
    public static LineLocationPatternConverter newInstance(
        final String[] options) {
        return INSTANCE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void format(final LogEvent event, final StringBuilder output) {
        final StackTraceElement element = event.getSource();

        if (element != null) {
            output.append(element.getLineNumber());
        }
    }
}


text:
cask 'virtualbox-extension-pack' do
  version '6.1.8'
  sha256 'e609c012305e4ff3c520f36b46d19dab50ecac65228a983fe85c918a1534e490'

  url "https://download.virtualbox.org/virtualbox/#{version}/Oracle_VM_VirtualBox_Extension_Pack-#{version}.vbox-extpack"
  appcast 'https://download.virtualbox.org/virtualbox/LATEST.TXT'
  name 'Oracle VirtualBox Extension Pack'
  homepage 'https://www.virtualbox.org/'

  conflicts_with cask: 'virtualbox-extension-pack-beta'
  depends_on cask: 'virtualbox'
  container type: :naked

  stage_only true

  postflight do
    system_command '/usr/local/bin/VBoxManage',
                   args:  [
                            'extpack', 'install',
                            '--replace', "#{staged_path}/Oracle_VM_VirtualBox_Extension_Pack-#{version}.vbox-extpack"
                          ],
                   input: 'y',
                   sudo:  true
  end

  uninstall_postflight do
    next unless File.exist?('/usr/local/bin/VBoxManage')

    system_command '/usr/local/bin/VBoxManage',
                   args: [
                           'extpack', 'uninstall',
                           'Oracle VM VirtualBox Extension Pack'
                         ],
                   sudo: true
  end

  caveats do
    license 'https://www.virtualbox.org/wiki/VirtualBox_PUEL'
  end
end


text:
namespace blink {

class FrameHost;
class FrameOwner;
class RemoteFrame;

// FIXME: This is just a placeholder frame owner to supply to RemoteFrame when
// the parent is also a remote frame. Strictly speaking, this shouldn't be
// necessary, since a remote frame shouldn't ever need to communicate with a
// remote parent (there are no sandbox flags to retrieve in this case, nor can
// the RemoteFrame itself load a document). In most circumstances, the check for
// frame->owner() can be replaced with a check for frame->tree().parent(). Once
// that's done, this class can be removed.
class PlaceholderFrameOwner : public NoBaseWillBeGarbageCollectedFinalized<PlaceholderFrameOwner>, public FrameOwner {
    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(PlaceholderFrameOwner);
public:
    virtual bool isLocal() const override;
    virtual SandboxFlags sandboxFlags() const override;
    virtual void dispatchLoad() override;

    virtual void trace(Visitor*) override;
};

class WebRemoteFrameImpl final : public RefCountedWillBeGarbageCollectedFinalized<WebRemoteFrameImpl>, public WebRemoteFrame {
public:
    explicit WebRemoteFrameImpl(WebRemoteFrameClient*);
    virtual ~WebRemoteFrameImpl();

    // WebRemoteFrame methods.
    virtual bool isWebLocalFrame() const override;
    virtual WebLocalFrame* toWebLocalFrame() override;
    virtual bool isWebRemoteFrame() const override;
    virtual WebRemoteFrame* toWebRemoteFrame() override;
    virtual void close() override;
    virtual WebString uniqueName() const override;
    virtual WebString assignedName() const override;
    virtual void setName(const WebString&) override;
    virtual WebVector<WebIconURL> iconURLs(int iconTypesMask) const override;
    virtual void setRemoteWebLayer(WebLayer*) override;
    virtual void setPermissionClient(WebPermissionClient*) override;
    virtual void setSharedWorkerRepositoryClient(WebSharedWorkerRepositoryClient*) override;
    virtual void setCanHaveScrollbars(bool) override;
    virtual WebSize scrollOffset() const override;
    virtual void setScrollOffset(const WebSize&) override;
    virtual WebSize minimumScrollOffset() const override;
    virtual WebSize maximumScrollOffset() const override;
    virtual WebSize contentsSize() const override;
    virtual bool hasVisibleContent() const override;
    virtual WebRect visibleContentRect() const override;
    virtual bool hasHorizontalScrollbar() const override;
    virtual bool hasVerticalScrollbar() const override;
    virtual WebView* view() const override;
    virtual void removeChild(WebFrame*) override;
    virtual WebDocument document() const override;
    virtual WebPerformance performance() const override;
    virtual bool dispatchBeforeUnloadEvent() override;
    virtual void dispatchUnloadEvent() override;
    virtual NPObject* windowObject() const override;
    virtual void bindToWindowObject(const WebString& name, NPObject*) override;
    virtual void bindToWindowObject(const WebString& name, NPObject*, void*) override;
    virtual void executeScript(const WebScriptSource&) override;
    virtual void executeScriptInIsolatedWorld(
        int worldID, const WebScriptSource* sources, unsigned numSources,
        int extensionGroup) override;
    virtual void setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin&) override;
    virtual void setIsolatedWorldContentSecurityPolicy(int worldID, const WebString&) override;
    virtual void addMessageToConsole(const WebConsoleMessage&) override;
    virtual void collectGarbage() override;
    virtual bool checkIfRunInsecureContent(const WebURL&) const override;
    virtual v8::Handle<v8::Value> executeScriptAndReturnValue(
        const WebScriptSource&) override;
    virtual void executeScriptInIsolatedWorld(
        int worldID, const WebScriptSource* sourcesIn, unsigned numSources,
        int extensionGroup, WebVector<v8::Local<v8::Value>>* results) override;
    virtual v8::Handle<v8::Value> callFunctionEvenIfScriptDisabled(
        v8::Handle<v8::Function>,
        v8::Handle<v8::Value>,
        int argc,
        v8::Handle<v8::Value> argv[]) override;
    virtual v8::Local<v8::Context> mainWorldScriptContext() const override;
    virtual void reload(bool ignoreCache) override;
    virtual void reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache) override;
    virtual void loadRequest(const WebURLRequest&) override;
    virtual void loadHistoryItem(const WebHistoryItem&, WebHistoryLoadType, WebURLRequest::CachePolicy) override;
    virtual void loadData(
        const WebData&, const WebString& mimeType, const WebString& textEncoding,
        const WebURL& baseURL, const WebURL& unreachableURL, bool replace) override;
    virtual void loadHTMLString(
        const WebData& html, const WebURL& baseURL, const WebURL& unreachableURL,
        bool replace) override;
    virtual void stopLoading() override;
    virtual WebDataSource* provisionalDataSource() const override;
    virtual WebDataSource* dataSource() const override;
    virtual void enableViewSourceMode(bool enable) override;
    virtual bool isViewSourceModeEnabled() const override;
    virtual void setReferrerForRequest(WebURLRequest&, const WebURL& referrer) override;
    virtual void dispatchWillSendRequest(WebURLRequest&) override;
    virtual WebURLLoader* createAssociatedURLLoader(const WebURLLoaderOptions&) override;
    virtual unsigned unloadListenerCount() const override;
    virtual void replaceSelection(const WebString&) override;
    virtual void insertText(const WebString&) override;
    virtual void setMarkedText(const WebString&, unsigned location, unsigned length) override;
    virtual void unmarkText() override;
    virtual bool hasMarkedText() const override;
    virtual WebRange markedRange() const override;
    virtual bool firstRectForCharacterRange(unsigned location, unsigned length, WebRect&) const override;
    virtual size_t characterIndexForPoint(const WebPoint&) const override;
    virtual bool executeCommand(const WebString&, const WebNode& = WebNode()) override;
    virtual bool executeCommand(const WebString&, const WebString& value, const WebNode& = WebNode()) override;
    virtual bool isCommandEnabled(const WebString&) const override;
    virtual void enableContinuousSpellChecking(bool) override;
    virtual bool isContinuousSpellCheckingEnabled() const override;
    virtual void requestTextChecking(const WebElement&) override;
    virtual void replaceMisspelledRange(const WebString&) override;
    virtual void removeSpellingMarkers() override;
    virtual bool hasSelection() const override;
    virtual WebRange selectionRange() const override;
    virtual WebString selectionAsText() const override;
    virtual WebString selectionAsMarkup() const override;
    virtual bool selectWordAroundCaret() override;
    virtual void selectRange(const WebPoint& base, const WebPoint& extent) override;
    virtual void selectRange(const WebRange&) override;
    virtual void moveRangeSelection(const WebPoint& base, const WebPoint& extent) override;
    virtual void moveCaretSelection(const WebPoint&) override;
    virtual bool setEditableSelectionOffsets(int start, int end) override;
    virtual bool setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines) override;
    virtual void extendSelectionAndDelete(int before, int after) override;
    virtual void setCaretVisible(bool) override;
    virtual int printBegin(const WebPrintParams&, const WebNode& constrainToNode) override;
    virtual float printPage(int pageToPrint, WebCanvas*) override;
    virtual float getPrintPageShrink(int page) override;
    virtual void printEnd() override;
    virtual bool isPrintScalingDisabledForPlugin(const WebNode&) override;
    virtual bool hasCustomPageSizeStyle(int pageIndex) override;
    virtual bool isPageBoxVisible(int pageIndex) override;
    virtual void pageSizeAndMarginsInPixels(
        int pageIndex,
        WebSize& pageSize,
        int& marginTop,
        int& marginRight,
        int& marginBottom,
        int& marginLeft) override;
    virtual WebString pageProperty(const WebString& propertyName, int pageIndex) override;
    virtual void printPagesWithBoundaries(WebCanvas*, const WebSize&) override;
    virtual bool find(
        int identifier, const WebString& searchText, const WebFindOptions&,
        bool wrapWithinFrame, WebRect* selectionRect) override;
    virtual void stopFinding(bool clearSelection) override;
    virtual void scopeStringMatches(
        int identifier, const WebString& searchText, const WebFindOptions&,
        bool reset) override;
    virtual void cancelPendingScopingEffort() override;
    virtual void increaseMatchCount(int count, int identifier) override;
    virtual void resetMatchCount() override;
    virtual int findMatchMarkersVersion() const override;
    virtual WebFloatRect activeFindMatchRect() override;
    virtual void findMatchRects(WebVector<WebFloatRect>&) override;
    virtual int selectNearestFindMatch(const WebFloatPoint&, WebRect* selectionRect) override;
    virtual void setTickmarks(const WebVector<WebRect>&) override;
    virtual void dispatchMessageEventWithOriginCheck(
        const WebSecurityOrigin& intendedTargetOrigin,
        const WebDOMEvent&) override;

    virtual WebString contentAsText(size_t maxChars) const override;
    virtual WebString contentAsMarkup() const override;
    virtual WebString renderTreeAsText(RenderAsTextControls toShow = RenderAsTextNormal) const override;
    virtual WebString markerTextForListItem(const WebElement&) const override;
    virtual WebRect selectionBoundsRect() const override;

    virtual bool selectionStartHasSpellingMarkerFor(int from, int length) const override;
    virtual WebString layerTreeAsText(bool showDebugInfo = false) const override;

    virtual WebLocalFrame* createLocalChild(const WebString& name, WebFrameClient*) override;
    virtual WebRemoteFrame* createRemoteChild(const WebString& name, WebRemoteFrameClient*) override;

    void initializeCoreFrame(FrameHost*, FrameOwner*, const AtomicString& name);

    void setCoreFrame(PassRefPtrWillBeRawPtr<RemoteFrame>);
    RemoteFrame* frame() const { return m_frame.get(); }

    WebRemoteFrameClient* client() const { return m_client; }

    static WebRemoteFrameImpl* fromFrame(RemoteFrame&);

    virtual void initializeFromFrame(WebLocalFrame*) const override;

    virtual void setReplicatedOrigin(const WebSecurityOrigin&) const override;
    void didStartLoading() override;
    void didStopLoading() override;

#if ENABLE(OILPAN)
    void trace(Visitor*);
#endif

private:
    RemoteFrameClientImpl m_frameClient;
    RefPtrWillBeMember<RemoteFrame> m_frame;
    WebRemoteFrameClient* m_client;

    WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner>> m_ownersForChildren;

#if ENABLE(OILPAN)
    // Oilpan: to provide the guarantee of having the frame live until
    // close() is called, an instance keep a self-persistent. It is
    // cleared upon calling close(). This avoids having to assume that
    // an embedder's WebFrame references are all discovered via thread
    // state (stack, registers) should an Oilpan GC strike while we're
    // in the process of detaching.
    GC_PLUGIN_IGNORE("340522")
    Persistent<WebRemoteFrameImpl> m_selfKeepAlive;
#endif
};

DEFINE_TYPE_CASTS(WebRemoteFrameImpl, WebFrame, frame, frame->isWebRemoteFrame(), frame.isWebRemoteFrame());

} // namespace blink

#endif // WebRemoteFrameImpl_h


text:
<!-- This file is machine generated: DO NOT EDIT! -->

# Histograms
[TOC]

Histograms. Please see @{$python/histogram_ops} guide.

- - -

### `tf.histogram_fixed_width(values, value_range, nbins=100, dtype=tf.int32, name=None)` {#histogram_fixed_width}

Return histogram of values.

Given the tensor `values`, this operation returns a rank 1 histogram counting
the number of entries in `values` that fell into every bin.  The bins are
equal width and determined by the arguments `value_range` and `nbins`.

##### Args:

*  <b>`values`</b>: Numeric `Tensor`.
*  <b>`value_range`</b>: Shape [2] `Tensor`.  new_values <= value_range[0] will be
    mapped to hist[0], values >= value_range[1] will be mapped to hist[-1].
    Must be same dtype as new_values.
*  <b>`nbins`</b>: Scalar `int32 Tensor`.  Number of histogram bins.
*  <b>`dtype`</b>: dtype for returned histogram.
*  <b>`name`</b>: A name for this operation (defaults to 'histogram_fixed_width').

##### Returns:

  A 1-D `Tensor` holding histogram of values.

*  <b>`Examples`</b>:

```python
# Bins will be:  (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
nbins = 5
value_range = [0.0, 5.0]
new_values = [-1.0, 0.0, 1.5, 2.0, 5.0, 15]

with tf.default_session() as sess:
  hist = tf.histogram_fixed_width(new_values, value_range, nbins=5)
  variables.global_variables_initializer().run()
  sess.run(hist) => [2, 1, 1, 0, 2]
```


text:
package shade.memcached

import java.io._
import scala.reflect.ClassTag
import scala.util.control.NonFatal
import java.io.Serializable

/**
 * Represents a type class that needs to be implemented
 * for serialization/deserialization to work.
 */
trait Codec[T] {
  def serialize(value: T): Array[Byte]
  def deserialize(data: Array[Byte]): T
}

object Codec extends BaseCodecs

trait BaseCodecs {
  implicit object IntBinaryCodec extends Codec[Int] {
    def serialize(value: Int): Array[Byte] =
      Array(
        (value >>> 24).asInstanceOf[Byte],
        (value >>> 16).asInstanceOf[Byte],
        (value >>> 8).asInstanceOf[Byte],
        value.asInstanceOf[Byte]
      )

    def deserialize(data: Array[Byte]): Int =
      (data(0).asInstanceOf[Int] & 255) << 24 |
        (data(1).asInstanceOf[Int] & 255) << 16 |
        (data(2).asInstanceOf[Int] & 255) << 8 |
        data(3).asInstanceOf[Int] & 255
  }

  implicit object LongBinaryCodec extends Codec[Long] {
    def serialize(value: Long): Array[Byte] =
      Array(
        (value >>> 56).asInstanceOf[Byte],
        (value >>> 48).asInstanceOf[Byte],
        (value >>> 40).asInstanceOf[Byte],
        (value >>> 32).asInstanceOf[Byte],
        (value >>> 24).asInstanceOf[Byte],
        (value >>> 16).asInstanceOf[Byte],
        (value >>> 8).asInstanceOf[Byte],
        value.asInstanceOf[Byte]
      )

    def deserialize(data: Array[Byte]): Long =
      (data(0).asInstanceOf[Long] & 255) << 56 |
        (data(1).asInstanceOf[Long] & 255) << 48 |
        (data(2).asInstanceOf[Long] & 255) << 40 |
        (data(3).asInstanceOf[Long] & 255) << 32 |
        (data(4).asInstanceOf[Long] & 255) << 24 |
        (data(5).asInstanceOf[Long] & 255) << 16 |
        (data(6).asInstanceOf[Long] & 255) << 8 |
        data(7).asInstanceOf[Long] & 255
  }

  implicit object BooleanBinaryCodec extends Codec[Boolean] {
    def serialize(value: Boolean): Array[Byte] =
      Array((if (value) 1 else 0).asInstanceOf[Byte])

    def deserialize(data: Array[Byte]): Boolean =
      data.isDefinedAt(0) && data(0) == 1
  }

  implicit object CharBinaryCodec extends Codec[Char] {
    def serialize(value: Char): Array[Byte] = Array(
      (value >>> 8).asInstanceOf[Byte],
      value.asInstanceOf[Byte]
    )

    def deserialize(data: Array[Byte]): Char =
      ((data(0).asInstanceOf[Int] & 255) << 8 |
        data(1).asInstanceOf[Int] & 255)
        .asInstanceOf[Char]
  }

  implicit object ShortBinaryCodec extends Codec[Short] {
    def serialize(value: Short): Array[Byte] = Array(
      (value >>> 8).asInstanceOf[Byte],
      value.asInstanceOf[Byte]
    )

    def deserialize(data: Array[Byte]): Short =
      ((data(0).asInstanceOf[Short] & 255) << 8 |
        data(1).asInstanceOf[Short] & 255)
        .asInstanceOf[Short]
  }

  implicit object StringBinaryCodec extends Codec[String] {
    def serialize(value: String): Array[Byte] = value.getBytes("UTF-8")
    def deserialize(data: Array[Byte]): String = new String(data, "UTF-8")
  }
}

trait MemcachedCodecs extends BaseCodecs {
  private[this] class GenericCodec[S <: Serializable](classTag: ClassTag[S]) extends Codec[S] {
    def classLoader = classTag.runtimeClass.getClassLoader

    def using[T <: Closeable, R](obj: T)(f: T => R): R =
      try
        f(obj)
      finally
        try obj.close() catch {
          case NonFatal(_) => // does nothing
        }

    def serialize(value: S): Array[Byte] =
      using (new ByteArrayOutputStream()) { buf =>
        using (new ObjectOutputStream(buf)) { out =>
          out.writeObject(value)
          out.close()
          buf.toByteArray
        }
      }

    def deserialize(data: Array[Byte]): S =
      using (new ByteArrayInputStream(data)) { buf =>
        val in = new ObjectInputStream(buf) {
          override def resolveClass(desc: ObjectStreamClass): Class[_] = {
            try
              classLoader.loadClass(desc.getName)
            catch {
              case ex: Exception =>
                // try fallback to super implementation
                super.resolveClass(desc)
            }
          }
        }

        using (in) { inp =>
          inp.readObject().asInstanceOf[S]
        }
      }
  }

  implicit def AnyRefBinaryCodec[S <: Serializable](implicit ev: ClassTag[S]): Codec[S] =
    new GenericCodec[S](ev)
}

object MemcachedCodecs extends MemcachedCodecs


text:
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/2.1.0...3.0.0)

**Closed issues:**

- Lock WP CLI version at ~1.1.0 for now [\#15](https://github.com/TypistTech/travis-nginx-wordpress/issues/15)

**Merged pull requests:**

- Remove `saucelabs` support [\#21](https://github.com/TypistTech/travis-nginx-wordpress/pull/21) ([TangRufus](https://github.com/TangRufus))
- Update TravisCI config [\#20](https://github.com/TypistTech/travis-nginx-wordpress/pull/20) ([TangRufus](https://github.com/TangRufus))
- Misc: Typist Tech code style [\#19](https://github.com/TypistTech/travis-nginx-wordpress/pull/19) ([TangRufus](https://github.com/TangRufus))

## [2.1.0](https://github.com/TypistTech/travis-nginx-wordpress/tree/2.1.0) (2017-08-06)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/2.0.2...2.1.0)

**Merged pull requests:**

- composer update [\#18](https://github.com/TypistTech/travis-nginx-wordpress/pull/18) ([TangRufus](https://github.com/TangRufus))

## [2.0.2](https://github.com/TypistTech/travis-nginx-wordpress/tree/2.0.2) (2017-06-01)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/2.0.1...2.0.2)

**Merged pull requests:**

- Lock WP CLI version at ~1.1.0 [\#16](https://github.com/TypistTech/travis-nginx-wordpress/pull/16) ([TangRufus](https://github.com/TangRufus))

## [2.0.1](https://github.com/TypistTech/travis-nginx-wordpress/tree/2.0.1) (2017-03-26)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/2.0.0...2.0.1)

**Merged pull requests:**

- Version bump 2.0.1 [\#14](https://github.com/TypistTech/travis-nginx-wordpress/pull/14) ([TangRufus](https://github.com/TangRufus))
- Test on Travis trusty [\#13](https://github.com/TypistTech/travis-nginx-wordpress/pull/13) ([TangRufus](https://github.com/TangRufus))

## [2.0.0](https://github.com/TypistTech/travis-nginx-wordpress/tree/2.0.0) (2017-03-09)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/1.2.1...2.0.0)

**Merged pull requests:**

- Version bump 2.0.0 [\#12](https://github.com/TypistTech/travis-nginx-wordpress/pull/12) ([TangRufus](https://github.com/TangRufus))
- Remove wpcs [\#11](https://github.com/TypistTech/travis-nginx-wordpress/pull/11) ([TangRufus](https://github.com/TangRufus))

## [1.2.1](https://github.com/TypistTech/travis-nginx-wordpress/tree/1.2.1) (2017-02-23)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/1.2.0...1.2.1)

**Merged pull requests:**

- Fix tnw-upload-coverage-to-codecov: command not found [\#10](https://github.com/TypistTech/travis-nginx-wordpress/pull/10) ([TangRufus](https://github.com/TangRufus))

## [1.2.0](https://github.com/TypistTech/travis-nginx-wordpress/tree/1.2.0) (2017-02-23)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/1.1.1...1.2.0)

**Merged pull requests:**

- Version bump 1.2.0 [\#9](https://github.com/TypistTech/travis-nginx-wordpress/pull/9) ([TangRufus](https://github.com/TangRufus))
- Add tnw-upload-coverage-to-codecov [\#8](https://github.com/TypistTech/travis-nginx-wordpress/pull/8) ([TangRufus](https://github.com/TangRufus))

## [1.1.1](https://github.com/TypistTech/travis-nginx-wordpress/tree/1.1.1) (2017-02-19)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/1.1.0...1.1.1)

**Merged pull requests:**

- Fix: Replace phantomjs path correctly [\#7](https://github.com/TypistTech/travis-nginx-wordpress/pull/7) ([TangRufus](https://github.com/TangRufus))

## [1.1.0](https://github.com/TypistTech/travis-nginx-wordpress/tree/1.1.0) (2017-02-18)
[Full Changelog](https://github.com/TypistTech/travis-nginx-wordpress/compare/1.0.0...1.1.0)

**Implemented enhancements:**

- Replace phantomjs path in codeception.yml and codeception.dist.yml [\#5](https://github.com/TypistTech/travis-nginx-wordpress/pull/5) ([TangRufus](https://github.com/TangRufus))

**Merged pull requests:**

- Version bump 1.1.0 [\#6](https://github.com/TypistTech/travis-nginx-wordpress/pull/6) ([TangRufus](https://github.com/TangRufus))
- Update installation guide in readme [\#4](https://github.com/TypistTech/travis-nginx-wordpress/pull/4) ([TangRufus](https://github.com/TangRufus))
- Add document to README.md [\#2](https://github.com/TypistTech/travis-nginx-wordpress/pull/2) ([TangRufus](https://github.com/TangRufus))

## [1.0.0](https://github.com/TypistTech/travis-nginx-wordpress/tree/1.0.0) (2017-02-17)
**Merged pull requests:**

- Version one release [\#1](https://github.com/TypistTech/travis-nginx-wordpress/pull/1) ([TangRufus](https://github.com/TangRufus))

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


text:
<!DOCTYPE html>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="msapplication-tap-highlight" content="no">
    <meta name="description" content="Drag and Drop script for complex nested html structures">
    <title>Lean & Mean Drag and Drop - LMDD</title>
    <meta property="og:title" content="Lean & Mean Drag and Drop"/>
    <meta property="og:description" content="Drag and Drop script for complex nested html structures"/>
    <meta property="og:url" content="https://supraniti.github.io/Lean-Mean-Drag-and-Drop/"/>
    <meta property="og:image"
          content="https://supraniti.github.io/Lean-Mean-Drag-and-Drop/gh-pages/images/logo.png"/>

    <link rel="apple-touch-icon" sizes="57x57" href="gh-pages/images/apple-icon-57x57.png">
    <link rel="apple-touch-icon" sizes="60x60" href="gh-pages/images/apple-icon-60x60.png">
    <link rel="apple-touch-icon" sizes="72x72" href="gh-pages/images/apple-icon-72x72.png">
    <link rel="apple-touch-icon" sizes="76x76" href="gh-pages/images/apple-icon-76x76.png">
    <link rel="apple-touch-icon" sizes="114x114" href="gh-pages/images/apple-icon-114x114.png">
    <link rel="apple-touch-icon" sizes="120x120" href="gh-pages/images/apple-icon-120x120.png">
    <link rel="apple-touch-icon" sizes="144x144" href="gh-pages/images/apple-icon-144x144.png">
    <link rel="apple-touch-icon" sizes="152x152" href="gh-pages/images/apple-icon-152x152.png">
    <link rel="apple-touch-icon" sizes="180x180" href="gh-pages/images/apple-icon-180x180.png">
    <link rel="icon" type="image/png" sizes="192x192" href="gh-pages/images/android-icon-192x192.png">
    <link rel="icon" type="image/png" sizes="32x32" href="gh-pages/images/favicon-32x32.png">
    <link rel="icon" type="image/png" sizes="96x96" href="gh-pages/images/favicon-96x96.png">
    <link rel="icon" type="image/png" sizes="16x16" href="gh-pages/images/favicon-16x16.png">
    <link rel="manifest" href="gh-pages/images/manifest.json">
    <meta name="msapplication-TileColor" content="#ef5423">
    <meta name="msapplication-TileImage" content="images/ms-icon-144x144.png">

    <meta name="theme-color" content="#ef5423">

    <link href="gh-pages/style.css" type="text/css" rel="stylesheet">
    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.10.0/styles/default.min.css">
    <link href="dist/lmdd.min.css" rel="stylesheet">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.8/css/materialize.min.css" type="text/css"
          rel="stylesheet" media="screen,projection">
    <link href="https://fonts.googleapis.com/css?family=Inconsolata" rel="stylesheet" type="text/css">
    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
    <meta name="google-site-verification" content="t8GPQFbC5CeqIvVrxan6kUHE4gRmM4ua22RxjyHxQwY"/>

LMDD

About

Usage

Examples

Options

Advanced

Integration

announcementAbout

lightbulb_outlineUsage

Examples

Options

Advanced

Integration

            menu

Lean & Mean Drag and Drop is a small script for dragging, dropping, sorting and reordering html structures

Features

Supports nested structures ('nestable sortables')

Smooth transitions

Auto scroll while dragging

Lightweight (~3.5kb gzipped)

No dependencies

Super easy to integrate with your own app

Supports touch events

Compatible with all modern browsers

Can work with any type of layout

Usage

//Load LMDD css and js files
<link href="../css/lmdd.min.css" rel="stylesheet">
<script src="../js/lmdd.min.js"></script>

//Initialize LMDD instance with your preferred options
<script>lmdd.set(document.getElementById('markupID'),{optionsObject});</script>

Examples

speaker_notes

                            The basic script is essentially the same for all cases. Set LMDD on an element (containing
                            all that has to be dragged or nested in), and declare the relevant classes
                            (containerClass,draggableItemClass & handleClass). The rest is done through proper HTML
                            markup.

filter_1Simple Grid

Green

Pink

Purple

Blue

Lime

Teal

Amber

Orange

Black

filter_2Multiple containers + handle

Tasks

                                        reorder

Code refactoring & optimizations

                                        reorder

Cross browser testing

Important Tasks

                                        reorder

Call mom

Done

                                        reorder

Basic Drag & Drop script

                                        reorder

Smooth transitions

                                        reorder

Support nested structures

                                        reorder

Scroll while dragging

filter_3Nested Grid

Red

Red

Red

Green

Green

Green

Blue

Blue

Blue

code

   Simple
    <div id="basic-example"> (scope)
        <div class="grid"> (container)
            <div class="item"></div> (draggable)
        </div>
    </div>
    <script>
        lmdd.set(document.getElementById('basic-example'), {
            containerClass: 'grid',
            draggableItemClass: 'item'
    });
    </script>

    Multiple Containers and handle
    <div id="handle-example"> (scope)
        <div class="grid"> (container)
            <div class="item"> (draggable)
                <div class="handle"></div> (handle)
            </div>
        </div>
        <div class="grid"> (another container)
        </div>
    </div>
    <script>
        lmdd.set(document.getElementById('handle-example'), {
            containerClass: 'grid',
            draggableItemClass: 'item',
            handleClass:'handle'
        });
    </script>

    Nested
    <div id="nested-example"> (scope)
        <div class="grid"> (container)
            <div class="grid item"> (container AND draggable)
                <div class="item"></div> (draggable)
                <div class="item"></div> (draggable)
                <div class="item"></div> (draggable)
            </div>
            <div class="grid item"> (container AND draggable)
                <div class="item"></div> (draggable)
                <div class="item"></div> (draggable)
                <div class="item"></div> (draggable)
            </div>
        </div>
    </div>
    <script>
        lmdd.set(document.getElementById('nested-example'), {
            containerClass: 'grid',
            draggableItemClass: 'item'
        });
    </script>

Options

speaker_notes

                                    Option
                                    Description

                                    containerClass
                                    Containers act as drop zones for draggable items

                                    draggableItemClass
                                    Draggable items can be moved inside and between containers

                                    handleClass
                                    Restricts drag start to a specific element which acts as a drag "handle"

                                    dragstartTimeout
                                    Delays the drag start for a short time to distinct it from other user intentions
                                        (such as selecting text)

                                    calcInterval
                                    Time interval in which LMDD evaluates the dragged element position, Short
                                        interval means more responsive experience (and more CPU usage)

                                    revert
                                    When set to true the draggable item will revert to its original position when
                                        the cursor is out of the container bounds

                                    nativeScroll
                                    LMDD uses its own auto-scroll function, you can eliminate it and use the native
                                        browser scroll

                                    mirrorMinHeight,
                                        mirrorMaxWidth

                                    Scale down the mirror size when it exceeds the maximum width set

                                    positionDelay
                                    When set to true - position will not be recalculated when the mouse stops moving
                                        (Prevents flickering on deep nested structures)

                                    dataMode
                                    When set to 'true' LMDD will undo all DOM mutations when the drag event ends,
                                        This is useful for integrating LMDD with Angular/React/Vue etc.

code

 //LMDD Options default values:
    lmdd.set(document.getElementById('someID'), {
        containerClass:'lmdd-container',
        draggableItemClass: 'lmdd-draggable',
        handleClass: false,
        dragstartTimeout: 50,
        calcInterval: 200,
        revert: true,
        nativeScroll: false,
        mirrorMinHeight: 100,
        mirrorMaxWidth: 500,
        positionDelay: false,
        dataMode: false
    });

Advanced

content_copyCloning

                            To clone dragged elements, just add two additional classes to your markup:

                            'lmdd-clonner' - for every element you want to clone when dragged

                            'lmdd-dispatcher' - for the container (parent of the elements to be cloned)

                            containers having the 'lmdd-dispatcher' class will not act as drop zones, the cloning
                            operation will begin when the mouse cursor enters a different container.

   //Example markup:
    <div id="clone-example"> (scope)
        <div class="grid lmdd-dispatcher"> (dragging items out from this container will clone them)
            <div class="item lmdd-clonner">(this draggable item will be cloned when dragged)
            </div>
        </div>
        <div class="grid"> (container)
        </div>
    </div>

eventEvents

LMDD dispatches three events:

'lmddbeforestart': Dispatched before any changes has been made to the
                                DOM. Does not contain a detail object

'lmddstart': Dispatched when the drag operation starts. Contains a
                                'detail' object

'lmddend':Dispatched when the drag operation ends. Contains a
                                'detail' object

The detail object carries the following information:

dragType: "move" or "clone"

draggedElement: HTML element being dragged

from.container: HTML element that originally contained the dragged
                                element

from.index: The original index of the dragged element

to.container: HTML element that currently contains the dragged
                                element

to.index: The current index of the dragged element

blockRendering Blocks

                            To animate transitions LMDD makes a copy of all movable elements on its scope and manage
                            their location with relative positioning,

                            this is an expensive process and might (in some cases) alter the way your markup renders
                            while dragging.

                            To prevent this from happening, AND save CPU on drag operations, add the class 'lmdd-block'
                            to the parts of your markup which are not needed to be animated.

                            This will stop LMDD from traversing down the DOM tree and keep all children of the element
                            intact.

   //Example markup:
    <div id="basic-example"> (scope)
        <div class="grid"> (container)
            <div class="item lmdd-block">(draggable)
                <--! A lot of additional markup -->
            </div>
        </div>
    </div>

Integration

bookmarkGuidelines

LMDD is fairly easy to integrate with any other script. I would recommend treating the drag
                            operation as any other user input, think of it as some kind of a sophisticated mouse
                            gesture. Having this point of view in mind, the integration process should be as
                            follows:

Upon rendering your markup, set an LMDD instance on the relevant part of the
                                DOM

Set the dataMode to 'true'. (Which will undo any changes LMDD made on the
                                DOM when the drag operation ends)

Add an eventListener for the 'lmddend' event

Use an event handler to process the event details and implement the
                                necessary changes on your app data/state

filter_1Vue Example

See the Pen vue.js drag and
                            drop with lmdd by Yair Levy (@supraniti) on CodePen.

                            Note that the relevant code for implementing the drag and drop operation is made out of two
                            simple functions,

setting up lmdd and adding an event listener (on Vue 'mounted'
                                    function).

moving the relevant data object from it's original parent into it's new
                                    parent (on our 'handleDragEvent' function)

                            Everything else is just proper markup for the "todo-item" and "todo-container" components.

code

  mounted: function() {
    //set lmdd
    lmdd.set(document.getElementById('drag-scope'), {
      containerClass: 'todo-container',
      draggableItemClass: 'todo-item',
      handleClass: 'handle',
      dataMode: true //set dataMode to true
    });
    //listen to 'lmddend' event
    this.$el.addEventListener('lmddend', this.handleDragEvent);
  }
  methods: {
      //handle 'lmddend' event
      handleDragEvent: function(event) {
          // Process the event detail
          var newIndex = event.detail.to.index;
          var oldIndex = event.detail.from.index;
          var newContainer = event.detail.to.container.__vue__.data;
          var oldContainer = event.detail.from.container.__vue__.data;
          if (event.detail.dragType === 'move') {
            //implement the changes on the app data
            newContainer.splice(newIndex, 0, oldContainer.splice(oldIndex, 1)[0]);
          }
      }
  }

Angular and React integration is pretty much the same, examples will be added to this section
                later on.

More

                Bug reports & feature requests are more than welcome.

                Feel free to ask questions and contribute on github

If you are interested in a drag&drop functionality for your web apps, you might also like:

jQuery UI - sortable

Dragula - "Drag and drop so simple it
                    hurts"

Sortable - no jQuery

nestedSortable jQuery Plugin

React DnD

angular-drag-and-drop-lists

Discussion

            2017 © Supraniti, All rights reserved.
            MIT License


text:
/**
 * Handles authorization of payments through PayPal.
 *
 * @author Anton Johansson
 */
var PayPalAuthorizeHandler = function()
{
};

/** Authorizes the payment. */
PayPalAuthorizeHandler.prototype.authorize = function(order)
{
	console.log("Successfully authorized %s %s for PayPal order %s", order.totalValue, order.currency, order.orderId);
};

// Expose the class
module.exports = PayPalAuthorizeHandler;


text:
cd /tmp
git clone https://github.com/indigo-dc/clues-indigo.git
cd clues-indigo/
nosetests tests/mesos_test.py


text:
package io.werval.api.http;

import java.util.EnumSet;

/**
 * HTTP Status Class.
 */
public enum StatusClass
{
    /**
     * 1xx Informational.
     */
    INFORMATIONAL( "Informational" ),
    /**
     * 2xx Success.
     */
    SUCCESS( "Successful" ),
    /**
     * 3xx Redirection.
     */
    REDIRECTION( "Redirection" ),
    /**
     * 4xx Client Error.
     */
    CLIENT_ERROR( "Client Error" ),
    /**
     * 5xx Server Error.
     */
    SERVER_ERROR( "Server Error" ),
    /**
     * {@literal 0xx} or {@literal >= 6xx} Unknown.
     */
    UNKNOWN( "Unknown Status" );

    private static final EnumSet<StatusClass> FORCE_CLOSE = EnumSet.of( CLIENT_ERROR, SERVER_ERROR, UNKNOWN );
    private static final int ONE_HUNDRED = 100;
    private static final int TWO_HUNDRED = 200;
    private static final int THREE_HUNDRED = 300;
    private static final int FOUR_HUNDRED = 400;
    private static final int FIVE_HUNDRED = 500;
    private static final int SIX_HUNDRED = 600;

    /**
     * @param status Status
     *
     * @return StatusClass for the given Status
     */
    public static StatusClass valueOf( Status status )
    {
        return valueOf( status.code() );
    }

    /**
     * @param status Status code
     *
     * @return StatusClass for the given status code
     */
    public static StatusClass valueOf( int status )
    {
        if( status < ONE_HUNDRED )
        {
            // 0xx
            return UNKNOWN;
        }
        if( status < TWO_HUNDRED )
        {
            // 1xx
            return INFORMATIONAL;
        }
        if( status < THREE_HUNDRED )
        {
            // 2xx
            return SUCCESS;
        }
        if( status < FOUR_HUNDRED )
        {
            // 3xx
            return REDIRECTION;
        }
        if( status < FIVE_HUNDRED )
        {
            // 4xx
            return CLIENT_ERROR;
        }
        if( status < SIX_HUNDRED )
        {
            // 5xx
            return SERVER_ERROR;
        }
        // >= 6xx
        return UNKNOWN;
    }

    private final String reasonPhrase;

    private StatusClass( String reasonPhrase )
    {
        this.reasonPhrase = reasonPhrase;
    }

    /**
     * @return Status class reason phrase
     */
    public String reasonPhrase()
    {
        return reasonPhrase;
    }

    /**
     * @return {@literal true} if this StatusClass force the connection close,
     *         otherwise return {@literal false}
     */
    public boolean isForceClose()
    {
        return FORCE_CLOSE.contains( this );
    }
}


text:
@implementation CYDataInputSource {
	NSData *data;
	xmlDocPtr document;
	NSArray<NSError *> *parseErrors;
}

- (instancetype)initWithOptions:(CYParsingOptions)options {
	self = [self initWithData:[NSData new] options:0];
	return self;
}

- (instancetype)initWithData:(NSData *)theData options:(CYParsingOptions)options {
	if ( (self = [super initWithOptions:options]) ) {
		data = theData;
	}
	return self;
}

- (instancetype)initWithData:(NSData *)theData basePath:(NSString *)theBasePath options:(CYParsingOptions)options {
	self = [self initWithData:theData options:options];
	self.basePath = theBasePath;
	return self;
}

- (void)dealloc {
	if ( document != NULL ) {
		xmlFreeDoc(document);
	}
}

- (nullable xmlDocPtr)getDocument:(NSError * _Nullable __autoreleasing *)error {
	if ( document != NULL ) {
		return document;
	}
	document = [self newDocumentFromData:data options:self.options error:error];
	if ( document ) {
		// free up data
		data = nil;
	}
	return document;
}

- (nullable xmlDocPtr)newDocument:(NSError **)error {
	if ( document ) {
		// already parsed, so just return a copy
		return xmlCopyDoc(document, 1);
	}
	return [self newDocumentFromData:data options:self.options error:error];
}

- (nullable xmlDocPtr)newDocumentFromData:(NSData *)xmlData options:(CYParsingOptions)parsingOptions error:(NSError **)error {
	xmlParserCtxtPtr ctxt;
	__block xmlDocPtr doc;
	const int xmlOptions = (int)parsingOptions;
	const BOOL asHTML = ((parsingOptions & CYParsingAsHTML) == CYParsingAsHTML);

	if ( asHTML ) {
		ctxt = htmlNewParserCtxt();
	} else {
		ctxt = xmlNewParserCtxt();
	}
	if ( ctxt == NULL ) {
		if ( error ) {
			*error = [NSError errorWithDomain:CYErrorDomain code:CYParsingErrorAllocationFailed userInfo:nil];
		}
		return NULL;
	}

	NSString *basePath = (self.basePath != nil ? self.basePath : @"data.xml");

	[CYUtilities handlePrasing:self inContext:ctxt block:^(CYParsingContext *context) {
		if ( asHTML ) {
			doc = htmlCtxtReadMemory(ctxt, [xmlData bytes], (int)[xmlData length], [basePath UTF8String], NULL, xmlOptions);
		} else {
			doc = xmlCtxtReadMemory(ctxt, [xmlData bytes], (int)[xmlData length], [basePath UTF8String], NULL, xmlOptions);
		}
	} finished:^(NSArray<NSError *> * _Nullable errors) {
		parseErrors = errors;
	}];

	xmlFreeParserCtxt(ctxt);

	if ( doc == NULL ) {
		if ( parseErrors.count > 0 ) {
			*error = [parseErrors firstObject];
		}
	}

	return doc;
}

@end


text:
<?xml version="1.0" encoding="UTF-8"?>
<Tokens version="1.0">
	<File path="Classes/AutoScalingDescribeScheduledActionsResponseUnmarshaller.html">

		<Token>
			<TokenIdentifier>//apple_ref/occ/cl/AutoScalingDescribeScheduledActionsResponseUnmarshaller</TokenIdentifier>
			<Abstract type="html">Describe Scheduled Actions Result Unmarshaller</Abstract>
			<DeclaredIn>AutoScalingDescribeScheduledActionsResponseUnmarshaller.h</DeclaredIn>

			<NodeRef refid="108"/>
		</Token>

	</File>
</Tokens>


text:
using System;
using System.Data;
using System.Diagnostics;
using Moq;
using NUnit.Framework;
using Shuhari.Framework.Data;

namespace Shuhari.Framework.UnitTests.Data.Common
{
    [TestFixture]
    public class BaseDbContextTest
    {
        [SetUp]
        public void SetUp()
        {
            _mockSessionFactory = new Mock<ISessionFactory>();
            _mockSession = new Mock<ISession>();
            _mockSessionFactory.Setup(m => m.OpenSession(It.IsAny<object>()))
                .Returns(_mockSession.Object);
            _mockTransaction = new Mock<IDbTransaction>();
            _mockSession.Setup(m => m.BeginTransaction()).Returns(_mockTransaction.Object);

            _dbCtx = new TestDbContext(_mockSessionFactory.Object);
            _dbCtx.OpenSession();
        }

        private TestDbContext _dbCtx;
        private Mock<ISessionFactory> _mockSessionFactory;
        private Mock<ISession> _mockSession;
        private Mock<IDbTransaction> _mockTransaction;

        [Test]
        public void GetRepositories()
        {
            CollectionAssert.Contains(_dbCtx.Repositories, _dbCtx.NotNullEntityRepository);
            CollectionAssert.Contains(_dbCtx.Repositories, _dbCtx.NullableEntityRepository);
        }

        [Test]
        public void OpenSession_CloseSession()
        {
            Assert.AreSame(_mockSession.Object, _dbCtx.NotNullEntityRepository.Session);
            Assert.AreSame(_mockSession.Object, _dbCtx.NullableEntityRepository.Session);

            _dbCtx.CloseSession();
            Assert.IsNull(_dbCtx.NotNullEntityRepository.Session);
            Assert.IsNull(_dbCtx.NullableEntityRepository.Session);
            _mockSession.Verify(m => m.Dispose());
        }

        [Test]
        public void ExecuteTransaction_Success_ShouldSubmit()
        {
            _dbCtx.ExecuteTransaction(() => Debug.WriteLine("ok"));

            _mockTransaction.Verify(m => m.Commit());
        }

        [Test]
        public void ExecuteTransaction_Throws_ShouldRollback()
        {
            try
            {
                _dbCtx.ExecuteTransaction(() => { throw new ArgumentException(); });
            }
            catch(ArgumentException)
            {
            }

            _mockTransaction.Verify(m => m.Rollback());
        }

        [Test]
        public void CreateSessionScope()
        {
            using (_dbCtx.CreateSessionScope())
            {
                _mockSessionFactory.Verify(m => m.OpenSession(It.IsAny<object>()));
            }

            _mockSession.Verify(m => m.Dispose());
        }
    }
}


text:
ltf
===

Language tests format


text:
<?php defined('SYSPATH') OR die('No direct access allowed.'); ?>

<?php echo Controller::_kohana_load_view(Kohana::find_file('views', 'pages/list_items', TRUE),
         array('items' => $items, 'pagination' => null,  'current_first_item' => 1)); ?>


text:
        <title>台大合唱團音樂會座位圖</title>
        <meta http-equiv="content-type" content="text/html" charset="utf-8" />

        <link href="css/menu.css" rel="stylesheet" type="text/css" />
        <link href="css/footer.css" rel="stylesheet" type="text/css" />
        <link href="css/typeset.css" rel="stylesheet" type="text/css" />
        <link href="css/seat.css" rel="stylesheet" type="text/css" />
        <link href="css/ticketoutline.css" rel="stylesheet" type="text/css" />

首頁

電子票圖

整票系統

劃票系統

售票登記

訂單編輯

售票地圖

統計報表

                正在讀取座位圖資訊......

                <select id='select_viewprogram' onchange="programChange(this)"></select>

售票率統計

Copyright &copy 2017 NTUChorus. All rights reserved.

Please contact r04922046_AT_ntu.edu.tw for further information.


text:
<?xml version="1.0" encoding="UTF-8"?>
<merge
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context=".ActivityHost">

    <TextView
        android:id="@+id/lblTitle"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:ellipsize="marquee"
        android:marqueeRepeatLimit="marquee_forever"
        android:nextFocusDown="@+id/btnPrev"
        android:nextFocusForward="@+id/btnPrev"
        android:nextFocusLeft="@+id/list"
        android:nextFocusRight="@+id/btnPrev"
        android:nextFocusUp="@+id/list"
        android:paddingBottom="4dp"
        android:paddingLeft="4dp"
        android:paddingRight="4dp"
        android:paddingTop="2dp"
        android:scrollHorizontally="true"
        android:singleLine="true"
        android:text="@string/nothing_playing"/>

    <TextView
        android:id="@+id/lblMsgSelMove"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ellipsize="marquee"
        android:marqueeRepeatLimit="marquee_forever"
        android:paddingBottom="4dp"
        android:paddingLeft="4dp"
        android:paddingRight="4dp"
        android:paddingTop="2dp"
        android:scrollHorizontally="true"
        android:singleLine="true"
        android:text="@string/msg_sel"
        android:visibility="gone"/>

</merge>


text:
package brut.androlib;

import brut.directory.ExtFile;
import brut.common.BrutException;
import brut.util.OS;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

import static org.junit.Assert.assertEquals;

/**
 * @author Connor Tumbleson <connor.tumbleson@gmail.com>
 */
public class MinifiedArscTest {

    @BeforeClass
    public static void beforeClass() throws Exception {
        TestUtils.cleanFrameworkFile();
        sTmpDir = new ExtFile(OS.createTempDirectory());
        TestUtils.copyResourceDir(MinifiedArscTest.class, "brut/apktool/issue1157/", sTmpDir);

        String apk = "issue1157.apk";
        sDecodedDir = new ExtFile(sTmpDir, "issue1157");

        // decode issue1157.apk
        ApkDecoder apkDecoder = new ApkDecoder(new ExtFile(sTmpDir, apk));
        apkDecoder.setForceDelete(true);
        apkDecoder.setOutDir(sDecodedDir);

        // this should not raise an exception:
        apkDecoder.decode();
    }

    @AfterClass
    public static void afterClass() throws BrutException {
        OS.rmdir(sTmpDir);
    }

    @Test
    public void checkIfMinifiedArscLayoutFileMatchesTest() throws IOException {
        String expected = TestUtils.replaceNewlines("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
                "<LinearLayout n1:orientation=\"vertical\" n1:layout_width=\"fill_parent\" n1:layout_height=\"fill_parent\"\n" +
                "  xmlns:n1=\"http://schemas.android.com/apk/res/android\">\n" +
                "    <com.ibotpeaches.issue1157.MyCustomView n1:max=\"100\" n2:default_value=\"1.0\" n2:max_value=\"5.0\" n2:min_value=\"0.2\" xmlns:n2=\"http://schemas.android.com/apk/res-auto\" />\n" +
                "</LinearLayout>");

        byte[] encoded = Files.readAllBytes(Paths.get(sDecodedDir + File.separator + "res" + File.separator + "xml" + File.separator + "custom.xml"));
        String obtained = TestUtils.replaceNewlines(new String(encoded));
        assertEquals(expected, obtained);
    }

    private static ExtFile sDecodedDir;
    private static ExtFile sTmpDir;
}


text:
require 'test_helper'

class TextTest < ActiveSupport::TestCase
end


text:
const getters = {
  sidebar: state => state.app.sidebar,
  size: state => state.app.size,
  device: state => state.app.device,
  visitedViews: state => state.tagsView.visitedViews,
  cachedViews: state => state.tagsView.cachedViews,
  token: state => state.user.token,
  avatar: state => state.user.avatar,
  name: state => state.user.name,
  introduction: state => state.user.introduction,
  roles: state => state.user.roles,
  permission_routes: state => state.permission.routes,
  errorLogs: state => state.errorLog.logs
}
export default getters


text:
CREATE TABLE [Icon] (
  [ID] AUTOINCREMENT CONSTRAINT [PrimaryKey] PRIMARY KEY  UNIQUE  NOT NULL ,
  [IconID] SHORT ,
  [IconX] LONGBINARY ,
  [Icon] LONGBINARY
)


text:
for https://github.com/mocobeta/wikification-webapp

## Create indexes example

```
  $ sbt "run-main md.lucene.TitleIndexApp /tmp/titleidx"

  $ sbt "run-main md.lucene.AnchorIndexApp /tmp/anchoridx /tmp/titleidx 4"

  $ sbt "run-main md.lucene.ContentIndexApp /tmp/contentidx /tmp/anchoridx 4"
```

## License

BSD 3-Clause License


text:
/*

    Name:       Base16 Railscasts Light
    Author:     Ryan Bates (http://railscasts.com)

    CodeMirror template adapted for IPython Notebook by Nikhil Sonnad (https://github.com/nsonnad/base16-ipython-notebook)
    CodeMirror template by Jan T. Sott (https://github.com/idleberg/base16-chrome-devtools)
    Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16)

*/

/* Uncomment to use a custom font
div#notebook, div.CodeMirror, div.output_area pre, div.output_wrapper, div.prompt {
  font-family: 'Custom Font Name', monospace !important;
}
*/

/* GLOBALS */
body {background-color: #f9f7f3;}
a {color: #6d9cbe;}

/* INTRO PAGE */
.toolbar_info, .list-container {color: #272935;}

/* NOTEBOOK */

/* comment out this line to bring the toolbar back */
/*div#maintoolbar, div#header {display: none !important;}*/

div#notebook {border-top: none;}

div.input_prompt {color: #b6b3eb;}
div.output_prompt {color: #bc9458;}
div.input_area {
  border-radius: 0px;
  border: 1px solid #e6e1dc;
}
div.output_area pre {font-weight: normal; color: #3a4055;}
div.output_subarea {font-weight: normal; color: #3a4055;}

.rendered_html table, .rendered_html th, .rendered_html tr, .rendered_html td {
  border: 1px  #5a647e solid;
  color: #5a647e;
}
div.output_html { font-family: sans-serif; }
table.dataframe tr {border: 1px #3a4055;}

div.cell.selected {border-radius: 0px;}
div.cell.edit_mode {border-radius: 0px; border: thin solid #bc9458;}
div.text_cell_render, div.output_html {color: #3a4055;}

span.ansiblack {color: #272935;}
span.ansiblue {color: #519f50;}
span.ansigray {color: #d4cfc9;}
span.ansigreen {color: #a5c261;}
span.ansipurple {color: #b6b3eb;}
span.ansired {color: #da4939;}
span.ansiyellow {color: #ffc66d;}

div.output_stderr {background-color: #da4939;}
div.output_stderr pre {color: #f4f1ed;}

.cm-s-ipython.CodeMirror {background: #f9f7f3; color: #272935;}
.cm-s-ipython div.CodeMirror-selected {background: #f4f1ed !important;}
.cm-s-ipython .CodeMirror-gutters {background: #f9f7f3; border-right: 0px;}
.cm-s-ipython .CodeMirror-linenumber {color: #d4cfc9;}
.cm-s-ipython .CodeMirror-cursor {border-left: 1px solid #5a647e !important;}

.cm-s-ipython span.cm-comment {color: #bc9458;}
.cm-s-ipython span.cm-atom {color: #b6b3eb;}
.cm-s-ipython span.cm-number {color: #b6b3eb;}

.cm-s-ipython span.cm-property, .cm-s-ipython span.cm-attribute {color: #a5c261;}
.cm-s-ipython span.cm-keyword {color: #da4939;}
.cm-s-ipython span.cm-string {color: #ffc66d;}
.cm-s-ipython span.cm-operator {color: #bc9458;}
.cm-s-ipython span.cm-builtin {color: #b6b3eb;}

.cm-s-ipython span.cm-variable {color: #a5c261;}
.cm-s-ipython span.cm-variable-2 {color: #6d9cbe;}
.cm-s-ipython span.cm-def {color: #cc7833;}
.cm-s-ipython span.cm-error {background: #da4939; color: #5a647e;}
.cm-s-ipython span.cm-bracket {color: #3a4055;}
.cm-s-ipython span.cm-tag {color: #da4939;}
.cm-s-ipython span.cm-link {color: #b6b3eb;}

.cm-s-ipython .CodeMirror-matchingbracket { text-decoration: underline; color: #272935 !important;}


text:
// +build go1.8

package mssql

import (
	"context"
	"database/sql"
	"database/sql/driver"
	"fmt"
	"net"
	"reflect"
	"strings"
	"sync"
	"testing"
	"time"
)

func TestNextResultSet(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	rows, err := conn.Query("select 1; select 2")
	if err != nil {
		t.Fatal("Query failed", err.Error())
	}
	defer func() {
		err := rows.Err()
		if err != nil {
			t.Error("unexpected error:", err)
		}
	}()

	defer rows.Close()

	if !rows.Next() {
		t.Fatal("Query didn't return row")
	}
	var fld1, fld2 int32
	err = rows.Scan(&fld1)
	if err != nil {
		t.Fatal("Scan failed", err)
	}
	if fld1 != 1 {
		t.Fatal("Returned value doesn't match")
	}
	if rows.Next() {
		t.Fatal("Query returned unexpected second row.")
	}
	// calling next again should still return false
	if rows.Next() {
		t.Fatal("Query returned unexpected second row.")
	}
	if !rows.NextResultSet() {
		t.Fatal("NextResultSet should return true but returned false")
	}
	if !rows.Next() {
		t.Fatal("Query didn't return row")
	}
	err = rows.Scan(&fld2)
	if err != nil {
		t.Fatal("Scan failed", err)
	}
	if fld2 != 2 {
		t.Fatal("Returned value doesn't match")
	}
	if rows.NextResultSet() {
		t.Fatal("NextResultSet should return false but returned true")
	}
}

func TestColumnTypeIntrospection(t *testing.T) {
	type tst struct {
		expr         string
		typeName     string
		reflType     reflect.Type
		hasSize      bool
		size         int64
		hasPrecScale bool
		precision    int64
		scale        int64
	}
	tests := []tst{
		{"cast(1 as bit)", "BIT", reflect.TypeOf(true), false, 0, false, 0, 0},
		{"cast(1 as tinyint)", "TINYINT", reflect.TypeOf(int64(0)), false, 0, false, 0, 0},
		{"cast(1 as smallint)", "SMALLINT", reflect.TypeOf(int64(0)), false, 0, false, 0, 0},
		{"1", "INT", reflect.TypeOf(int64(0)), false, 0, false, 0, 0},
		{"cast(1 as bigint)", "BIGINT", reflect.TypeOf(int64(0)), false, 0, false, 0, 0},
		{"cast(1 as real)", "REAL", reflect.TypeOf(0.0), false, 0, false, 0, 0},
		{"cast(1 as float)", "FLOAT", reflect.TypeOf(0.0), false, 0, false, 0, 0},
		{"cast('abc' as varbinary(3))", "VARBINARY", reflect.TypeOf([]byte{}), true, 3, false, 0, 0},
		{"cast('abc' as varbinary(max))", "VARBINARY", reflect.TypeOf([]byte{}), true, 2147483645, false, 0, 0},
		{"cast(1 as datetime)", "DATETIME", reflect.TypeOf(time.Time{}), false, 0, false, 0, 0},
		{"cast(1 as smalldatetime)", "SMALLDATETIME", reflect.TypeOf(time.Time{}), false, 0, false, 0, 0},
		{"cast(getdate() as datetime2(7))", "DATETIME2", reflect.TypeOf(time.Time{}), false, 0, false, 0, 0},
		{"cast(getdate() as datetimeoffset(7))", "DATETIMEOFFSET", reflect.TypeOf(time.Time{}), false, 0, false, 0, 0},
		{"cast(getdate() as date)", "DATE", reflect.TypeOf(time.Time{}), false, 0, false, 0, 0},
		{"cast(getdate() as time)", "TIME", reflect.TypeOf(time.Time{}), false, 0, false, 0, 0},
		{"'abc'", "VARCHAR", reflect.TypeOf(""), true, 3, false, 0, 0},
		{"cast('abc' as varchar(max))", "VARCHAR", reflect.TypeOf(""), true, 2147483645, false, 0, 0},
		{"N'abc'", "NVARCHAR", reflect.TypeOf(""), true, 3, false, 0, 0},
		{"cast(N'abc' as NVARCHAR(MAX))", "NVARCHAR", reflect.TypeOf(""), true, 1073741822, false, 0, 0},
		{"cast(1 as decimal)", "DECIMAL", reflect.TypeOf([]byte{}), false, 0, true, 18, 0},
		{"cast(1 as decimal(5, 2))", "DECIMAL", reflect.TypeOf([]byte{}), false, 0, true, 5, 2},
		{"cast(1 as numeric(10, 4))", "DECIMAL", reflect.TypeOf([]byte{}), false, 0, true, 10, 4},
		{"cast(1 as money)", "MONEY", reflect.TypeOf([]byte{}), false, 0, false, 0, 0},
		{"cast(1 as smallmoney)", "SMALLMONEY", reflect.TypeOf([]byte{}), false, 0, false, 0, 0},
		{"cast(0x6F9619FF8B86D011B42D00C04FC964FF as uniqueidentifier)", "UNIQUEIDENTIFIER", reflect.TypeOf([]byte{}), false, 0, false, 0, 0},
		{"cast('<root/>' as xml)", "XML", reflect.TypeOf(""), true, 1073741822, false, 0, 0},
		{"cast('abc' as text)", "TEXT", reflect.TypeOf(""), true, 2147483647, false, 0, 0},
		{"cast(N'abc' as ntext)", "NTEXT", reflect.TypeOf(""), true, 1073741823, false, 0, 0},
		{"cast('abc' as image)", "IMAGE", reflect.TypeOf([]byte{}), true, 2147483647, false, 0, 0},
		{"cast('abc' as char(3))", "CHAR", reflect.TypeOf(""), true, 3, false, 0, 0},
		{"cast(N'abc' as nchar(3))", "NCHAR", reflect.TypeOf(""), true, 3, false, 0, 0},
		{"cast(1 as sql_variant)", "SQL_VARIANT", reflect.TypeOf(nil), false, 0, false, 0, 0},
	}
	conn := open(t)
	defer conn.Close()
	for _, tt := range tests {
		rows, err := conn.Query("select " + tt.expr)
		if err != nil {
			t.Fatalf("Query failed with unexpected error %s", err)
		}
		ct, err := rows.ColumnTypes()
		if err != nil {
			t.Fatalf("Query failed with unexpected error %s", err)
		}
		if ct[0].DatabaseTypeName() != tt.typeName {
			t.Errorf("Expected type %s but returned %s", tt.typeName, ct[0].DatabaseTypeName())
		}
		size, ok := ct[0].Length()
		if ok != tt.hasSize {
			t.Errorf("Expected has size %v but returned %v for %s", tt.hasSize, ok, tt.expr)
		} else {
			if ok && size != tt.size {
				t.Errorf("Expected size %d but returned %d for %s", tt.size, size, tt.expr)
			}
		}

		prec, scale, ok := ct[0].DecimalSize()
		if ok != tt.hasPrecScale {
			t.Errorf("Expected has prec/scale %v but returned %v for %s", tt.hasPrecScale, ok, tt.expr)
		} else {
			if ok && prec != tt.precision {
				t.Errorf("Expected precision %d but returned %d for %s", tt.precision, prec, tt.expr)
			}
			if ok && scale != tt.scale {
				t.Errorf("Expected scale %d but returned %d for %s", tt.scale, scale, tt.expr)
			}
		}

		if ct[0].ScanType() != tt.reflType {
			t.Errorf("Expected ScanType %v but got %v for %s", tt.reflType, ct[0].ScanType(), tt.expr)
		}
	}
}

func TestColumnIntrospection(t *testing.T) {
	type tst struct {
		expr         string
		fieldName    string
		typeName     string
		nullable     bool
		hasSize      bool
		size         int64
		hasPrecScale bool
		precision    int64
		scale        int64
	}
	tests := []tst{
		{"f1 int null", "f1", "INT", true, false, 0, false, 0, 0},
		{"f2 varchar(15) not null", "f2", "VARCHAR", false, true, 15, false, 0, 0},
		{"f3 decimal(5, 2) null", "f3", "DECIMAL", true, false, 0, true, 5, 2},
	}
	conn := open(t)
	defer conn.Close()

	// making table variable with specified fields and making a select from it
	exprs := make([]string, len(tests))
	for i, test := range tests {
		exprs[i] = test.expr
	}
	exprJoined := strings.Join(exprs, ",")
	rows, err := conn.Query(fmt.Sprintf("declare @tbl table(%s); select * from @tbl", exprJoined))
	if err != nil {
		t.Fatalf("Query failed with unexpected error %s", err)
	}

	ct, err := rows.ColumnTypes()
	if err != nil {
		t.Fatalf("ColumnTypes failed with unexpected error %s", err)
	}
	for i, test := range tests {
		if ct[i].Name() != test.fieldName {
			t.Errorf("Field expected have name %s but it has name %s", test.fieldName, ct[i].Name())
		}

		if ct[i].DatabaseTypeName() != test.typeName {
			t.Errorf("Invalid type name returned %s expected %s", ct[i].DatabaseTypeName(), test.typeName)
		}

		nullable, ok := ct[i].Nullable()
		if ok {
			if nullable != test.nullable {
				t.Errorf("Invalid nullable value returned %v", nullable)
			}
		} else {
			t.Error("Nullable was expected to support Nullable but it didn't")
		}

		size, ok := ct[i].Length()
		if ok != test.hasSize {
			t.Errorf("Expected has size %v but returned %v for %s", test.hasSize, ok, test.expr)
		} else {
			if ok && size != test.size {
				t.Errorf("Expected size %d but returned %d for %s", test.size, size, test.expr)
			}
		}

		prec, scale, ok := ct[i].DecimalSize()
		if ok != test.hasPrecScale {
			t.Errorf("Expected has prec/scale %v but returned %v for %s", test.hasPrecScale, ok, test.expr)
		} else {
			if ok && prec != test.precision {
				t.Errorf("Expected precision %d but returned %d for %s", test.precision, prec, test.expr)
			}
			if ok && scale != test.scale {
				t.Errorf("Expected scale %d but returned %d for %s", test.scale, scale, test.expr)
			}
		}
	}
}

func TestContext(t *testing.T) {
	conn := open(t)
	defer conn.Close()

	opts := &sql.TxOptions{
		Isolation: sql.LevelSerializable,
	}
	ctx := context.Background()
	tx, err := conn.BeginTx(ctx, opts)
	if err != nil {
		t.Errorf("BeginTx failed with unexpected error %s", err)
		return
	}
	rows, err := tx.QueryContext(ctx, "DBCC USEROPTIONS")
	properties := make(map[string]string)
	for rows.Next() {
		var name, value string
		if err = rows.Scan(&name, &value); err != nil {
			t.Errorf("Scan failed with unexpected error %s", err)
		}
		properties[name] = value
	}

	if properties["isolation level"] != "serializable" {
		t.Errorf("Expected isolation level to be serializable but it is %s", properties["isolation level"])
	}

	row := tx.QueryRowContext(ctx, "select 1")
	var val int64
	if err = row.Scan(&val); err != nil {
		t.Errorf("QueryRowContext failed with unexpected error %s", err)
	}
	if val != 1 {
		t.Error("Incorrect value returned from query")
	}

	_, err = tx.ExecContext(ctx, "select 1")
	if err != nil {
		t.Errorf("ExecContext failed with unexpected error %s", err)
		return
	}

	_, err = tx.PrepareContext(ctx, "select 1")
	if err != nil {
		t.Errorf("PrepareContext failed with unexpected error %s", err)
		return
	}
}

func TestBeginTxtReadOnlyNotSupported(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	opts := &sql.TxOptions{ReadOnly: true}
	_, err := conn.BeginTx(context.Background(), opts)
	if err == nil {
		t.Error("BeginTx expected to fail for read only transaction because MSSQL doesn't support it, but it succeeded")
	}
}

func TestMssqlConn_BeginTx(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	_, err := conn.Exec("create table test (f int)")
	defer conn.Exec("drop table test")
	if err != nil {
		t.Fatal("create table failed with error", err)
	}

	tx1, err := conn.BeginTx(context.Background(), nil)
	if err != nil {
		t.Fatal("BeginTx failed with error", err)
	}
	tx2, err := conn.BeginTx(context.Background(), nil)
	if err != nil {
		t.Fatal("BeginTx failed with error", err)
	}
	_, err = tx1.Exec("insert into test (f) values (1)")
	if err != nil {
		t.Fatal("insert failed with error", err)
	}
	_, err = tx2.Exec("insert into test (f) values (2)")
	if err != nil {
		t.Fatal("insert failed with error", err)
	}
	tx1.Rollback()
	tx2.Commit()

	rows, err := conn.Query("select f from test")
	if err != nil {
		t.Fatal("select failed with error", err)
	}
	values := []int64{}
	for rows.Next() {
		var val int64
		err = rows.Scan(&val)
		if err != nil {
			t.Fatal("scan failed with error", err)
		}
		values = append(values, val)
	}
	if !reflect.DeepEqual(values, []int64{2}) {
		t.Errorf("Values is expected to be [1] but it is %v", values)
	}
}

func TestNamedParameters(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	row := conn.QueryRow(
		"select :param2, :param1, :param2",
		sql.Named("param1", 1),
		sql.Named("param2", 2))
	var col1, col2, col3 int64
	err := row.Scan(&col1, &col2, &col3)
	if err != nil {
		t.Errorf("Scan failed with unexpected error %s", err)
		return
	}
	if col1 != 2 || col2 != 1 || col3 != 2 {
		t.Errorf("Unexpected values returned col1=%d, col2=%d, col3=%d", col1, col2, col3)
	}
}

func TestBadNamedParameters(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	row := conn.QueryRow(
		"select :param2, :param1, :param2",
		sql.Named("badparam1", 1),
		sql.Named("param2", 2))
	var col1, col2, col3 int64
	err := row.Scan(&col1, &col2, &col3)
	if err == nil {
		t.Error("Scan succeeded unexpectedly")
		return
	}
	t.Logf("Scan failed as expected with error %s", err)
}

func TestMixedParameters(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	row := conn.QueryRow(
		"select :2, :param1, :param2",
		5, // this parameter will be unused
		6,
		sql.Named("param1", 1),
		sql.Named("param2", 2))
	var col1, col2, col3 int64
	err := row.Scan(&col1, &col2, &col3)
	if err != nil {
		t.Errorf("Scan failed with unexpected error %s", err)
		return
	}
	if col1 != 6 || col2 != 1 || col3 != 2 {
		t.Errorf("Unexpected values returned col1=%d, col2=%d, col3=%d", col1, col2, col3)
	}
}

/*
func TestMixedParametersExample(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	row := conn.QueryRow(
		"select :id, ?",
		sql.Named("id", 1),
		2,
		)
	var col1, col2 int64
	err := row.Scan(&col1, &col2)
	if err != nil {
		t.Errorf("Scan failed with unexpected error %s", err)
		return
	}
	if col1 != 1 || col2 != 2 {
		t.Errorf("Unexpected values returned col1=%d, col2=%d", col1, col2)
	}
}
*/

func TestPinger(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	err := conn.Ping()
	if err != nil {
		t.Errorf("Failed to hit database")
	}
}

func TestQueryCancelLowLevel(t *testing.T) {
	checkConnStr(t)
	drv := driverWithProcess(t)
	conn, err := drv.open(makeConnStr(t).String())
	if err != nil {
		t.Fatalf("Open failed with error %v", err)
	}

	defer conn.Close()
	ctx, cancel := context.WithCancel(context.Background())
	stmt, err := conn.prepareContext(ctx, "waitfor delay '00:00:03'")
	if err != nil {
		t.Fatalf("Prepare failed with error %v", err)
	}
	err = stmt.sendQuery([]namedValue{})
	if err != nil {
		t.Fatalf("sendQuery failed with error %v", err)
	}

	cancel()

	_, err = stmt.processExec(ctx)
	if err != context.Canceled {
		t.Errorf("Expected error to be Cancelled but got %v", err)
	}

	// same connection should be usable again after it was cancelled
	stmt, err = conn.prepareContext(context.Background(), "select 1")
	if err != nil {
		t.Fatalf("Prepare failed with error %v", err)
	}
	rows, err := stmt.Query([]driver.Value{})
	if err != nil {
		t.Fatalf("Query failed with error %v", err)
	}

	values := []driver.Value{nil}
	err = rows.Next(values)
	if err != nil {
		t.Fatalf("Next failed with error %v", err)
	}
}

func TestQueryCancelHighLevel(t *testing.T) {
	conn := open(t)
	defer conn.Close()

	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		time.Sleep(200 * time.Millisecond)
		cancel()
	}()
	_, err := conn.ExecContext(ctx, "waitfor delay '00:00:03'")
	if err != context.Canceled {
		t.Errorf("ExecContext expected to fail with Cancelled but it returned %v", err)
	}

	// connection should be usable after timeout
	row := conn.QueryRow("select 1")
	var val int64
	err = row.Scan(&val)
	if err != nil {
		t.Fatal("Scan failed with", err)
	}
}

func TestQueryTimeout(t *testing.T) {
	conn := open(t)
	defer conn.Close()
	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
	defer cancel()
	_, err := conn.ExecContext(ctx, "waitfor delay '00:00:03'")
	if err != context.DeadlineExceeded {
		t.Errorf("ExecContext expected to fail with DeadlineExceeded but it returned %v", err)
	}

	// connection should be usable after timeout
	row := conn.QueryRow("select 1")
	var val int64
	err = row.Scan(&val)
	if err != nil {
		t.Fatal("Scan failed with", err)
	}
}

func TestDriverParams(t *testing.T) {
	checkConnStr(t)
	SetLogger(testLogger{t})
	type sqlCmd struct {
		Name   string
		Driver string
		Query  string
		Param  []interface{}
		Expect []interface{}
	}

	list := []sqlCmd{
		{
			Name:   "preprocess-ordinal",
			Driver: "mssql",
			Query:  `select V1=:1`,
			Param:  []interface{}{"abc"},
			Expect: []interface{}{"abc"},
		},
		{
			Name:   "preprocess-name",
			Driver: "mssql",
			Query:  `select V1=:First`,
			Param:  []interface{}{sql.Named("First", "abc")},
			Expect: []interface{}{"abc"},
		},
		{
			Name:   "raw-ordinal",
			Driver: "sqlserver",
			Query:  `select V1=@p1`,
			Param:  []interface{}{"abc"},
			Expect: []interface{}{"abc"},
		},
		{
			Name:   "raw-name",
			Driver: "sqlserver",
			Query:  `select V1=@First`,
			Param:  []interface{}{sql.Named("First", "abc")},
			Expect: []interface{}{"abc"},
		},
	}

	for cmdIndex, cmd := range list {
		t.Run(cmd.Name, func(t *testing.T) {
			db, err := sql.Open(cmd.Driver, makeConnStr(t).String())
			if err != nil {
				t.Fatalf("failed to open driver %q", cmd.Driver)
			}
			defer db.Close()

			rows, err := db.Query(cmd.Query, cmd.Param...)
			if err != nil {
				t.Fatalf("failed to run query %q %v", cmd.Query, err)
			}
			defer rows.Close()

			columns, err := rows.Columns()
			if err != nil {
				t.Fatalf("failed to get column schema %v", err)
			}
			clen := len(columns)

			if clen != len(cmd.Expect) {
				t.Fatalf("query column has %d, expect %d columns", clen, len(cmd.Expect))
			}

			values := make([]interface{}, clen)
			into := make([]interface{}, clen)
			for i := 0; i < clen; i++ {
				into[i] = &values[i]
			}
			for rows.Next() {
				err = rows.Scan(into...)
				if err != nil {
					t.Fatalf("failed to scan into row for %d %q", cmdIndex, cmd.Driver)
				}
				for i := range cmd.Expect {
					if values[i] != cmd.Expect[i] {
						t.Fatalf("expected value in index %d %v != actual value %v", i, cmd.Expect[i], values[i])
					}
				}
			}
		})
	}
}

type connInterrupt struct {
	net.Conn

	mu           sync.Mutex
	disruptRead  bool
	disruptWrite bool
}

func (c *connInterrupt) Interrupt(write bool) {
	c.mu.Lock()
	if write {
		c.disruptWrite = true
	} else {
		c.disruptRead = true
	}
	c.mu.Unlock()
}

func (c *connInterrupt) Read(b []byte) (n int, err error) {
	c.mu.Lock()
	dis := c.disruptRead
	c.mu.Unlock()
	if dis {
		return 0, disconnectError{}
	}
	return c.Conn.Read(b)
}

func (c *connInterrupt) Write(b []byte) (n int, err error) {
	c.mu.Lock()
	dis := c.disruptWrite
	c.mu.Unlock()
	if dis {
		return 0, disconnectError{}
	}
	return c.Conn.Write(b)
}

type dialerInterrupt struct {
	nd tcpDialer

	mu   sync.Mutex
	list []*connInterrupt
}

func (d *dialerInterrupt) Dial(addr string) (net.Conn, error) {
	conn, err := d.nd.Dial(addr)
	if err != nil {
		return nil, err
	}
	ci := &connInterrupt{Conn: conn}
	d.mu.Lock()
	d.list = append(d.list, ci)
	d.mu.Unlock()
	return ci, err
}

func (d *dialerInterrupt) Interrupt(write bool) {
	d.mu.Lock()
	defer d.mu.Unlock()

	for _, ci := range d.list {
		ci.Interrupt(write)
	}
}

var _ net.Error = disconnectError{}

type disconnectError struct{}

func (disconnectError) Error() string {
	return "disconnect"
}

func (disconnectError) Timeout() bool {
	return true
}

func (disconnectError) Temporary() bool {
	return true
}

// TestDisconnect1 ensures errors and states are handled correctly if
// the server is disconnected mid-query.
func TestDisconnect1(t *testing.T) {
	if testing.Short() {
		t.Skip("short")
	}
	checkConnStr(t)
	SetLogger(testLogger{t})

	// Revert to the normal dialer after the test is done.
	normalCreateDialer := createDialer
	defer func() {
		createDialer = normalCreateDialer
	}()

	waitDisrupt := make(chan struct{})
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
	defer cancel()

	createDialer = func(p *connectParams) dialer {
		nd := tcpDialer{&net.Dialer{Timeout: p.dial_timeout, KeepAlive: p.keepAlive}}
		di := &dialerInterrupt{nd: nd}
		go func() {
			<-waitDisrupt
			di.Interrupt(true)
			di.Interrupt(false)
		}()
		return di
	}
	db, err := sql.Open("sqlserver", makeConnStr(t).String())
	if err != nil {
		t.Fatal(err)
	}

	if err := db.PingContext(ctx); err != nil {
		t.Fatal(err)
	}
	defer db.Close()

	_, err = db.ExecContext(ctx, `SET LOCK_TIMEOUT 1800;`)
	if err != nil {
		t.Fatal(err)
	}

	go func() {
		time.Sleep(time.Second * 1)
		close(waitDisrupt)
	}()
	t.Log("prepare for query")
	_, err = db.ExecContext(ctx, `waitfor delay '00:00:3';`)
	if err != nil {
		t.Log("expected error after disconnect", err)
		return
	}
	t.Fatal("wanted error after Exec")
}

// TestDisconnect2 tests a read error so the query is started
// but results cannot be read.
func TestDisconnect2(t *testing.T) {
	if testing.Short() {
		t.Skip("short")
	}
	checkConnStr(t)
	SetLogger(testLogger{t})

	// Revert to the normal dialer after the test is done.
	normalCreateDialer := createDialer
	defer func() {
		createDialer = normalCreateDialer
	}()

	end := make(chan error)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func() {
		waitDisrupt := make(chan struct{})
		ctx, cancel = context.WithTimeout(ctx, time.Second*2)
		defer cancel()

		createDialer = func(p *connectParams) dialer {
			nd := tcpDialer{&net.Dialer{Timeout: p.dial_timeout, KeepAlive: p.keepAlive}}
			di := &dialerInterrupt{nd: nd}
			go func() {
				<-waitDisrupt
				di.Interrupt(false)
			}()
			return di
		}
		db, err := sql.Open("sqlserver", makeConnStr(t).String())
		if err != nil {
			t.Fatal(err)
		}

		if err := db.PingContext(ctx); err != nil {
			t.Fatal(err)
		}
		defer db.Close()

		_, err = db.ExecContext(ctx, `SET LOCK_TIMEOUT 1800;`)
		if err != nil {
			t.Fatal(err)
		}
		close(waitDisrupt)

		_, err = db.ExecContext(ctx, `waitfor delay '00:00:3';`)
		end <- err
	}()

	timeout := time.After(10 * time.Second)
	select {
	case err := <-end:
		if err == nil {
			t.Fatal("test err")
		}
	case <-timeout:
		t.Fatal("timeout")
	}
}


text:
__author__ = 'douglas'

from datetime import *

atual = date.today()

print(atual)


text:
package org.apache.eagle.alert.config;

import org.junit.Assert;
import org.junit.Test;

import org.apache.eagle.dataproc.core.JsonSerDeserUtils;

public class TestAlertDedup {

	@Test
	public void test() throws Exception{
		String alertDef = "{\"alertDedupIntervalMin\":\"10\",\"fields\":[\"key1\",\"key2\",\"key3\"]}";
		DeduplicatorConfig dedupConfig = JsonSerDeserUtils.deserialize(alertDef, DeduplicatorConfig.class);
		Assert.assertEquals(dedupConfig.getAlertDedupIntervalMin(), 10);
		Assert.assertEquals(dedupConfig.getFields().size(), 3);

		alertDef = "null";
		dedupConfig = JsonSerDeserUtils.deserialize(alertDef, DeduplicatorConfig.class);
		Assert.assertEquals(dedupConfig, null);
	}

}


text:
from re import compile
from ..scraper import make_scraper
from ..util import tagre

_imageSearch = compile(tagre("img", "src", r'([^"]*/comics/[^"]+)'))
_prevSearch = compile(tagre("a", "href", r'([^"]*/d/\d{8}\.html)') +
   '(?:Previous comic' + '|' +
    tagre("img", "alt", "Previous comic") + '|' +
    tagre("img", "src", "images/back\.gif") +
    ')')

def add(name, url):
    classname = 'ComicGenesis_%s' % name
    if '/d/' in url:
        stripUrl = url.split('/d/')[0] + '/d/%s.html'
    else:
        stripUrl = url + 'd/%s.html'

    @classmethod
    def _prevUrlModifier(cls, prevUrl):
        if prevUrl:
            return prevUrl.replace("keenspace.com", "comicgenesis.com"
              ).replace("keenspot.com", "comicgenesis.com"
              ).replace("toonspace.com", "comicgenesis.com"
              ).replace("comicgen.com", "comicgenesis.com")

    globals()[classname] = make_scraper(classname,
        name='ComicGenesis/' + name,
        url=url,
        stripUrl=stripUrl,
        imageSearch = _imageSearch,
        prevSearch = _prevSearch,
        prevUrlModifier = _prevUrlModifier,
        multipleImagesPerStrip = True,
        help = 'Index format: yyyymmdd',
    )

# Comicgenesis has a lot of comics, but most of them are disallowed by robots.txt
# do not edit anything below since these entries are generated from scripts/update.sh
# DO NOT REMOVE
add('AAAAA', 'http://aaaaa.comicgenesis.com/')
add('AdventuresofKiltman', 'http://kiltman.comicgenesis.com/')
add('AmorModerno', 'http://amormoderno.comicgenesis.com/')
add('AnythingButRealLife', 'http://anythingbutreallife.comicgenesis.com/')
add('Ardra', 'http://ardra.comicgenesis.com/')
add('Artwork', 'http://artwork.comicgenesis.com/')
add('BabeintheWoods', 'http://babeinthewoods.comicgenesis.com/')
add('BackwaterPlanet', 'http://bobthespirit.comicgenesis.com/')
add('BendyStrawVampires', 'http://bsvampires.comicgenesis.com/')
add('BlindSight', 'http://blindsight.comicgenesis.com/')
add('BreakingtheDoldrum', 'http://breakingthedoldrum.comicgenesis.com/')
add('Candi', 'http://candicomics.com/')
add('CorporateLife', 'http://corporatelife.comicgenesis.com/')
add('CryHavoc', 'http://cryhavoc.comicgenesis.com/')
add('DarkWelkin', 'http://darkwelkin.comicgenesis.com/')
add('DemonEater', 'http://demoneater.comicgenesis.com/')
add('DoodleDiaries', 'http://doodlediaries.comicgenesis.com/')
add('DormSweetDorm', 'http://dormsweetdorm.comicgenesis.com/')
add('DoubleyouTeeEff', 'http://doubleyouteeeff.comicgenesis.com/')
add('DragonsBane', 'http://jasonwhitewaterz.comicgenesis.com/')
add('Dreamaniac', 'http://dreamaniaccomic.comicgenesis.com/')
add('ElnifiChronicles', 'http://elnifichronicles.comicgenesis.com/')
add('EvesApple', 'http://evesapple.comicgenesis.com/')
add('FancyThat', 'http://fancythat.comicgenesis.com/')
add('FantasyQwest', 'http://creatorauthorman.comicgenesis.com/')
add('Fantazine', 'http://fantazin.comicgenesis.com/')
add('Flounderville', 'http://flounderville.comicgenesis.com/')
add('GEM', 'http://keltzy.comicgenesis.com/')
add('Gonefor300days', 'http://g4300d.comicgenesis.com/')
add('IBlameDanny', 'http://vileterror.comicgenesis.com/')
add('ImpendingDoom', 'http://impending.comicgenesis.com/')
add('InANutshell', 'http://nutshellcomics.comicgenesis.com/')
add('KernyMantisComics', 'http://kernymantis.comicgenesis.com/')
add('KitsuneJewel', 'http://kitsunejewel.comicgenesis.com/')
add('KittyCattyGames', 'http://kittycattygames.comicgenesis.com/')
add('KiwiDayN', 'http://kiwidayn.comicgenesis.com/')
add('KungFounded', 'http://kungfounded.comicgenesis.com/')
add('LabBratz', 'http://labbratz.comicgenesis.com/')
add('Laserwing', 'http://laserwing.comicgenesis.com/')
add('LumiasKingdom', 'http://lumia.comicgenesis.com/')
add('Majestic7', 'http://majestic7.comicgenesis.com/')
add('MaximumWhimsy', 'http://maximumwhimsy.comicgenesis.com/')
add('MenschunsererZeitGerman', 'http://muz.comicgenesis.com/')
add('MoonCrest24', 'http://mooncrest.comicgenesis.com/d/20121117.html')
add('Mushian', 'http://tentoumushi.comicgenesis.com/')
add('NightwolfCentral', 'http://nightwolfcentral.comicgenesis.com/')
add('NoTimeForLife', 'http://randyraven.comicgenesis.com/')
add('NoneMoreComic', 'http://nonemore.comicgenesis.com/')
add('ODCKS', 'http://odcks.comicgenesis.com/')
add('OfDoom', 'http://ofdoom.comicgenesis.com/')
add('OpportunityofaLifetime', 'http://carpathia.comicgenesis.com/')
add('Orbz', 'http://orbz.comicgenesis.com/')
add('OwMySanity', 'http://owmysanity.comicgenesis.com/')
add('PhantomThesis', 'http://phantomthesis.comicgenesis.com/')
add('ProfessorSaltinesAstrodynamicDirigible', 'http://drsaltine.comicgenesis.com/')
add('PsychicDyslexiaInstitute', 'http://pdi.comicgenesis.com/')
add('PublicidadeEnganosa', 'http://publicidadeenganosa.comicgenesis.com/')
add('RandomAxeOfKindness', 'http://randomaxe.comicgenesis.com/')
add('SalemUncommons', 'http://salemuncommons.comicgenesis.com/')
add('SamandElisAdventures', 'http://sameliadv.comicgenesis.com/')
add('SarahZero', 'http://plughead.comicgenesis.com/')
add('SixByNineCollege', 'http://sixbyninecollege.comicgenesis.com/')
add('SpoononHighandFireontheMountian', 'http://spoon.comicgenesis.com/')
add('SueosdelSur', 'http://sds.comicgenesis.com/')
add('SynapticMisfires', 'http://synapticmisfires.comicgenesis.com/')
add('TakingStock', 'http://mapaghimagsik.comicgenesis.com/')
add('TemplarArizona', 'http://templaraz.comicgenesis.com/')
add('TheAdventuresofKaniraBaxter', 'http://kanirabaxter.comicgenesis.com/')
add('TheAdventuresofVindibuddSuperheroInTraining', 'http://vindibudd.comicgenesis.com/d/20070720.html')
add('TheEasyBreather', 'http://easybreather.comicgenesis.com/')
add('TheLounge', 'http://thelounge.comicgenesis.com/')
add('TheMisadventuresofOkk', 'http://okk.comicgenesis.com/')
add('ThePath', 'http://thepath.comicgenesis.com/')
add('TheTalesofKalduras', 'http://kalduras.comicgenesis.com/')
add('Unconventional', 'http://unconventional.comicgenesis.com/')
add('WarMageNC17', 'http://warmage.comicgenesis.com/')
add('WebcomicTheWebcomicWebcomicWebcomicWebcomic', 'http://dannormnsanidey.comicgenesis.com/')
add('WhatYouDontSee', 'http://phantomlady4.comicgenesis.com/')
add('Wierdman', 'http://asa.comicgenesis.com/')