text:
html {
    width: 100%;
    height: 100%;
    margin: 0px;
    padding: 0px;
    overflow: hidden;
    -webkit-transform-style: preserve-3d;
    transform-style: preserve-3d;
}

body {
    position: absolute;
    width: 100%;
    height: 100%;
    margin: 0px;
    padding: 0px;
    -webkit-transform-style: preserve-3d;
    transform-style: preserve-3d;
    -webkit-font-smoothing: antialiased;
    -webkit-tap-highlight-color: transparent;
    -webkit-perspective: 0;
    perspective: none;
    overflow: hidden;
}

.famous-container, .famous-group {
    position: absolute;
    top: 0px;
    left: 0px;
    bottom: 0px;
    right: 0px;
    overflow: visible;
    -webkit-transform-style: preserve-3d;
    transform-style: preserve-3d;
    -webkit-backface-visibility: visible;
    backface-visibility: visible;
    pointer-events: none;
}

.famous-group {
    width: 0px;
    height: 0px;
    margin: 0px;
    padding: 0px;
    -webkit-transform-style: preserve-3d;
    transform-style: preserve-3d;
}

.famous-surface {
    position: absolute;
    -webkit-transform-origin: center center;
    transform-origin: center center;
    -webkit-backface-visibility: hidden;
    backface-visibility: hidden;
    -webkit-transform-style: flat;
    transform-style: preserve-3d; /* performance */
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    -webkit-tap-highlight-color: transparent;
    pointer-events: auto;
}

.famous-container-group {
    position: relative;
    width: 100%;
    height: 100%;
}


text:
@class TPInputUserAccountView;

@protocol TPInputPhoneViewDelegate <NSObject>

- (void)inputPhoneViewCountrySelectViewTap:(TPInputUserAccountView *)inputPhoneView;
- (void)inputPhoneViewNextButtonTap:(TPInputUserAccountView *)inputPhoneView;

@end

@interface TPInputUserAccountView : TPBaseLayout

@property (nonatomic, weak) id<TPInputPhoneViewDelegate> delegate;

@property (nonatomic, strong) NSString *userAccount;

- (void)setCountryCode:(TPCountryModel *)countryCodeModel;

@end

redpajama_set_name: RedPajamaGithub


text:
package org.apache.beam.sdk.util;

import static com.google.common.base.Preconditions.checkArgument;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.auto.value.AutoValue;
import com.google.common.collect.ComparisonChain;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Nullable;
import org.apache.beam.sdk.coders.Coder;
import org.apache.beam.sdk.coders.CoderException;
import org.apache.beam.sdk.coders.InstantCoder;
import org.apache.beam.sdk.coders.StandardCoder;
import org.apache.beam.sdk.coders.StringUtf8Coder;
import org.apache.beam.sdk.transforms.windowing.BoundedWindow;
import org.apache.beam.sdk.util.state.StateNamespace;
import org.apache.beam.sdk.util.state.StateNamespaces;
import org.joda.time.Instant;

/**
 * Encapsulate interaction with time within the execution environment.
 *
 *
This class allows setting and deleting timers, and also retrieving an
 * estimate of the current time.
 */
public interface TimerInternals {

  /**
   * Sets a timer to be fired when the current time in the specified time domain reaches the
   * target timestamp.
   *
   *
The combination of {@code namespace} and {@code timerId} uniquely identify a timer.
   *
   *
If a timer is set and then set again before it fires, later settings should clear the prior
   * setting.
   *
   *
It is an error to set a timer for two different time domains.
   */
  void setTimer(StateNamespace namespace, String timerId, Instant target, TimeDomain timeDomain);

  /**
   * Sets the timer described by {@code timerData}.
   */
  void setTimer(TimerData timerData);

  /**
   * Deletes the given timer.
   */
  void deleteTimer(StateNamespace namespace, String timerId);

  /**
   * Deletes the timer with the ID contained in the provided {@link TimerData}.
   */
  void deleteTimer(TimerData timerKey);

  /**
   * Returns the current timestamp in the {@link TimeDomain#PROCESSING_TIME} time domain.
   */
  Instant currentProcessingTime();

  /**
   * Returns the current timestamp in the {@link TimeDomain#SYNCHRONIZED_PROCESSING_TIME} time
   * domain or {@code null} if unknown.
   */
  @Nullable
  Instant currentSynchronizedProcessingTime();

  /**
   * Return the current, local input watermark timestamp for this computation
   * in the {@link TimeDomain#EVENT_TIME} time domain.
   *
   *
This value:
   *

   *
Is never {@literal null}, but may be {@link BoundedWindow#TIMESTAMP_MIN_VALUE}.
   *
Is monotonically increasing.
   *
May differ between workers due to network and other delays.
   *
Will never be ahead of the global input watermark for this computation. But it
   * may be arbitrarily behind the global input watermark.
   *
Any element with a timestamp before the local input watermark can be considered
   * 'locally late' and be subject to special processing or be dropped entirely.
   *

   *
   *
Note that because the local input watermark can be behind the global input watermark,
   * it is possible for an element to be considered locally on-time even though it is
   * globally late.
   */
  Instant currentInputWatermarkTime();

  /**
   * Return the current, local output watermark timestamp for this computation
   * in the {@link TimeDomain#EVENT_TIME} time domain. Return {@code null} if unknown.
   *
   *
This value:
   *

   *
Is monotonically increasing.
   *
Will never be ahead of {@link #currentInputWatermarkTime} as returned above.
   *
May differ between workers due to network and other delays.
   *
However will never be behind the global input watermark for any following computation.
   *

   *
   *
In pictures:
   *
{@code
   *  |              |       |       |       |
   *  |              |   D   |   C   |   B   |   A
   *  |              |       |       |       |
   * GIWM     <=    GOWM <= LOWM <= LIWM <= GIWM
   * (next stage)
   * -------------------------------------------------> event time
   * }

   *
   *
where
   *
   *

   *
 LOWM = local output water mark.
   *
 GOWM = global output water mark.
   *
 GIWM = global input water mark.
   *
 LIWM = local input water mark.
   *
 A = A globally on-time element.
   *
 B = A globally late, but locally on-time element.
   *
 C = A locally late element which may still contribute to the timestamp of a pane.
   *
 D = A locally late element which cannot contribute to the timestamp of a pane.
   *

   *
   *
Note that if a computation emits an element which is not before the current output watermark
   * then that element will always appear locally on-time in all following computations. However,
   * it is possible for an element emitted before the current output watermark to appear locally
   * on-time in a following computation. Thus we must be careful to never assume locally late data
   * viewed on the output of a computation remains locally late on the input of a following
   * computation.
   */
  @Nullable
  Instant currentOutputWatermarkTime();

  /**
   * Data about a timer as represented within {@link TimerInternals}.
   */
  @AutoValue
  abstract class TimerData implements Comparable<TimerData> {

    public abstract String getTimerId();

    public abstract StateNamespace getNamespace();

    public abstract Instant getTimestamp();

    public abstract TimeDomain getDomain();

    /**
     * Construct a {@link TimerData} for the given parameters, where the timer ID is automatically
     * generated.
     */
    public static TimerData of(
        String timerId, StateNamespace namespace, Instant timestamp, TimeDomain domain) {
      return new AutoValue_TimerInternals_TimerData(timerId, namespace, timestamp, domain);
    }

    /**
     * Construct a {@link TimerData} for the given parameters, where the timer ID is
     * deterministically generated from the {@code timestamp} and {@code domain}.
     */
    public static TimerData of(StateNamespace namespace, Instant timestamp, TimeDomain domain) {
      String timerId =
          new StringBuilder()
              .append(domain.ordinal())
              .append(':')
              .append(timestamp.getMillis())
              .toString();
      return of(timerId, namespace, timestamp, domain);
    }

    /**
     * {@inheritDoc}.
     *
     *
The ordering of {@link TimerData} that are not in the same namespace or domain is
     * arbitrary.
     */
    @Override
    public int compareTo(TimerData that) {
      if (this.equals(that)) {
        return 0;
      }
      ComparisonChain chain =
          ComparisonChain.start()
              .compare(this.getTimestamp(), that.getTimestamp())
              .compare(this.getDomain(), that.getDomain());
      if (chain.result() == 0 && !this.getNamespace().equals(that.getNamespace())) {
        // Obtaining the stringKey may be expensive; only do so if required
        chain = chain.compare(getNamespace().stringKey(), that.getNamespace().stringKey());
      }
      return chain.result();
    }
  }

  /**
   * A {@link Coder} for {@link TimerData}.
   */
  class TimerDataCoder extends StandardCoder<TimerData> {
    private static final StringUtf8Coder STRING_CODER = StringUtf8Coder.of();
    private static final InstantCoder INSTANT_CODER = InstantCoder.of();
    private final Coder<? extends BoundedWindow> windowCoder;

    public static TimerDataCoder of(Coder<? extends BoundedWindow> windowCoder) {
      return new TimerDataCoder(windowCoder);
    }

    @SuppressWarnings("unchecked")
    @JsonCreator
    public static TimerDataCoder of(
        @JsonProperty(PropertyNames.COMPONENT_ENCODINGS)
        List<Coder<?>> components) {
      checkArgument(components.size() == 1, "Expecting 1 components, got %s", components.size());
      return of((Coder<? extends BoundedWindow>) components.get(0));
    }

    private TimerDataCoder(Coder<? extends BoundedWindow> windowCoder) {
      this.windowCoder = windowCoder;
    }

    @Override
    public void encode(TimerData timer, OutputStream outStream, Context context)
        throws CoderException, IOException {
      Context nestedContext = context.nested();
      STRING_CODER.encode(timer.getTimerId(), outStream, nestedContext);
      STRING_CODER.encode(timer.getNamespace().stringKey(), outStream, nestedContext);
      INSTANT_CODER.encode(timer.getTimestamp(), outStream, nestedContext);
      STRING_CODER.encode(timer.getDomain().name(), outStream, nestedContext);
    }

    @Override
    public TimerData decode(InputStream inStream, Context context)
        throws CoderException, IOException {
      Context nestedContext = context.nested();
      String timerId = STRING_CODER.decode(inStream, nestedContext);
      StateNamespace namespace =
          StateNamespaces.fromString(STRING_CODER.decode(inStream, nestedContext), windowCoder);
      Instant timestamp = INSTANT_CODER.decode(inStream, nestedContext);
      TimeDomain domain = TimeDomain.valueOf(STRING_CODER.decode(inStream, nestedContext));
      return TimerData.of(timerId, namespace, timestamp, domain);
    }

    @Override
    public List<? extends Coder<?>> getCoderArguments() {
      return Arrays.asList(windowCoder);
    }

    @Override
    public void verifyDeterministic() throws NonDeterministicException {
      verifyDeterministic("window coder must be deterministic", windowCoder);
    }
  }
}


text:
package github

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"testing"

	"github.com/google/go-cmp/cmp"
)

func TestUsersService_ListProjects(t *testing.T) {
	client, mux, _, teardown := setup()
	defer teardown()

	mux.HandleFunc("/users/u/projects", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "GET")
		testHeader(t, r, "Accept", mediaTypeProjectsPreview)
		testFormValues(t, r, values{"state": "open", "page": "2"})
		fmt.Fprint(w, `[{"id":1}]`)
	})

	opt := &ProjectListOptions{State: "open", ListOptions: ListOptions{Page: 2}}
	ctx := context.Background()
	projects, _, err := client.Users.ListProjects(ctx, "u", opt)
	if err != nil {
		t.Errorf("Users.ListProjects returned error: %v", err)
	}

	want := []*Project{{ID: Int64(1)}}
	if !cmp.Equal(projects, want) {
		t.Errorf("Users.ListProjects returned %+v, want %+v", projects, want)
	}

	const methodName = "ListProjects"
	testBadOptions(t, methodName, func() (err error) {
		_, _, err = client.Users.ListProjects(ctx, "\n", opt)
		return err
	})

	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Users.ListProjects(ctx, "u", opt)
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestUsersService_CreateProject(t *testing.T) {
	client, mux, _, teardown := setup()
	defer teardown()

	input := &CreateUserProjectOptions{Name: "Project Name", Body: String("Project body.")}

	mux.HandleFunc("/user/projects", func(w http.ResponseWriter, r *http.Request) {
		testMethod(t, r, "POST")
		testHeader(t, r, "Accept", mediaTypeProjectsPreview)

		v := &CreateUserProjectOptions{}
		json.NewDecoder(r.Body).Decode(v)
		if !cmp.Equal(v, input) {
			t.Errorf("Request body = %+v, want %+v", v, input)
		}

		fmt.Fprint(w, `{"id":1}`)
	})

	ctx := context.Background()
	project, _, err := client.Users.CreateProject(ctx, input)
	if err != nil {
		t.Errorf("Users.CreateProject returned error: %v", err)
	}

	want := &Project{ID: Int64(1)}
	if !cmp.Equal(project, want) {
		t.Errorf("Users.CreateProject returned %+v, want %+v", project, want)
	}

	const methodName = "CreateProject"
	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
		got, resp, err := client.Users.CreateProject(ctx, input)
		if got != nil {
			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
		}
		return resp, err
	})
}

func TestCreateUserProjectOptions_Marshal(t *testing.T) {
	testJSONMarshal(t, &CreateUserProjectOptions{}, `{}`)

	c := CreateUserProjectOptions{
		Name: "SomeProject",
		Body: String("SomeProjectBody"),
	}

	want := `{
			"name": "SomeProject",
			"body": "SomeProjectBody"
		}`

	testJSONMarshal(t, c, want)
}


text:
using BefunDebug.Pages;

namespace BefunDebug
{
	partial class frmMain
	{
		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.IContainer components = null;

		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
		protected override void Dispose(bool disposing)
		{
			if (disposing && (components != null))
			{
				components.Dispose();
			}
			base.Dispose(disposing);
		}

		#region Windows Form Designer generated code

		/// <summary>
		/// Required method for Designer support - do not modify
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
			System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmMain));
			this.tabMainControl = new System.Windows.Forms.TabControl();
			this.tabPageBefunGen = new System.Windows.Forms.TabPage();
			this.tabPageBefunRep = new System.Windows.Forms.TabPage();
			this.tabPageBefunHighlight = new System.Windows.Forms.TabPage();
			this.tabPageBefunCompile = new System.Windows.Forms.TabPage();
			this.tabPageBefunRun = new System.Windows.Forms.TabPage();
			this.tabPageTools = new System.Windows.Forms.TabPage();
			this.control_BefunGen = new BefunDebug.Pages.frmMain_BefunGen();
			this.control_BefunRep = new BefunDebug.Pages.frmMain_BefunRep();
			this.control_BefunHighlight = new BefunDebug.Pages.frmMain_BefunHighlight();
			this.control_BefunCompile = new BefunDebug.Pages.frmMain_BefunCompile();
			this.control_BefunRun = new BefunDebug.Pages.frmMain_BefunRun();
			this.control_BefunTools = new BefunDebug.Pages.frmMain_BefunTools();
			this.tabMainControl.SuspendLayout();
			this.tabPageBefunGen.SuspendLayout();
			this.tabPageBefunRep.SuspendLayout();
			this.tabPageBefunHighlight.SuspendLayout();
			this.tabPageBefunCompile.SuspendLayout();
			this.tabPageBefunRun.SuspendLayout();
			this.tabPageTools.SuspendLayout();
			this.SuspendLayout();
			//
			// tabMainControl
			//
			this.tabMainControl.Appearance = System.Windows.Forms.TabAppearance.FlatButtons;
			this.tabMainControl.Controls.Add(this.tabPageBefunGen);
			this.tabMainControl.Controls.Add(this.tabPageBefunRep);
			this.tabMainControl.Controls.Add(this.tabPageBefunHighlight);
			this.tabMainControl.Controls.Add(this.tabPageBefunCompile);
			this.tabMainControl.Controls.Add(this.tabPageBefunRun);
			this.tabMainControl.Controls.Add(this.tabPageTools);
			this.tabMainControl.Dock = System.Windows.Forms.DockStyle.Fill;
			this.tabMainControl.Location = new System.Drawing.Point(0, 0);
			this.tabMainControl.Multiline = true;
			this.tabMainControl.Name = "tabMainControl";
			this.tabMainControl.SelectedIndex = 0;
			this.tabMainControl.Size = new System.Drawing.Size(984, 697);
			this.tabMainControl.TabIndex = 6;
			this.tabMainControl.SelectedIndexChanged += new System.EventHandler(this.tabMainControl_SelectedIndexChanged);
			//
			// tabPageBefunGen
			//
			this.tabPageBefunGen.Controls.Add(this.control_BefunGen);
			this.tabPageBefunGen.Location = new System.Drawing.Point(4, 25);
			this.tabPageBefunGen.Name = "tabPageBefunGen";
			this.tabPageBefunGen.Size = new System.Drawing.Size(976, 668);
			this.tabPageBefunGen.TabIndex = 0;
			this.tabPageBefunGen.Text = "BefunGen";
			this.tabPageBefunGen.UseVisualStyleBackColor = true;
			//
			// tabPageBefunRep
			//
			this.tabPageBefunRep.Controls.Add(this.control_BefunRep);
			this.tabPageBefunRep.Location = new System.Drawing.Point(4, 25);
			this.tabPageBefunRep.Name = "tabPageBefunRep";
			this.tabPageBefunRep.Padding = new System.Windows.Forms.Padding(3);
			this.tabPageBefunRep.Size = new System.Drawing.Size(976, 668);
			this.tabPageBefunRep.TabIndex = 2;
			this.tabPageBefunRep.Text = "BefunRep";
			this.tabPageBefunRep.UseVisualStyleBackColor = true;
			//
			// tabPageBefunHighlight
			//
			this.tabPageBefunHighlight.Controls.Add(this.control_BefunHighlight);
			this.tabPageBefunHighlight.Location = new System.Drawing.Point(4, 25);
			this.tabPageBefunHighlight.Name = "tabPageBefunHighlight";
			this.tabPageBefunHighlight.Padding = new System.Windows.Forms.Padding(3);
			this.tabPageBefunHighlight.Size = new System.Drawing.Size(976, 668);
			this.tabPageBefunHighlight.TabIndex = 3;
			this.tabPageBefunHighlight.Text = "BefunHighlight";
			this.tabPageBefunHighlight.UseVisualStyleBackColor = true;
			//
			// tabPageBefunCompile
			//
			this.tabPageBefunCompile.Controls.Add(this.control_BefunCompile);
			this.tabPageBefunCompile.Location = new System.Drawing.Point(4, 25);
			this.tabPageBefunCompile.Name = "tabPageBefunCompile";
			this.tabPageBefunCompile.Padding = new System.Windows.Forms.Padding(3);
			this.tabPageBefunCompile.Size = new System.Drawing.Size(976, 668);
			this.tabPageBefunCompile.TabIndex = 4;
			this.tabPageBefunCompile.Text = "BefunCompile";
			this.tabPageBefunCompile.UseVisualStyleBackColor = true;
			//
			// tabPageBefunRun
			//
			this.tabPageBefunRun.Controls.Add(this.control_BefunRun);
			this.tabPageBefunRun.Location = new System.Drawing.Point(4, 25);
			this.tabPageBefunRun.Name = "tabPageBefunRun";
			this.tabPageBefunRun.Padding = new System.Windows.Forms.Padding(3);
			this.tabPageBefunRun.Size = new System.Drawing.Size(976, 668);
			this.tabPageBefunRun.TabIndex = 6;
			this.tabPageBefunRun.Text = "BefunRun";
			this.tabPageBefunRun.UseVisualStyleBackColor = true;
			//
			// tabPageTools
			//
			this.tabPageTools.Controls.Add(this.control_BefunTools);
			this.tabPageTools.Location = new System.Drawing.Point(4, 25);
			this.tabPageTools.Name = "tabPageTools";
			this.tabPageTools.Padding = new System.Windows.Forms.Padding(3);
			this.tabPageTools.Size = new System.Drawing.Size(976, 668);
			this.tabPageTools.TabIndex = 5;
			this.tabPageTools.Text = "Befunge Tools";
			this.tabPageTools.UseVisualStyleBackColor = true;
			//
			// control_BefunGen
			//
			this.control_BefunGen.Dock = System.Windows.Forms.DockStyle.Fill;
			this.control_BefunGen.Location = new System.Drawing.Point(0, 0);
			this.control_BefunGen.Margin = new System.Windows.Forms.Padding(0);
			this.control_BefunGen.Name = "control_BefunGen";
			this.control_BefunGen.Size = new System.Drawing.Size(976, 668);
			this.control_BefunGen.TabIndex = 0;
			//
			// control_BefunRep
			//
			this.control_BefunRep.Dock = System.Windows.Forms.DockStyle.Fill;
			this.control_BefunRep.Location = new System.Drawing.Point(3, 3);
			this.control_BefunRep.Margin = new System.Windows.Forms.Padding(0);
			this.control_BefunRep.Name = "control_BefunRep";
			this.control_BefunRep.Size = new System.Drawing.Size(970, 662);
			this.control_BefunRep.TabIndex = 0;
			//
			// control_BefunHighlight
			//
			this.control_BefunHighlight.Dock = System.Windows.Forms.DockStyle.Fill;
			this.control_BefunHighlight.Location = new System.Drawing.Point(3, 3);
			this.control_BefunHighlight.Margin = new System.Windows.Forms.Padding(0);
			this.control_BefunHighlight.Name = "control_BefunHighlight";
			this.control_BefunHighlight.Size = new System.Drawing.Size(970, 662);
			this.control_BefunHighlight.TabIndex = 0;
			//
			// control_BefunCompile
			//
			this.control_BefunCompile.Dock = System.Windows.Forms.DockStyle.Fill;
			this.control_BefunCompile.Location = new System.Drawing.Point(3, 3);
			this.control_BefunCompile.Margin = new System.Windows.Forms.Padding(0);
			this.control_BefunCompile.Name = "control_BefunCompile";
			this.control_BefunCompile.Size = new System.Drawing.Size(970, 662);
			this.control_BefunCompile.TabIndex = 0;
			//
			// control_BefunRun
			//
			this.control_BefunRun.Dock = System.Windows.Forms.DockStyle.Fill;
			this.control_BefunRun.Location = new System.Drawing.Point(3, 3);
			this.control_BefunRun.Margin = new System.Windows.Forms.Padding(0);
			this.control_BefunRun.Name = "control_BefunRun";
			this.control_BefunRun.Size = new System.Drawing.Size(970, 662);
			this.control_BefunRun.TabIndex = 0;
			//
			// control_BefunTools
			//
			this.control_BefunTools.Dock = System.Windows.Forms.DockStyle.Fill;
			this.control_BefunTools.Location = new System.Drawing.Point(3, 3);
			this.control_BefunTools.Margin = new System.Windows.Forms.Padding(0);
			this.control_BefunTools.Name = "control_BefunTools";
			this.control_BefunTools.Size = new System.Drawing.Size(970, 662);
			this.control_BefunTools.TabIndex = 0;
			//
			// frmMain
			//
			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
			this.ClientSize = new System.Drawing.Size(984, 697);
			this.Controls.Add(this.tabMainControl);
			this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
			this.Name = "frmMain";
			this.Text = "BefunUtils Tool";
			this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.frmMain_FormClosing);
			this.tabMainControl.ResumeLayout(false);
			this.tabPageBefunGen.ResumeLayout(false);
			this.tabPageBefunRep.ResumeLayout(false);
			this.tabPageBefunHighlight.ResumeLayout(false);
			this.tabPageBefunCompile.ResumeLayout(false);
			this.tabPageBefunRun.ResumeLayout(false);
			this.tabPageTools.ResumeLayout(false);
			this.ResumeLayout(false);

		}

		#endregion
		private System.Windows.Forms.TabControl tabMainControl;
		private System.Windows.Forms.TabPage tabPageBefunGen;
		private System.Windows.Forms.TabPage tabPageBefunRep;
		private System.Windows.Forms.TabPage tabPageBefunHighlight;
		private System.Windows.Forms.TabPage tabPageBefunCompile;
		private System.Windows.Forms.TabPage tabPageTools;
		private frmMain_BefunGen control_BefunGen;
		private frmMain_BefunRep control_BefunRep;
		private frmMain_BefunHighlight control_BefunHighlight;
		private frmMain_BefunCompile control_BefunCompile;
		private frmMain_BefunTools control_BefunTools;
		private System.Windows.Forms.TabPage tabPageBefunRun;
		private frmMain_BefunRun control_BefunRun;
	}
}


text:
<?php $this->includeCss('users.css'); ?>
<?php $this->includeJavaScript('externalauth.js'); ?>
<?php $this->set('template.action.search', $this->get('search-form.action')); ?>

	<form method="post" action="<?php $this->html('add-form.action'); ?>" class="groups padding">
		<?php echo($this->msg('Groups.add.description')); ?>

			<?php $this->html('add-form.input-names'); ?>

			<?php echo($this->msg('Groups.data.role'));?>

			<?php $this->html('add-form.select-roles'); ?>

		<?php $this->html('form.auth-section'); ?>

			<?php $this->html('add-form.submit');?>
			<?php echo $this->msgRaw('PageRestore.form.cancel', $this->get('add-form.back')); ?>

	</form>


text:
package org.neo4art.api.builder.mock.timeline;

import java.awt.Color;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import org.neo4art.colour.domain.ColourAnalysis;
import org.neo4art.domain.Artwork;

/**
 * @author Enrico De Benetti
 * @since 29 Apr 2015
 *
 */
public class BuildTimeLineMock {

	public List<ColourAnalysis> getColourAnalysis(){

		List<ColourAnalysis> colourAnalysisList = new ArrayList<ColourAnalysis>();

		ColourAnalysis colourAnalysis1 = new ColourAnalysis();
		colourAnalysis1.setAverageColour(new Color(197,215,242));
		colourAnalysis1.setSource("http://www.vggallery.com/painting/f_0001.jpg");
		Artwork artwork1 = new Artwork();
		artwork1.setTitle("Still Life with Cabbage and Clogs");
		artwork1.setYear("1881");
		colourAnalysis1.setArtwork(artwork1);

		ColourAnalysis colourAnalysis2 = new ColourAnalysis();
		colourAnalysis2.setAverageColour(new Color(4,135,213));
		colourAnalysis2.setSource("http://www.vggallery.com/painting/f_0018.jpg");
		Artwork artwork2 = new Artwork();
		artwork2.setTitle("Farmhouses Among Trees");

		Calendar calendar2 = Calendar.getInstance();
		calendar2.set(Calendar.YEAR, 1883);
		calendar2.set(Calendar.MONTH, 8);
		calendar2.set(Calendar.DAY_OF_MONTH, 14);
		calendar2.set(Calendar.HOUR,12);
		calendar2.set(Calendar.MINUTE,0);

		artwork2.setCompletionDate(calendar2.getTime());
		colourAnalysis2.setArtwork(artwork2);

		ColourAnalysis colourAnalysis3 = new ColourAnalysis();
		colourAnalysis3.setAverageColour(new Color(77,211,18));
		colourAnalysis3.setSource("http://www.vggallery.com/painting/f_0216i.jpg");
		Artwork artwork3 = new Artwork();
		artwork3.setTitle("Plaster Statuette of a Female Torso");

		Calendar calendar3 = Calendar.getInstance();
		calendar3.set(Calendar.YEAR, 1886);
		calendar3.set(Calendar.MONTH, 2);
		calendar3.set(Calendar.DAY_OF_MONTH, 9);
		calendar3.set(Calendar.HOUR,12);
		calendar3.set(Calendar.MINUTE,0);

		artwork3.setCompletionDate(calendar3.getTime());
		colourAnalysis3.setArtwork(artwork3);

		ColourAnalysis colourAnalysis4 = new ColourAnalysis();
		colourAnalysis4.setAverageColour(new Color(141,115,245));
		colourAnalysis4.setSource("http://www.vggallery.com/painting/f_0273.jpg");
		Artwork artwork4 = new Artwork();
		artwork4.setTitle("Le Moulin de Blute-Fin");

		Calendar calendar4 = Calendar.getInstance();
		calendar4.set(Calendar.YEAR, 1886);
		calendar4.set(Calendar.MONTH, 5);
		calendar4.set(Calendar.DAY_OF_MONTH, 9);
		calendar4.set(Calendar.HOUR,12);
		calendar4.set(Calendar.MINUTE,0);

		artwork4.setCompletionDate(calendar4.getTime());
		colourAnalysis4.setArtwork(artwork4);

		colourAnalysisList.add(colourAnalysis1);
		colourAnalysisList.add(colourAnalysis2);
		colourAnalysisList.add(colourAnalysis3);
		colourAnalysisList.add(colourAnalysis4);

	  return colourAnalysisList;
	}

}


text:
<?php
	defined("BASEPATH") OR exit("No Direct script access allowed");

	class Employer_model extends CI_Model{

		public function __construct(){

			parent:: __construct();

			// $this->db->db_select('auth_google',TRUE);

		}

		public function getActiveEmployer($eid)
		{
			$query = $this->db->select('tb_users.user_id, tb_users.email, mobile_num, company_name, company_description, street_1, tb_cities.city_name AS city_1, tb_region.region_name AS province_1, profile_pic, first_name, middle_name, last_name, telephone_number, department, industry, position, area_code, company_banner, company_website, tb_region.id AS region_id, tb_cities.id AS city_id')
								->where('tb_users.user_id',$eid)
								->join('tb_employer','tb_employer.user_id = tb_users.user_id')
								->join('tb_region', 'tb_region.id = tb_employer.province_1')
								->join('tb_cities', 'tb_cities.id = tb_employer.city_1')
								->get('tb_users');
			return $query->row();
		}

		public function updateCompanyProfile($user_id, $data)
		{
			$query = $this->db->where('user_id',$user_id)->update('tb_employer',$data);

			return TRUE;
		}

		public function updateProfile($user_id, $data)
		{
			$query = $this->db->where('user_id',$user_id)->update('tb_employer',$data);

			return TRUE;
		}

		public function updateEmail($user_id, $data)
		{
			$query = $this->db->where('user_id',$user_id)->update('tb_users',$data);

			return TRUE;
		}

		public function updatePassword($user_id, $data)
		{
			$query = $this->db->where('user_id',$user_id)->update('tb_users',$data);

			return TRUE;
		}

		public function updateMobileNumber($user_id, $data)
		{
			$query = $this->db->where('user_id', $user_id)->update('tb_users', $data);

			return TRUE;
		}

		public function validUser($user_id, $password)
		{
			$query = $this->db->where('user_id', $user_id)->where('password', $password)->get('tb_users');

			if($query->num_rows() === 1)
			{
				return TRUE;
			}
			else{
				return FALSE;
			}
		}

		public function updateBanner($user_id, $banner)
		{
			$query = $this->db->where('user_id',$user_id)->update('tb_employer',$banner);

			return TRUE;
		}

		public function updateCompanyLogo($user_id, $banner)
		{
			$query = $this->db->where('user_id',$user_id)->update('tb_employer',$banner);

			return TRUE;
		}
	}
?>


text:
'use strict';

var Xtemplate = require('kissy-xtemplate'),
	fs = require('fs'),
    path = require('path'),
    os = require('os'),
    chalk = require('chalk');

module.exports = function (grunt) {

    // Please see the Grunt documentation for more information regarding task
    // creation: http://gruntjs.com/creating-tasks

    grunt.registerMultiTask('xtemplate', 'Compile KISSY XTemplates.', function () {
        // Merge task-specific and/or target-specific options with these defaults.
        var options = this.options();

        var xtemp = new Xtemplate(options);

        this.files.forEach(function (f) {
            var src = f.src.filter(function(filepath) {
                // Warn on and remove invalid source files (if nonull was set).
                if (!grunt.file.exists(filepath)) {
                    grunt.log.warn('Source file ' + chalk.cyan(filepath) + ' not found.');
                    return false;
                } else {
                    return true;
                }
            });

            if (src.length === 0) {
                grunt.log.warn('Destination ' + chalk.cyan(f.dest) + ' not written because src files were empty.');
                return;
            }
            src.forEach(function(src){
                xtemp.compileSync(src, f.dest);
//                grunt.log.ok('compiled ' + src + ' ===> ' + f.dest + ' successfully.');
            });
        });

    });

};


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

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name="uuf-renderablecreator-hbs" verbose="1" >
    <test name="uuf-renderablecreator-hbs"   >
        <packages>
            <package name="org.wso2.carbon.uuf.renderablecreator.hbs" />
        </packages>
    </test>
</suite>


text:
<!doctype html>
<!--
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-->
<html>
  <head>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">

    <title>polymer-i18n-poc</title>

    <script src="../webcomponentsjs/webcomponents-lite.js"></script>

    <link rel="import" href="../polymer/polymer.html">
    <link rel="import" href="../iron-component-page/iron-component-page.html">

  </head>
  <body>

    <iron-component-page></iron-component-page>

  </body>
</html>


text:
define(['can', 'app/admin/admin'], function (can, Admin) {
    'use strict';

    /**
     * Router for users.
     * @author dorajistyle
     * @param {string} target
     * @function Router
     * @name admin#Routers
     * @constructor
     */

    var Routers = function (target) {
        new Admin(target);
    };

    return Routers;
});


text:
class RequestPipeline
  attr_reader :params, :api_params

  def initialize(params, api_params)
    @params = params
    @api_params = api_params
  end

  def execute
    values = route_map

    return {} if values.empty?

    Services::Requester.make_request( values[:verb],
                                      values[:url],
                                      { 'X-API-TOKEN': values[:token] },
                                      api_params )
  end

  private

  def route_map
    verb = params[:method].to_s.downcase

    path = params[:url_pattern].gsub('/api/', '').gsub('(.:format)', '')
    splited_path = path.split('/')
    version = splited_path.shift
    url_pattern = splited_path.join('/')

    route = Route.where({ verb: verb,
                          version: version,
                          url_pattern: url_pattern }).last

    return {} unless route

    service = route.service
    {
      verb: verb,
      url: "#{service.url}#{params[:path]}",
      token: service.token
    }
  end
end


text:
package com.commonsware.android.mrp;

import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.widget.Toast;

public class MainActivity extends ActionBarActivity {
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    Toast.makeText(this, R.string.active, Toast.LENGTH_LONG)
         .show();

    finish();
  }
}


text:
package com.thinkgem.jeesite.modules.edu.web.portal.dto;

import com.thinkgem.jeesite.modules.edu.entity.Major;

/**
 * Created by wanjinma on 15/4/20.
 */
public class TeacherDto {
    private String id;
    private String name;
    private String img;
    private String content;
    private Byte status;
    private Byte gendar;
    private String teachTime;
    private String grade;
    private String ability;
    private String summary;
    private String majorName;
    private String majorId;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getImg() {
        return img;
    }

    public void setImg(String img) {
        this.img = img;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Byte getStatus() {
        return status;
    }

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

    public Byte getGendar() {
        return gendar;
    }

    public void setGendar(Byte gendar) {
        this.gendar = gendar;
    }

    public String getTeachTime() {
        return teachTime;
    }

    public void setTeachTime(String teachTime) {
        this.teachTime = teachTime;
    }

    public String getGrade() {
        return grade;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }

    public String getAbility() {
        return ability;
    }

    public void setAbility(String ability) {
        this.ability = ability;
    }

    public String getSummary() {
        return summary;
    }

    public void setSummary(String summary) {
        this.summary = summary;
    }

    public String getMajorName() {
        return majorName;
    }

    public void setMajorName(String majorName) {
        this.majorName = majorName;
    }

    public String getMajorId() {
        return majorId;
    }

    public void setMajorId(String majorId) {
        this.majorId = majorId;
    }
}


text:
package Paws::EC2::RegisterImage;
  use Moose;
  has Architecture => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'architecture' );
  has BillingProducts => (is => 'ro', isa => 'ArrayRef[Str|Undef]', traits => ['NameInRequest'], request_name => 'BillingProduct' );
  has BlockDeviceMappings => (is => 'ro', isa => 'ArrayRef[Paws::EC2::BlockDeviceMapping]', traits => ['NameInRequest'], request_name => 'BlockDeviceMapping' );
  has Description => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'description' );
  has DryRun => (is => 'ro', isa => 'Bool', traits => ['NameInRequest'], request_name => 'dryRun' );
  has EnaSupport => (is => 'ro', isa => 'Bool', traits => ['NameInRequest'], request_name => 'enaSupport' );
  has ImageLocation => (is => 'ro', isa => 'Str');
  has KernelId => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'kernelId' );
  has Name => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'name' , required => 1);
  has RamdiskId => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'ramdiskId' );
  has RootDeviceName => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'rootDeviceName' );
  has SriovNetSupport => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'sriovNetSupport' );
  has VirtualizationType => (is => 'ro', isa => 'Str', traits => ['NameInRequest'], request_name => 'virtualizationType' );

  use MooseX::ClassAttribute;

  class_has _api_call => (isa => 'Str', is => 'ro', default => 'RegisterImage');
  class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::EC2::RegisterImageResult');
  class_has _result_key => (isa => 'Str', is => 'ro');
1;

### main pod documentation begin ###

=head1 NAME

Paws::EC2::RegisterImage - Arguments for method RegisterImage on Paws::EC2

=head1 DESCRIPTION

This class represents the parameters used for calling the method RegisterImage on the
Amazon Elastic Compute Cloud service. Use the attributes of this class
as arguments to method RegisterImage.

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

As an example:

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

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

=head1 ATTRIBUTES

=head2 Architecture => Str

The architecture of the AMI.

Default: For Amazon EBS-backed AMIs, C<i386>. For instance store-backed
AMIs, the architecture specified in the manifest file.

Valid values are: C<"i386">, C<"x86_64">

=head2 BillingProducts => ArrayRef[Str|Undef]

The billing product codes. Your account must be authorized to specify
billing product codes. Otherwise, you can use the AWS Marketplace to
bill for the use of an AMI.

=head2 BlockDeviceMappings => ArrayRef[L<Paws::EC2::BlockDeviceMapping>]

One or more block device mapping entries.

=head2 Description => Str

A description for your AMI.

=head2 DryRun => Bool

Checks whether you have the required permissions for the action,
without actually making the request, and provides an error response. If
you have the required permissions, the error response is
C<DryRunOperation>. Otherwise, it is C<UnauthorizedOperation>.

=head2 EnaSupport => Bool

Set to C<true> to enable enhanced networking with ENA for the AMI and
any instances that you launch from the AMI.

This option is supported only for HVM AMIs. Specifying this option with
a PV AMI can make instances launched from the AMI unreachable.

=head2 ImageLocation => Str

The full path to your AMI manifest in Amazon S3 storage.

=head2 KernelId => Str

The ID of the kernel.

=head2 B<REQUIRED> Name => Str

A name for your AMI.

Constraints: 3-128 alphanumeric characters, parentheses (()), square
brackets ([]), spaces ( ), periods (.), slashes (/), dashes (-), single
quotes ('), at-signs (@), or underscores(_)

=head2 RamdiskId => Str

The ID of the RAM disk.

=head2 RootDeviceName => Str

The name of the root device (for example, C</dev/sda1>, or
C</dev/xvda>).

=head2 SriovNetSupport => Str

Set to C<simple> to enable enhanced networking with the Intel 82599
Virtual Function interface for the AMI and any instances that you
launch from the AMI.

There is no way to disable C<sriovNetSupport> at this time.

This option is supported only for HVM AMIs. Specifying this option with
a PV AMI can make instances launched from the AMI unreachable.

=head2 VirtualizationType => Str

The type of virtualization.

Default: C<paravirtual>

=head1 SEE ALSO

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

=head1 BUGS and CONTRIBUTIONS

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

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

=cut


text:
module.exports = {

  getColumn(columns, idx) {
    if(Array.isArray(columns)){
      return columns[idx];
    }else if (typeof Immutable !== 'undefined') {
      return columns.get(idx);
    }
  },

  getSize(columns) {
    if(Array.isArray(columns)){
      return columns.length;
    }else if (typeof Immutable !== 'undefined') {
      return columns.size;
    }
  },
}


text:
{% extends "base.html" %}
{% load filter %}
{% load staticfiles %}
{% block pagetitle %}{{envt.name}}{% endblock %}
{% block maintitle %}Environnement {{envt.name}}{% endblock %}

{% block frequentActionsButtons %}
{% if perms.ref.scm_addenvironment %}D{% endif %}
E
P
{% endblock %}

{% block scripts %}

<link rel="stylesheet" type="text/css" href='{% static "datatables-1.10.5/css/dataTables.bootstrap.css" %}'>

{% endblock scripts %}

{% block content %}
{% regroup cis by description as compotype_list %}

Généralités

Code	: {{envt.name}}

Responsable	: {{envt.manager}}

Référencé le	: {{envt.buildDate|date:'d/m/y'}}

Détruit le	: {% if envt.destructionDate %}{{envt.destructionDate}}{% else %}à plannifier{% endif %}

Catégorie	: {{envt.typology.name}}

Géré en version	: {% if envt.managed %}oui{% else %}non{% endif %}

Liens GCL

Historique des installations

Sauvegardes disponibles

Tags

Accès rapide

    {% for compotype in compotype_list %}
        {{ compotype.grouper.description | capfirst}}

    {%  endfor %}

Composants

    {% for compotype in compotype_list %}

{{compotype.grouper.description}}

                {% comment %} Table Header {% endcomment %}

                        Livré dans
                        Nom
                        {% for field in compotype.grouper.field_set.all %}
                            {{field.short_label|capfirst}}
                        {% endfor %}

                        {% for field in compotype.grouper.computed_field_set.all %}
                            {{field.short_label|capfirst}}
                        {% endfor %}

                        {% if perms.ref.change_component_instance %}	{% endif %}

	           {% comment %} Data rows {% endcomment %}

                {% for compo in compotype.list %}

                           {% if compo.instanciates %}{{compo.instanciates.implements.application.name}} - {{compo.instanciates.implements.name}}{% endif %}
                           {% if compo.include_in_envt_backup %}{% endif %}

                       {{compo.name}}

                       {% for field, value in compo.description.field_set.all|project_ci_fields:compo.field_set.all %}
                           {{value | urlify}}
                       {% endfor %}

                       {% for field in compo.description.computed_field_set.all %}
                           {{compo | apply_field_template:field | urlify}}
                       {% endfor %}

                       {% if perms.ref.change_component_instance %}éditer	{% endif %}

                {% endfor %}

    {% endfor %}

    {% if perms.ref.change_component_instance %}

Composants supprimés

ID	Type

                {% for ci in deleted %}

{{ci.id}}	{{ci.description.description}}	éditer

                {% endfor %}

    {% endif %}

Représentation

	<svg width='2048' height='2048'>
	   <g transform="translate(20,20) scale(0.7)"/>
	</svg>

{% endblock content %}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Alphora.Dataphor
{
	/// <summary>
	/// Utility class to perform assembly name parsing.
	/// </summary>
	/// <remarks>
	/// The Silverlight Framework has prevented us from running
	/// Assembly.GetName() or using the AssemblyName constructor
	/// that would perform AssemblyName parsing, so this utility
	/// class performs those security critical tasks.
	/// </remarks>
	public static class AssemblyNameUtility
	{
		public static string GetName(string fullName)
		{
			return fullName.Split(',')[0];
		}

		public static Version GetVersion(string fullName)
		{
			string[] parts = fullName.Split(',');
			for (int index = 0; index < parts.Length; index++)
				if (parts[index].Trim().StartsWith("Version"))
					return new Version(parts[index].Split('=')[1]);

			throw new ArgumentException("Invalid Assembly Name Format");
		}
	}
}


text:
import * as React from 'react'
import Async, { Props as AsyncProps } from 'react-promise'
import Issue from './Issue'
import Loading from './Loading'
import { getIssuesForRepo } from '../github-api'
import GithubIssue from '../types/github-issue'

const AsyncGithubIssues = Async as { new (props: AsyncProps<GithubIssue[]>): Async<GithubIssue[]> }

export interface Props {
  owner: string
  repo: string
}

const Issues: React.StatelessComponent<Props> = ({ owner, repo }) => (
  <AsyncGithubIssues
    promise={getIssuesForRepo(owner, repo)}
    pendingRender={<Loading />}
    then={issues => (
      <div>{issues.map((issue, i) => <Issue key={i} owner={owner} repo={repo} issueNumber={issue.number} issue={issue} />)}</div>
    )}
    catch={err => <text>Error while loading issues: {err}</text>}
  />
)

export default Issues


text:
//==============================================================================
//         Copyright 2003 - 2012   LASMEA UMR 6602 CNRS/Univ. Clermont II
//         Copyright 2009 - 2012   LRI    UMR 8623 CNRS/Univ Paris Sud XI
//
//          Distributed under the Boost Software License, Version 1.0.
//                 See accompanying file LICENSE.txt or copy at
//                     http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#ifndef BOOST_SIMD_ARITHMETIC_FUNCTIONS_FAST_RSQRT_HPP_INCLUDED
#define BOOST_SIMD_ARITHMETIC_FUNCTIONS_FAST_RSQRT_HPP_INCLUDED

#include <boost/simd/include/functor.hpp>
#include <boost/dispatch/include/functor.hpp>

namespace boost { namespace simd
{
  namespace tag
  {
    /*!
      @brief fast_rsqrt generic tag

      Represents the fast_rsqrt function in generic contexts.

      @par Models:
      Hierarchy
    **/
    struct fast_rsqrt_ : ext::elementwise_<fast_rsqrt_>
    {
      /// @brief Parent hierarchy
      typedef ext::elementwise_<fast_rsqrt_> parent;
    };
  }
  /*!
    Computes the inverse of the square root its parameter.

    @par semantic:
    For any given value @c x of type @c T:

    @code
    T r = fast_rsqrt(x);
    @endcode

    is similar to:

    @code
    T r = T(1)/sqrt(x);
    @endcode

    @par Note:

    Fast means that the computation is possibly done through some
    low precision intrinsic. The result can be not fully accurate

    @see funcref{rsqrt}
    @param  a0

    @return      a value of the typeof the input.

  **/
  BOOST_DISPATCH_FUNCTION_IMPLEMENTATION(tag::fast_rsqrt_, fast_rsqrt, 1)
} }

#endif


text:
package com.mtnaircomputer.atcsmon_dbtools;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Unit test for simple App.
 */
public class AppTest
    extends TestCase
{
    /**
     * Create the test case
     *
     * @param testName name of the test case
     */
    public AppTest(String testName)
    {
        super(testName);
    }

    /**
     * @return the suite of tests being tested
     */
    public static Test suite()
    {
        return new TestSuite(AppTest.class);
    }

    /**
     * Rigorous Test :-)
     */
    public void testApp()
    {
    	App.main(null);
        assertTrue(true);
    }

    /**
     * Rigorous Test :-)
     */
    public void testAppEmptyOptions()
    {
    	String[] emptyOptions = {""};

    	App.main(emptyOptions);
        assertTrue(true);
    }

    /**
     * Testing main with some parameters.
     */
    public void testAppWithArguments()
    {
    	String[] cmdLineOptions = {
    			"-sourceDBPath", "up_boone_15_1025.mdb",
    			"-masterDBPath", "ATCSdb.mdb",
                "-operation", CmdLineParser.OPERATION_DUMP
    	};

    	App.main(cmdLineOptions);
    	assertTrue(true);
    }
}


text:
module RouteC
  describe Lights do

    context 'light the lights' do
      before(:each) do
        allow_any_instance_of(Object).to receive(:sleep) { nil }

        allow(PiPiper::Pin).to receive(:new) do
          double = instance_double(PiPiper::Pin)
          allow(double).to receive(:off)
          double
        end
      end

      (1..8).each do |i|
        arr = Array.new(Config.new.lights.count).each_with_index.map { |k,v| v + 1 <= i ? 1 : 0 }

        it "lights #{i} lights with an array like #{arr}" do
          lights = described_class.new(arr)
          i.times { |i| expect(lights.lights[i]).to receive(:on) }
          lights.turn_on
        end
      end
    end

    it 'turns off the lights' do
      allow_any_instance_of(Object).to receive(:sleep) { nil }

      allow(PiPiper::Pin).to receive(:new) do
        double = instance_double(PiPiper::Pin)
        allow(double).to receive(:on)
        expect(double).to receive(:off)
        double
      end

      described_class.new([1,1,1,0,0,0,0]).turn_on
    end

  end
end


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Carduus wolgensis M.Bieb. ex Willd.

### Remarks
null


text:
package konstructs.shard

import java.util.UUID

import konstructs.api.{Position, Block, BlockTypeId, Direction, Rotation, Orientation, LightLevel, Colour, Health}
import konstructs.Db

case class BlockData(w: Int,
                     health: Int,
                     direction: Int,
                     rotation: Int,
                     ambient: Int,
                     red: Int,
                     green: Int,
                     blue: Int,
                     light: Int) {
  def write(data: Array[Byte], i: Int) {
    BlockData.write(data, i, w, health, direction, rotation, ambient, red, green, blue, light)
  }

  def block(id: UUID, blockTypeId: BlockTypeId) =
    new Block(id, blockTypeId, Health.get(health), Orientation.get(direction, rotation))
}

object BlockData {

  val Size = 7

  def w(data: Array[Byte], i: Int): Int =
    (data(i * Size) & 0xFF) + ((data(i * Size + 1) & 0xFF) << 8)

  def hp(data: Array[Byte], i: Int): Int =
    (data(i * Size + 2) & 0xFF) + ((data(i * Size + 3) & 0x07) << 8)

  def direction(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 3) & 0xE0) >> 5)

  def rotation(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 3) & 0x18) >> 3)

  def ambientLight(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 4) & 0x0F))

  def red(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 4) & 0xF0) >> 4)

  def green(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 5) & 0x0F))

  def blue(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 5) & 0xF0) >> 4)

  def light(data: Array[Byte], i: Int): Int =
    ((data(i * Size + 6) & 0x0F))

  def apply(data: Array[Byte], i: Int): BlockData = {
    apply(w(data, i),
          hp(data, i),
          direction(data, i),
          rotation(data, i),
          ambientLight(data, i),
          red(data, i),
          green(data, i),
          blue(data, i),
          light(data, i))
  }

  def apply(w: Int, block: Block, ambient: Int, colour: Colour, level: LightLevel): BlockData = {
    apply(
      w,
      block.getHealth.getHealth,
      block.getOrientation.getDirection.getEncoding,
      block.getOrientation.getRotation.getEncoding,
      ambient,
      colour.getRed,
      colour.getGreen,
      colour.getBlue,
      level.getLevel
    )
  }

  def write(data: Array[Byte],
            i: Int,
            w: Int,
            health: Int,
            direction: Int,
            rotation: Int,
            ambient: Int,
            red: Int,
            green: Int,
            blue: Int,
            light: Int) {
    writeW(data, i, w)
    writeHealthAndOrientation(data, i, health, direction, rotation)
    writeLight(data, i, ambient, red, green, blue, light)
  }

  def write(data: Array[Byte],
            i: Int,
            w: Int,
            block: Block,
            ambientLight: LightLevel,
            colour: Colour,
            light: LightLevel) {
    write(data,
          i,
          w,
          block.getHealth.getHealth,
          block.getOrientation.getDirection.getEncoding,
          block.getOrientation.getRotation.getEncoding,
          ambientLight.getLevel,
          colour.getRed,
          colour.getGreen,
          colour.getBlue,
          light.getLevel)
  }

  def writeW(data: Array[Byte], i: Int, w: Int) {
    data(i * Size) = (w & 0xFF).toByte
    data(i * Size + 1) = ((w >> 8) & 0xFF).toByte
  }

  def writeHealthAndOrientation(data: Array[Byte], i: Int, health: Int, direction: Int, rotation: Int) {
    data(i * Size + 2) = (health & 0xFF).toByte
    val b = (((direction << 5) & 0xE0) + ((rotation << 3) & 0x18) + ((health >> 8) & 0x07)).toByte
    data(i * Size + 3) = b
  }

  def writeLight(data: Array[Byte], i: Int, ambient: Int, red: Int, green: Int, blue: Int, light: Int) {
    val b4 = ((ambient & 0x0F) + ((red << 4) & 0xF0)).toByte
    data(i * Size + 4) = b4
    val b5 = ((green & 0x0F) + ((blue << 4) & 0xF0)).toByte
    data(i * Size + 5) = b5
    data(i * Size + 6) = (light & 0x0F).toByte
  }

}


text:
var artnet = require("artnet-node");

var srv = artnet.Server.listen(6454, function(msg, peer) {
	console.log("-----------------");
	console.log("Sequence: " + msg.sequence);
	console.log("Physical: " + msg.physical);
	console.log("Universe: " + msg.universe);
	console.log("Length: " + msg.length);
	console.log("Data: " + msg.data);
	console.log("-----------------");
});


text:
package arx.core.graphics.text

/**
 * Created by IntelliJ IDEA.
 * User: nvt
 * Date: 2/15/13
 * Time: 9:04 AM
 * Created by nonvirtualthunk
 */

import java.awt.{RenderingHints, AlphaComposite, Color, Font}
import java.awt.image.BufferedImage
import arx.core.graphics.data.{SubImageView, Image}
import arx.core.datastructures.Rect

class FontHelper(font:Font) {
	def pixelSize = imgSize
	val bufferedImage = new BufferedImage((font.getSize*1.5).toInt,(font.getSize*1.5).toInt, BufferedImage.TYPE_INT_ARGB)
	val g = bufferedImage.createGraphics

	val backgroundColor: Color = new Color(1.0f,1.0f,1.0f,1.0f)
	val foregroundColor: Color = new Color(1.0f,1.0f,1.0f,1.0f)

	g.setFont(font)
	g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON)
	g.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON)
	g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY)

	val fm = g.getFontMetrics
	val ascent = fm.getMaxAscent
	val descent = fm.getMaxDescent

	val imgSize : Int = math.max(fm.charWidth('W')+3,fm.getMaxAscent+fm.getMaxDescent+fm.getLeading/2+3) //fm. //font.getSize * 1.5).toInt
	var retImage : Image = Image.withDimensions(imgSize,imgSize)

	def clearCanvas () {
		// Clear image with background color (make transparent if color has alpha value)
		g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR,0.0f))
		g.setColor(backgroundColor)
		g.fillRect(0,0,imgSize,imgSize)
	}

	/**
	 * Draws a character to an Image and returns it. The image returned
	 * will be invalidated as soon as drawChar is next called
	 * @param ch the character to render
	 * @return an image representation of the character
	 */
	def drawChar ( ch : Char ) = {
		clearCanvas()
		// prepare to draw characters in foreground color
		g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f))
		g.setColor(foregroundColor)

		g.drawString( String.valueOf(ch) , 0 , ascent )

		val cWidth = if ( ch == 'f' ) { fm.charWidth(ch) + 2 } else { fm.charWidth(ch) }
		val cHeight = fm.getHeight - 2
		val cX = 0
		val cY = 0

		val retSubImage = new SubImageView(retImage,Rect(0,0,cWidth,cHeight))
		val rast = bufferedImage.getData
		var x = 0 ; while ( x < cWidth ) {
			var y = 0 ; while ( y < cHeight ) {
				var q = 0; while ( q < 4 ) {
					val rastX = x + cX
					val rastY = math.max(y + cY,0)
					retSubImage(x,cHeight - y - 1,q) = rast.getSample(rastX,rastY,q).toByte
				q += 1}
			y += 1}
		x += 1}
		retSubImage
	}
}


text:
<?php

namespace CsvMigrations\FieldHandlers\Config;

/**
 * CountryConfig
 *
 * This class provides the predefined configuration
 * for country field handlers.
 */
class CountryConfig extends FixedConfig
{
    /**
     * @var array $providers List of provider names and classes
     */
    protected $providers = [
        'combinedFields' => '\\CsvMigrations\\FieldHandlers\\Provider\\CombinedFields\\NullCombinedFields',
        'dbFieldType' => '\\CsvMigrations\\FieldHandlers\\Provider\\DbFieldType\\StringDbFieldType',
        'fieldValue' => '\\CsvMigrations\\FieldHandlers\\Provider\\FieldValue\\MixedFieldValue',
        'fieldToDb' => '\\CsvMigrations\\FieldHandlers\\Provider\\FieldToDb\\ListFieldToDb',
        'searchOperators' => '\\CsvMigrations\\FieldHandlers\\Provider\\SearchOperators\\ListSearchOperators',
        'searchOptions' => '\\CsvMigrations\\FieldHandlers\\Provider\\SearchOptions\\CountrySearchOptions',
        'selectOptions' => '\\CsvMigrations\\FieldHandlers\\Provider\\SelectOptions\\ListSelectOptions',
        'renderInput' => '\\CsvMigrations\\FieldHandlers\\Provider\\RenderInput\\CountryRenderer',
        'renderValue' => '\\CsvMigrations\\FieldHandlers\\Provider\\RenderValue\\CountryRenderer',
        'renderName' => '\\CsvMigrations\\FieldHandlers\\Provider\\RenderName\\DefaultRenderer',
        'validationRules' => '\\CsvMigrations\\FieldHandlers\\Provider\\ValidationRules\\ListValidationRules',
    ];
}


text:
<?php

namespace Integrated\Bundle\ContentBundle\Document\Permission\Embedded;

use Integrated\Common\Security\Permission as CommonPermission;

class Permission extends CommonPermission
{
}


text:
import asyncio
import os
import socket
import stat
import sys
import warnings
from argparse import ArgumentParser
from collections import Iterable, MutableMapping
from importlib import import_module

from yarl import URL

from . import (hdrs, web_exceptions, web_fileresponse, web_middlewares,
               web_protocol, web_request, web_response, web_server,
               web_urldispatcher, web_ws)
from .abc import AbstractMatchInfo, AbstractRouter
from .helpers import FrozenList
from .http import HttpVersion  # noqa
from .log import access_logger, web_logger
from .signals import FuncSignal, PostSignal, PreSignal, Signal
from .web_exceptions import *  # noqa
from .web_fileresponse import *  # noqa
from .web_middlewares import *  # noqa
from .web_protocol import *  # noqa
from .web_request import *  # noqa
from .web_response import *  # noqa
from .web_server import Server
from .web_urldispatcher import *  # noqa
from .web_urldispatcher import PrefixedSubAppResource
from .web_ws import *  # noqa

__all__ = (web_protocol.__all__ +
           web_fileresponse.__all__ +
           web_request.__all__ +
           web_response.__all__ +
           web_exceptions.__all__ +
           web_urldispatcher.__all__ +
           web_ws.__all__ +
           web_server.__all__ +
           web_middlewares.__all__ +
           ('Application', 'HttpVersion', 'MsgType'))

class Application(MutableMapping):
    def __init__(self, *,
                 logger=web_logger,
                 router=None,
                 middlewares=(),
                 handler_args=None,
                 client_max_size=1024**2,
                 secure_proxy_ssl_header=None,
                 loop=None,
                 debug=...):
        if router is None:
            router = web_urldispatcher.UrlDispatcher()
        assert isinstance(router, AbstractRouter), router

        if loop is not None:
            warnings.warn("loop argument is deprecated", ResourceWarning)

        self._debug = debug
        self._router = router
        self._secure_proxy_ssl_header = secure_proxy_ssl_header
        self._loop = loop
        self._handler_args = handler_args
        self.logger = logger

        self._middlewares = FrozenList(middlewares)
        self._state = {}
        self._frozen = False
        self._subapps = []

        self._on_pre_signal = PreSignal()
        self._on_post_signal = PostSignal()
        self._on_loop_available = FuncSignal(self)
        self._on_response_prepare = Signal(self)
        self._on_startup = Signal(self)
        self._on_shutdown = Signal(self)
        self._on_cleanup = Signal(self)
        self._client_max_size = client_max_size

    # MutableMapping API

    def __getitem__(self, key):
        return self._state[key]

    def _check_frozen(self):
        if self._frozen:
            warnings.warn("Changing state of started or joined "
                          "application is deprecated",
                          DeprecationWarning,
                          stacklevel=3)

    def __setitem__(self, key, value):
        self._check_frozen()
        self._state[key] = value

    def __delitem__(self, key):
        self._check_frozen()
        del self._state[key]

    def __len__(self):
        return len(self._state)

    def __iter__(self):
        return iter(self._state)

    ########
    @property
    def loop(self):
        return self._loop

    def _set_loop(self, loop):
        if loop is None:
            loop = asyncio.get_event_loop()
        if self._loop is not None and self._loop is not loop:
            raise RuntimeError(
                "web.Application instance initialized with different loop")

        self._loop = loop
        self._on_loop_available.send(self)

        # set loop debug
        if self._debug is ...:
            self._debug = loop.get_debug()

        # set loop to sub applications
        for subapp in self._subapps:
            subapp._set_loop(loop)

    @property
    def frozen(self):
        return self._frozen

    def freeze(self):
        if self._frozen:
            return

        self._frozen = True
        self._middlewares = tuple(reversed(self._middlewares))
        self._router.freeze()
        self._on_loop_available.freeze()
        self._on_pre_signal.freeze()
        self._on_post_signal.freeze()
        self._on_response_prepare.freeze()
        self._on_startup.freeze()
        self._on_shutdown.freeze()
        self._on_cleanup.freeze()

        for subapp in self._subapps:
            subapp.freeze()

    @property
    def debug(self):
        return self._debug

    def _reg_subapp_signals(self, subapp):

        def reg_handler(signame):
            subsig = getattr(subapp, signame)

            @asyncio.coroutine
            def handler(app):
                yield from subsig.send(subapp)
            appsig = getattr(self, signame)
            appsig.append(handler)

        reg_handler('on_startup')
        reg_handler('on_shutdown')
        reg_handler('on_cleanup')

    def add_subapp(self, prefix, subapp):
        if self.frozen:
            raise RuntimeError(
                "Cannot add sub application to frozen application")
        if subapp.frozen:
            raise RuntimeError("Cannot add frozen application")
        if prefix.endswith('/'):
            prefix = prefix[:-1]
        if prefix in ('', '/'):
            raise ValueError("Prefix cannot be empty")

        resource = PrefixedSubAppResource(prefix, subapp)
        self.router.register_resource(resource)
        self._reg_subapp_signals(subapp)
        self._subapps.append(subapp)
        if self._loop is not None:
            subapp._set_loop(self._loop)
        return resource

    @property
    def on_loop_available(self):
        return self._on_loop_available

    @property
    def on_response_prepare(self):
        return self._on_response_prepare

    @property
    def on_pre_signal(self):
        return self._on_pre_signal

    @property
    def on_post_signal(self):
        return self._on_post_signal

    @property
    def on_startup(self):
        return self._on_startup

    @property
    def on_shutdown(self):
        return self._on_shutdown

    @property
    def on_cleanup(self):
        return self._on_cleanup

    @property
    def router(self):
        return self._router

    @property
    def middlewares(self):
        return self._middlewares

    def make_handler(self, *, loop=None,
                     secure_proxy_ssl_header=None, **kwargs):
        self._set_loop(loop)
        self.freeze()

        kwargs['debug'] = self.debug
        if self._handler_args:
            for k, v in self._handler_args.items():
                kwargs[k] = v

        if secure_proxy_ssl_header:
            self._secure_proxy_ssl_header = secure_proxy_ssl_header
        return Server(self._handle, request_factory=self._make_request,
                      loop=self.loop, **kwargs)

    @asyncio.coroutine
    def startup(self):
        """Causes on_startup signal

        Should be called in the event loop along with the request handler.
        """
        yield from self.on_startup.send(self)

    @asyncio.coroutine
    def shutdown(self):
        """Causes on_shutdown signal

        Should be called before cleanup()
        """
        yield from self.on_shutdown.send(self)

    @asyncio.coroutine
    def cleanup(self):
        """Causes on_cleanup signal

        Should be called after shutdown()
        """
        yield from self.on_cleanup.send(self)

    def _make_request(self, message, payload, protocol, writer, task,
                      _cls=web_request.Request):
        return _cls(
            message, payload, protocol, writer, protocol._time_service, task,
            secure_proxy_ssl_header=self._secure_proxy_ssl_header,
            client_max_size=self._client_max_size)

    @asyncio.coroutine
    def _handle(self, request):
        match_info = yield from self._router.resolve(request)
        assert isinstance(match_info, AbstractMatchInfo), match_info
        match_info.add_app(self)

        if __debug__:
            match_info.freeze()

        resp = None
        request._match_info = match_info
        expect = request.headers.get(hdrs.EXPECT)
        if expect:
            resp = (
                yield from match_info.expect_handler(request))

        if resp is None:
            handler = match_info.handler
            for app in match_info.apps:
                for factory in app._middlewares:
                    handler = yield from factory(app, handler)

            resp = yield from handler(request)

        assert isinstance(resp, web_response.StreamResponse), \
            ("Handler {!r} should return response instance, "
             "got {!r} [middlewares {!r}]").format(
                 match_info.handler, type(resp),
                 [middleware for middleware in app.middlewares
                  for app in match_info.apps])
        return resp

    def __call__(self):
        """gunicorn compatibility"""
        return self

    def __repr__(self):
        return "<Application 0x{:x}>".format(id(self))

def run_app(app, *, host=None, port=None, path=None, sock=None,
            shutdown_timeout=60.0, ssl_context=None,
            print=print, backlog=128, access_log_format=None,
            access_log=access_logger, loop=None):
    """Run an app locally"""
    if loop is None:
        loop = asyncio.get_event_loop()

    make_handler_kwargs = dict()
    if access_log_format is not None:
        make_handler_kwargs['access_log_format'] = access_log_format
    handler = app.make_handler(loop=loop, access_log=access_log,
                               **make_handler_kwargs)

    loop.run_until_complete(app.startup())

    scheme = 'https' if ssl_context else 'http'
    base_url = URL('{}://localhost'.format(scheme)).with_port(port)

    if path is None:
        paths = ()
    elif isinstance(path, (str, bytes, bytearray, memoryview))\
            or not isinstance(path, Iterable):
        paths = (path,)
    else:
        paths = path

    if sock is None:
        socks = ()
    elif not isinstance(sock, Iterable):
        socks = (sock,)
    else:
        socks = sock

    if host is None:
        if (paths or socks) and not port:
            hosts = ()
        else:
            hosts = ("0.0.0.0",)
    elif isinstance(host, (str, bytes, bytearray, memoryview))\
            or not isinstance(host, Iterable):
        hosts = (host,)
    else:
        hosts = host

    if hosts and port is None:
        port = 8443 if ssl_context else 8080

    server_creations = []
    uris = [str(base_url.with_host(host)) for host in hosts]
    if hosts:
        # Multiple hosts bound to same server is available in most loop
        # implementations, but only send multiple if we have multiple.
        host_binding = hosts[0] if len(hosts) == 1 else hosts
        server_creations.append(
            loop.create_server(
                handler, host_binding, port, ssl=ssl_context, backlog=backlog
            )
        )
    for path in paths:
        # Most loop implementations don't support multiple paths bound in same
        # server, so create a server for each.
        server_creations.append(
            loop.create_unix_server(
                handler, path, ssl=ssl_context, backlog=backlog
            )
        )
        uris.append('{}://unix:{}:'.format(scheme, path))

        # Clean up prior socket path if stale and not abstract.
        # CPython 3.5.3+'s event loop already does this. See
        # https://github.com/python/asyncio/issues/425
        if path[0] not in (0, '\x00'):  # pragma: no branch
            try:
                if stat.S_ISSOCK(os.stat(path).st_mode):
                    os.remove(path)
            except FileNotFoundError:
                pass
    for sock in socks:
        server_creations.append(
            loop.create_server(
                handler, sock=sock, ssl=ssl_context, backlog=backlog
            )
        )

        if hasattr(socket, 'AF_UNIX') and sock.family == socket.AF_UNIX:
            uris.append('{}://unix:{}:'.format(scheme, sock.getsockname()))
        else:
            host, port = sock.getsockname()
            uris.append(str(base_url.with_host(host).with_port(port)))

    servers = loop.run_until_complete(
        asyncio.gather(*server_creations, loop=loop)
    )

    print("======== Running on {} ========\n"
          "(Press CTRL+C to quit)".format(', '.join(uris)))

    try:
        loop.run_forever()
    except KeyboardInterrupt:  # pragma: no cover
        pass
    finally:
        server_closures = []
        for srv in servers:
            srv.close()
            server_closures.append(srv.wait_closed())
        loop.run_until_complete(asyncio.gather(*server_closures, loop=loop))
        loop.run_until_complete(app.shutdown())
        loop.run_until_complete(handler.shutdown(shutdown_timeout))
        loop.run_until_complete(app.cleanup())
    loop.close()

def main(argv):
    arg_parser = ArgumentParser(
        description="aiohttp.web Application server",
        prog="aiohttp.web"
    )
    arg_parser.add_argument(
        "entry_func",
        help=("Callable returning the `aiohttp.web.Application` instance to "
              "run. Should be specified in the 'module:function' syntax."),
        metavar="entry-func"
    )
    arg_parser.add_argument(
        "-H", "--hostname",
        help="TCP/IP hostname to serve on (default: %(default)r)",
        default="localhost"
    )
    arg_parser.add_argument(
        "-P", "--port",
        help="TCP/IP port to serve on (default: %(default)r)",
        type=int,
        default="8080"
    )
    arg_parser.add_argument(
        "-U", "--path",
        help="Unix file system path to serve on. Specifying a path will cause "
             "hostname and port arguments to be ignored.",
    )
    args, extra_argv = arg_parser.parse_known_args(argv)

    # Import logic
    mod_str, _, func_str = args.entry_func.partition(":")
    if not func_str or not mod_str:
        arg_parser.error(
            "'entry-func' not in 'module:function' syntax"
        )
    if mod_str.startswith("."):
        arg_parser.error("relative module names not supported")
    try:
        module = import_module(mod_str)
    except ImportError as ex:
        arg_parser.error("unable to import %s: %s" % (mod_str, ex))
    try:
        func = getattr(module, func_str)
    except AttributeError:
        arg_parser.error("module %r has no attribute %r" % (mod_str, func_str))

    # Compatibility logic
    if args.path is not None and not hasattr(socket, 'AF_UNIX'):
        arg_parser.error("file system paths not supported by your operating"
                         " environment")

    app = func(extra_argv)
    run_app(app, host=args.hostname, port=args.port, path=args.path)
    arg_parser.exit(message="Stopped\n")

if __name__ == "__main__":  # pragma: no branch
    main(sys.argv[1:])  # pragma: no cover


text:
create table hash_test(id int,
			   test_time time,
			   test_date date,
			   test_timestamp timestamp, primary key(id,test_time))
	PARTITION BY HASH(test_time)
        PARTITIONS 0;

drop class hash_test;


text:
package federation

import (
	"github.com/coredns/coredns/plugin/kubernetes"

	api "k8s.io/api/core/v1"
	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type APIConnFederationTest struct{}

func (APIConnFederationTest) HasSynced() bool                        { return true }
func (APIConnFederationTest) Run()                                   { return }
func (APIConnFederationTest) Stop() error                            { return nil }
func (APIConnFederationTest) SvcIndexReverse(string) []*api.Service  { return nil }
func (APIConnFederationTest) EpIndexReverse(string) []*api.Endpoints { return nil }

func (APIConnFederationTest) PodIndex(string) []*api.Pod {
	a := []*api.Pod{{
		ObjectMeta: meta.ObjectMeta{
			Namespace: "podns",
		},
		Status: api.PodStatus{
			PodIP: "10.240.0.1", // Remote IP set in test.ResponseWriter
		},
	}}
	return a
}

func (APIConnFederationTest) SvcIndex(string) []*api.Service {
	svcs := []*api.Service{
		{
			ObjectMeta: meta.ObjectMeta{
				Name:      "svc1",
				Namespace: "testns",
			},
			Spec: api.ServiceSpec{
				ClusterIP: "10.0.0.1",
				Ports: []api.ServicePort{{
					Name:     "http",
					Protocol: "tcp",
					Port:     80,
				}},
			},
		},
		{
			ObjectMeta: meta.ObjectMeta{
				Name:      "hdls1",
				Namespace: "testns",
			},
			Spec: api.ServiceSpec{
				ClusterIP: api.ClusterIPNone,
			},
		},
		{
			ObjectMeta: meta.ObjectMeta{
				Name:      "external",
				Namespace: "testns",
			},
			Spec: api.ServiceSpec{
				ExternalName: "ext.interwebs.test",
				Ports: []api.ServicePort{{
					Name:     "http",
					Protocol: "tcp",
					Port:     80,
				}},
			},
		},
	}
	return svcs
}

func (APIConnFederationTest) ServiceList() []*api.Service {
	svcs := []*api.Service{
		{
			ObjectMeta: meta.ObjectMeta{
				Name:      "svc1",
				Namespace: "testns",
			},
			Spec: api.ServiceSpec{
				ClusterIP: "10.0.0.1",
				Ports: []api.ServicePort{{
					Name:     "http",
					Protocol: "tcp",
					Port:     80,
				}},
			},
		},
		{
			ObjectMeta: meta.ObjectMeta{
				Name:      "hdls1",
				Namespace: "testns",
			},
			Spec: api.ServiceSpec{
				ClusterIP: api.ClusterIPNone,
			},
		},
		{
			ObjectMeta: meta.ObjectMeta{
				Name:      "external",
				Namespace: "testns",
			},
			Spec: api.ServiceSpec{
				ExternalName: "ext.interwebs.test",
				Ports: []api.ServicePort{{
					Name:     "http",
					Protocol: "tcp",
					Port:     80,
				}},
			},
		},
	}
	return svcs
}

func (APIConnFederationTest) EpIndex(string) []*api.Endpoints {
	eps := []*api.Endpoints{
		{
			Subsets: []api.EndpointSubset{
				{
					Addresses: []api.EndpointAddress{
						{
							IP:       "172.0.0.1",
							Hostname: "ep1a",
						},
					},
					Ports: []api.EndpointPort{
						{
							Port:     80,
							Protocol: "tcp",
							Name:     "http",
						},
					},
				},
			},
			ObjectMeta: meta.ObjectMeta{
				Name:      "svc1",
				Namespace: "testns",
			},
		},
	}
	return eps
}

func (APIConnFederationTest) EndpointsList() []*api.Endpoints {
	eps := []*api.Endpoints{
		{
			Subsets: []api.EndpointSubset{
				{
					Addresses: []api.EndpointAddress{
						{
							IP:       "172.0.0.1",
							Hostname: "ep1a",
						},
					},
					Ports: []api.EndpointPort{
						{
							Port:     80,
							Protocol: "tcp",
							Name:     "http",
						},
					},
				},
			},
			ObjectMeta: meta.ObjectMeta{
				Name:      "svc1",
				Namespace: "testns",
			},
		},
	}
	return eps
}

func (APIConnFederationTest) GetNodeByName(name string) (*api.Node, error) {
	return &api.Node{
		ObjectMeta: meta.ObjectMeta{
			Name: "test.node.foo.bar",
			Labels: map[string]string{
				kubernetes.LabelRegion: "fd-r",
				kubernetes.LabelZone:   "fd-az",
			},
		},
	}, nil
}

func (APIConnFederationTest) GetNamespaceByName(name string) (*api.Namespace, error) {
	return &api.Namespace{
		ObjectMeta: meta.ObjectMeta{
			Name: name,
		},
	}, nil
}