text:
package joshie.harvest.core.base.block;

import joshie.harvest.core.HFTab;
import joshie.harvest.core.helpers.EntityHelper;
import net.minecraft.block.BlockHorizontal;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IStringSerializable;
import net.minecraft.util.Mirror;
import net.minecraft.util.Rotation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public abstract class BlockHFEnumRotatableMeta<B extends BlockHFEnumRotatableMeta, E extends Enum<E> & IStringSerializable> extends BlockHFEnum<B, E> {
    public static final PropertyDirection FACING = BlockHorizontal.FACING;
    //Main Constructor
    public BlockHFEnumRotatableMeta(Material material, Class<E> clazz, CreativeTabs tab) {
        super(material, clazz, tab);
        setDefaultState(blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH));
    }

    //Constructor default to farming tab
    public BlockHFEnumRotatableMeta(Material material, Class<E> clazz) {
        this(material, clazz, HFTab.FARMING);
    }

    @Override
    protected BlockStateContainer createBlockState() {
        if(property == null) return new BlockStateContainer(this, temporary, FACING);
        return new BlockStateContainer(this, property, FACING);
    }

    @Override
    public ItemStack getStackFromEnum(E e) {
        return new ItemStack(this, 1, e.ordinal());
    }

    public ItemStack getStackFromEnum(E e, int amount) {
        return new ItemStack(this, amount, e.ordinal());
    }

    @Override
    public IBlockState getStateFromMeta(int meta) {
        return getDefaultState().withProperty(property, getEnumFromMeta(meta)).withProperty(FACING, getFacingFromMeta(meta));
    }

    public EnumFacing getFacingFromMeta(int meta) {
        return EnumFacing.values()[2 + ((meta / values.length) %4)];
    }

    @Override
    public int getMetaFromState(IBlockState state) {
        int enumValue = (state.getValue(property)).ordinal();
        int faceValue = (state.getValue(FACING)).ordinal();
        return enumValue + (values.length * enumValue) + faceValue;
    }

    @Override
    public int damageDropped(IBlockState state) {
        return (state.getValue(property)).ordinal(); //Return without the extra data
    }

    @Override
    public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
        EnumFacing facing = EntityHelper.getFacingFromEntity(placer);
        world.setBlockState(pos, state.withProperty(FACING, facing));
    }

    @SuppressWarnings("deprecation")
    @Override
    public IBlockState withRotation(IBlockState state, Rotation rot) {
        return state.withProperty(FACING, rot.rotate(state.getValue(FACING)));
    }

    @SuppressWarnings("deprecation")
    @Override
    public IBlockState withMirror(IBlockState state, Mirror mirrorIn) {
        return state.withRotation(mirrorIn.toRotation(state.getValue(FACING)));
    }

    @SideOnly(Side.CLIENT)
    @Override
    public void registerModels(Item item, String name) {
        for (int i = 0; i < values.length; i++) {
            if (Character.toLowerCase(property.getName().charAt(0)) < Character.toLowerCase('f')) {
                ModelLoader.setCustomModelResourceLocation(item, i, new ModelResourceLocation(getRegistryName(), property.getName() + "=" + getEnumFromMeta(i).getName() + ",facing=north"));
            } else {
                ModelLoader.setCustomModelResourceLocation(item, i, new ModelResourceLocation(getRegistryName(), "facing=north," + property.getName() + "=" + getEnumFromMeta(i).getName()));
            }
        }
    }
}


text:
.container_header {
    padding: 0 40px;
}
.ptl {
    padding-top: 20px !important;
}

.title-text {
    font-size: 26px;
    line-height: 26px;
    color: #1e90ff;
}

.center-text {
    margin-left: auto;
    margin-right: auto;
    text-align: center;
}

.helper-text {
    color: red;
}
.center {
    margin: auto;
    width: 40%;
    border:3px solid #8AC007;
    padding: 10px;
    background-color: yellowgreen;
}

.center-users {
    margin: auto;
    width: 40%;
    border:3px solid lightgrey;
    padding: 10px;
    background-color: lightgrey;
}

.login_icon_input {
    padding-left: 2px !important;
    width: 280px;
    height : 37px;
}

.btn-primary {
    background-color: #49a2f6;
    background-image: linear-gradient(to top, #2b90ef 0%, #49a2f6 100%);
    border-color: #2a7cca;
    color: #fff;
}

.btn-login {
    width: 290px;
    height : 37px;
}

.button-link {
    background:none!important;
    border:none;
    padding:0!important;

    /*optional*/
    font-family:arial,sans-serif; /*input has OS specific font-family*/
    color:#069;
    text-decoration:underline;
    cursor:pointer;
}

/* Style Sheet for New Login Page */
.form-title h1{margin: 50px 0 30px 0; font-weight: 200; color:#e2e2e2;}
.form-title h1 a.title_lable,.form-title h1 a.title_lable:hover,.form-title h1 a.title_lable:active,h1 a.title_lable:link{color:#e2e2e2;text-decoration: none}
.form-title h1 a.active {font-weight: 500; color:#333!important;}
.warning p{text-align: center;line-height: 2em;}

redpajama_set_name: RedPajamaGithub


text:
function varargout=shadedErrorBar(x,y,errBar,lineProps,opacity,plotEdge)
% function H=shadedErrorBar(x,y,errBar,lineProps,transparent)
%
% Purpose
% Makes a 2-d line plot with a pretty shaded error bar made
% using patch. Error bar color is chosen automatically.
%
% Inputs
% x - vector of x values [optional, can be left empty]
% y - vector of y values or a matrix of n observations by m cases
%     where m has length(x);
% errBar - if a vector we draw symmetric errorbars. If it has a size
%          of [2,length(x)] then we draw asymmetric error bars with
%          row 1 being the upper bar and row 2 being the lower bar
%          (with respect to y). ** alternatively ** errBar can be a
%          cellArray of two function handles. The first defines which
%          statistic the line should be and the second defines the
%          error bar.
% lineProps - [optional,'-k' by default] defines the properties of
%             the data line. e.g.:
%             'or-', or {'-or','markerfacecolor',[1,0.2,0.2]}
% transparent - [optional, 0 by default] if ==1 the shaded error
%               bar is made transparent, which forces the renderer
%               to be openGl. However, if this is saved as .eps the
%               resulting file will contain a raster not a vector
%               image.
%
% Outputs
% H - a structure of handles to the generated plot objects.
%
%
% Examples
% y=randn(30,80); x=1:size(y,2);
% shadedErrorBar(x,mean(y,1),std(y),'g');
% shadedErrorBar(x,y,{@median,@std},{'r-o','markerfacecolor','r'});
% shadedErrorBar([],y,{@median,@std},{'r-o','markerfacecolor','r'});
%
% Overlay two transparent lines
% y=randn(30,80)*10; x=(1:size(y,2))-40;
% shadedErrorBar(x,y,{@mean,@std},'-r',1);
% hold on
% y=ones(30,1)*x; y=y+0.06*y.^2+randn(size(y))*10;
% shadedErrorBar(x,y,{@mean,@std},'-b',1);
% hold off
%
%
% Rob Campbell - November 2009

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Error checking
narginchk(3,6)

%Process y using function handles if needed to make the error bar
%dynamically
if iscell(errBar)
    fun1=errBar{1};
    fun2=errBar{2};
    errBar=fun2(y);
    y=fun1(y);
else
    y=y(:)';
end

if isempty(x)
    x=1:length(y);
else
    x=x(:)';
end

%Make upper and lower error bars if only one was specified
if length(errBar)==length(errBar(:))
    errBar=repmat(errBar(:)',2,1);
else
    s=size(errBar);
    f=find(s==2);
    if isempty(f), error('errBar has the wrong size'), end
    if f==2, errBar=errBar'; end
end

if length(x) ~= length(errBar)
    error('length(x) must equal length(errBar)')
end

%Set default options
defaultProps={};
if nargin<4, lineProps=defaultProps; end
if isempty(lineProps), lineProps=defaultProps; end
if ~iscell(lineProps), lineProps={lineProps}; end

if nargin<5, opacity=0; end
if nargin<6, plotEdge=1; end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Plot to get the parameters of the line
H.mainLine=plot(x,y,lineProps{:});

% Work out the color of the shaded region and associated lines
% Using alpha requires the render to be openGL and so you can't
% save a vector image. On the other hand, you need alpha if you're
% overlaying lines. There we have the option of choosing alpha or a
% de-saturated solid colour for the patch surface .

col=get(H.mainLine,'color');
edgeColor=col+(1-col)*0.55;
patchSaturation=0.15; %How de-saturated or transparent to make patch
if opacity
    faceAlpha=opacity;
    patchColor=col;
    set(gcf,'renderer','openGL')
else
    faceAlpha=1;
    patchColor=col+(1-col)*(1-patchSaturation);
    set(gcf,'renderer','painters')
end

%Calculate the error bars
uE=y+errBar(1,:);
lE=y-errBar(2,:);

%Add the patch error bar
holdStatus=ishold;
if ~holdStatus, hold on,  end

%Make the patch
yP=[lE,fliplr(uE)];
xP=[x,fliplr(x)];

%remove nans otherwise patch won't work
xP(isnan(yP))=[];
yP(isnan(yP))=[];

H.patch=patch(xP,yP,1,'facecolor',patchColor,...
              'edgecolor','none',...
              'facealpha',faceAlpha);

%Make pretty edges around the patch.
if plotEdge
    H.edge(1)=plot(x,lE,'-','color',edgeColor);
    H.edge(2)=plot(x,uE,'-','color',edgeColor);
end

%Now replace the line (this avoids having to bugger about with z coordinates)
uistack(H.mainLine,'top')

if ~holdStatus, hold off, end

if nargout==1
    varargout{1}=H;
end


text:
package com.helger.commons.codec;

import java.io.IOException;
import java.io.Writer;
import java.util.BitSet;

import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.WillNotClose;

import com.helger.commons.string.StringHelper;
import com.helger.commons.text.util.ABNF;

/**
 * Codec for RFC 2616 HTTP header values.
 *
 * @author Philip Helger
 * @since 9.3.6
 */
public class RFC2616Codec implements ICharArrayCodec
{
  private static final char QUOTE_CHAR = '"';
  private static final char ESCAPE_CHAR = '\\';

  // Non-token chars according to RFC 2616
  private static final BitSet NON_TOKEN_RFC2616 = new BitSet (256);

  static
  {
    for (int i = ABNF.CHECK_RANGE_MIN_INCL; i <= ABNF.CHECK_RANGE_MAX_INCL; ++i)
      if (ABNF.isCtl (i) || ABNF.isSP (i) || ABNF.isHTab (i))
        NON_TOKEN_RFC2616.set (i);
    NON_TOKEN_RFC2616.set ('(');
    NON_TOKEN_RFC2616.set (')');
    NON_TOKEN_RFC2616.set ('<');
    NON_TOKEN_RFC2616.set ('>');
    NON_TOKEN_RFC2616.set ('@');
    NON_TOKEN_RFC2616.set (',');
    NON_TOKEN_RFC2616.set (';');
    NON_TOKEN_RFC2616.set (':');
    NON_TOKEN_RFC2616.set ('\\');
    NON_TOKEN_RFC2616.set ('"');
    NON_TOKEN_RFC2616.set ('/');
    NON_TOKEN_RFC2616.set ('[');
    NON_TOKEN_RFC2616.set (']');
    NON_TOKEN_RFC2616.set ('?');
    NON_TOKEN_RFC2616.set ('=');
    NON_TOKEN_RFC2616.set ('{');
    NON_TOKEN_RFC2616.set ('}');
  }

  public static boolean isToken (@Nullable final String s)
  {
    // May not be empty
    if (s == null)
      return false;

    return isToken (s.toCharArray ());
  }

  public static boolean isToken (@Nullable final char [] aChars)
  {
    // May not be empty
    if (aChars == null || aChars.length == 0)
      return false;

    // No forbidden chars may be present
    for (final char c : aChars)
      if (NON_TOKEN_RFC2616.get (c))
        return false;
    return true;
  }

  public static boolean isMaybeEncoded (@Nullable final String s)
  {
    return s != null && s.length () >= 2 && s.charAt (0) == QUOTE_CHAR && StringHelper.getLastChar (s) == QUOTE_CHAR;
  }

  public static boolean isMaybeEncoded (@Nullable final char [] s)
  {
    return s != null && s.length >= 2 && s[0] == QUOTE_CHAR && s[s.length - 1] == QUOTE_CHAR;
  }

  public RFC2616Codec ()
  {}

  @Nonnegative
  @Override
  public int getMaximumEncodedLength (@Nonnegative final int nDecodedLen)
  {
    // Worst case: each char needs quoting
    return 1 + 2 * nDecodedLen + 1;
  }

  public void encode (@Nullable final char [] aDecodedBuffer,
                      @Nonnegative final int nOfs,
                      @Nonnegative final int nLen,
                      @Nonnull @WillNotClose final Writer aWriter)
  {
    // Length 0 is okay, because it results in an empty string
    if (aDecodedBuffer == null)
      return;

    try
    {
      // Opening quote
      aWriter.write (QUOTE_CHAR);

      for (int i = 0; i < nLen; ++i)
      {
        final char b = aDecodedBuffer[nOfs + i];
        if (b == ESCAPE_CHAR || b == QUOTE_CHAR)
          aWriter.write (ESCAPE_CHAR);
        aWriter.write (b);
      }

      // closing quote
      aWriter.write (QUOTE_CHAR);
    }
    catch (final IOException ex)
    {
      throw new EncodeException ("Failed to encode RFC2616", ex);
    }
  }

  @Nonnegative
  @Override
  public int getMaximumDecodedLength (@Nonnegative final int nEncodedLen)
  {
    if (nEncodedLen < 2)
      return 0;
    // Without leading and trailing quote
    return nEncodedLen - 2;
  }

  public void decode (@Nullable final char [] aEncodedBuffer,
                      @Nonnegative final int nOfs,
                      @Nonnegative final int nLen,
                      @Nonnull @WillNotClose final Writer aWriter)
  {
    if (aEncodedBuffer == null)
      return;

    if (nLen < 2)
      throw new DecodeException ("At least the 2 quote characters must be present. Provided length is only " + nLen);

    if (aEncodedBuffer[nOfs] != QUOTE_CHAR)
      throw new DecodeException ("The provided bytes does not seem to be encoded. The first byte is not the double quote character.");
    final int nLastOfs = nOfs + nLen - 1;
    if (aEncodedBuffer[nLastOfs] != QUOTE_CHAR)
      throw new DecodeException ("The provided bytes does not seem to be encoded. The last byte is not the double quote character.");

    try
    {
      for (int i = nOfs + 1; i < nLastOfs; ++i)
      {
        final char c = aEncodedBuffer[i];
        if (c == ESCAPE_CHAR)
        {
          if (i == nLastOfs - 1)
            throw new DecodeException ("The encoded string seems to be cut. The second last character cannot be an escape character.");
          ++i;
          aWriter.write (aEncodedBuffer[i]);
        }
        else
          aWriter.write (c);
      }
    }
    catch (final IOException ex)
    {
      throw new DecodeException ("Failed to decode RFC2616", ex);
    }
  }
}


text:
/**
  * Created by Brent on 11/23/2016.
  */
import org.deeplearning4j.eval.Evaluation
import org.deeplearning4j.nn.api.OptimizationAlgorithm
import org.deeplearning4j.nn.conf.MultiLayerConfiguration
import org.deeplearning4j.nn.conf.NeuralNetConfiguration
import org.deeplearning4j.nn.conf.Updater
import org.deeplearning4j.nn.conf.inputs.InputType
import org.deeplearning4j.nn.conf.layers.ConvolutionLayer
import org.deeplearning4j.nn.conf.layers.DenseLayer
import org.deeplearning4j.nn.conf.layers.OutputLayer
import org.deeplearning4j.nn.conf.layers.SubsamplingLayer
import org.deeplearning4j.nn.conf.layers.setup.ConvolutionLayerSetup
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork
import org.deeplearning4j.nn.weights.WeightInit
import org.deeplearning4j.optimize.listeners.ScoreIterationListener
import org.nd4j.linalg.api.buffer.DataBuffer
import org.nd4j.linalg.api.ndarray.INDArray
import org.nd4j.linalg.dataset.DataSet
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator
import org.nd4j.linalg.factory.Nd4j
import org.nd4j.linalg.lossfunctions.LossFunctions

object Driver {

  def main(args: Array[String]): Unit = {

  }

}


text:
<#macro plantilla titulo="${i18n('header.title')}">
<!DOCTYPE html>

        <meta charset="utf-8">
        <title>${titulo}</title>
        <link rel="icon" href="${assetsAt('image/bug32.png')}" sizes="32x32" type="image/png">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta name="description" content="">
        <meta name="author" content="Herman Barrantes">

        <link rel="stylesheet" href="${webJarsAt('bootstrap/3.3.5/css/bootstrap.min.css')}">
        <link rel="stylesheet" href="${webJarsAt('bootstrap/3.3.5/css/bootstrap-theme.min.css')}">
        <link rel="stylesheet" href="${webJarsAt('font-awesome/4.4.0/css/font-awesome.min.css')}">
        <link rel="stylesheet" href="${assetsAt('css/custom.css')}">

            <#include "header.ftl.html"/>

            <#if (flash.error)??>

                ${i18n("error")}:
                ${i18n("error")}: ${flash.error}

            </#if>

            <#if (flash.success)??>

                ${flash.success}

            </#if>

            <#nested/>

            <#include "footer.ftl.html"/>

</#macro>


text:
module ResumeStylist
  class UnsuportedFormatError < StandardError
    # No body
  end

  class Resume
    Handlers = []

    def self.register_handler(handler)
      Handlers << handler
    end

    attr_accessor :data

    def initialize(input, resume_format)
      @data = {
        "basics" => {
          "name" =>          nil,
          "label" =>         nil,
          "picture" =>       nil,
          "email" =>         nil,
          "phone" =>         nil,
          "website" =>       nil,
          "summary" =>       nil
        },

        "location" => {
          "address" => nil,
          "postalCode" => nil,
          "city" => nil,
          "countryCode" => nil,
          "region" => nil
        },

        "profiles" =>      [], # { network, username, url }
        "work" =>          [], # { organisation, position, website, summary, highlights => [], startDate, endDate }
        "volunteer" =>     [], # { organisation, position, website, summary, highlights => [], startDate, endDate }
        "education" =>     [], # { institution, area, studyType, grade, courses => [], startDate, endDate }
        "publications" =>  [], # { name, publisher, releaseDate, website, summary }
        "skill" =>         [], # { name, level }
        "language" =>      [], # { name, level }
        "reference" =>     [], # { name, reference }

        # @XXX: Remove these?
        "awards" =>        [], # { title, date, awarder, summary }
        "interests" =>     []  # { name, keywords }
      }

      if handler = Handlers.find {|h| h.handles? resume_format }
        handler.instance_method(:load!).bind(self).call(input)
      else
        raise UnsuportedFormatError, "`#{resume_format.to_s}` is not a valid format"
      end

    end
  end
end

require "resume-stylist/resume/json.rb"
require "resume-stylist/resume/xml.rb"


text:
List Slider

List Slider From Bethania

                             <a href="<?php echo base_url(); ?>slider/add"><input type="button" class="btn btn success" Value="Tambah Data">

                                        ID
                                    	SLider Title
                                    	Action

                                         <?php
                                        $no = 1 ;
                                        foreach ($show_slider as $content ) { ?>

                                        	<?php echo $no; ?>
                                            Preview

                                              <a class="btn btn-admin btn-info" href="<?php echo base_url(); ?>slider/edit/view/<?php echo $content->id_content;?>">Detail
                                              <a href="" type="button" class="btn btn-admin btn-info" data-toggle="modal" data-target="#delete_slider<?php echo $content->id_content;?>">Hapus

                                         <?php $no++;}?>

                       <?php $no = 1; foreach ($show_slider as $hapus_slider) { ?>
<div class="modal fade" id="delete_slider<?php echo $hapus_slider->id_content?>" role="dialog" >

      <button type="button" class="close" data-dismiss="modal">×</button>

Are you Sure Delete This Item ?

        <form action="<?php echo base_url(); ?>slider/delete/<?php echo $hapus_slider->id_content?>" method="POST" >
         <input type="text" id="hapus_gambar" name="hapus_gambar" class="hide" value="./assets/images/upload/slider1/<?php echo $hapus_slider->nama_file;?>">
        <button type="submit" class="btn btn-success button" >Yes,Iam Sure</button>
        </form>
        <button class="btn btn-danger button"data-dismiss="modal">No, Remove This Item</button>

 <button  id="deleteclose" class="btn btn-info button" data-dismiss="modal">Close</button>

<?php } ?>


text:
#include "tr/xqp/serial/deser.h"

#include "tr/xqp/visitor/ASTVisitor.h"
#include "ASTTypeSingle.h"

ASTTypeSingle::~ASTTypeSingle()
{
    delete type;
}

void ASTTypeSingle::accept(ASTVisitor &v)
{
    v.addToPath(this);
    v.visit(*this);
    v.removeFromPath(this);
}

ASTNode *ASTTypeSingle::dup()
{
    return new ASTTypeSingle(cd, type->dup(), mod);
}

ASTNode *ASTTypeSingle::createNode(scheme_list &sl)
{
    ASTNodeCommonData cd;
    ASTNode *type = NULL;
    OccurMod mod;

    U_ASSERT(sl[1].type == SCM_LIST && sl[2].type == SCM_LIST && sl[3].type == SCM_NUMBER);

    cd = dsGetASTCommonFromSList(*sl[1].internal.list);
    type = dsGetASTFromSchemeList(*sl[2].internal.list);
    mod = OccurMod(atol(sl[3].internal.num));

    return new ASTTypeSingle(cd, type, mod);
}

void ASTTypeSingle::modifyChild(const ASTNode *oldc, ASTNode *newc)
{
    if (type == oldc)
    {
        type = newc;
        return;
    }
}


text:
class RemoveSearchIndexesFromPeople < ActiveRecord::Migration[5.2]
  def change
    remove_index :people, name: :index_people_on_first_name, using: :gin
    remove_index :people, name: :index_people_on_last_name, using: :gin
    remove_index :people, name: :index_people_on_city, using: :gin
    remove_index :people, name: :index_people_on_state_name, using: :gin
    remove_index :people, name: :index_people_on_country_name, using: :gin

    disable_extension "btree_gin"
  end
end


text:
"""
xml2dict
Thunder Chen<nkchenz@gmail.com> 2007.9.1

Convert an XML string or file with XML data to a dict object.
http://code.google.com/p/xml2dict/
"""

from .xml2dict import XML2Dict, Dict2XML
from object_dict import object_dict

def xml2dict(data):
    """Turn XML into a dictionary."""
    converter = XML2Dict()
    if hasattr(data, 'read'):
        # Then it's a file.
        data = data.read()
    return converter.fromstring(data)

def dict2xml(data):
    """Turn a dictionary into XML."""
    converter = Dict2XML()
    return converter.tostring(data)

__all__ = [XML2Dict, Dict2XML, xml2dict, dict2xml, object_dict]


text:
<?php
require 'vendor/autoload.php';
require 'lib/SendGrid.php';
require 'lib/Client.php';

Dotenv::load(__DIR__);
$sendgrid_apikey = getenv('SG_KEY');
$sendgrid = new Client($sendgrid_apikey);

$api_key = "My API Key";
$scopes = array("mail.send", "alerts.create", "alerts.read");
$response = $sendgrid->api_keys->post($api_key, $scopes);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

/*

$start_date = "2015-12-01";
$response = $sendgrid->global_stats->get($start_date);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n\n");

$end_date = "2015-12-14";
$response = $sendgrid->global_stats->get($start_date, $end_date);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n\n");

$aggregated_by = "day";
$response = $sendgrid->global_stats->get($start_date, $end_date, $aggregated_by);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n\n");

$aggregated_by = "week";
$response = $sendgrid->global_stats->get($start_date, $end_date, $aggregated_by);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n\n");

$aggregated_by = "month";
$response = $sendgrid->global_stats->get($start_date, $end_date, $aggregated_by);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n\n");

$group_id = 70;
$email = 'example@example.com';
$response = $sendgrid->asm_suppressions->delete($group_id, $email);
print("Status Code: " . $response->getStatusCode() . "\n");

$group_id = 70;
$email = 'example@example.com';
$response = $sendgrid->asm_suppressions->post($group_id, $email);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$group_id = 70;
$email = array('example@example.com', 'example@example.com');
$response = $sendgrid->asm_suppressions->post($group_id, $email);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$response = $sendgrid->asm_groups->get();
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$response = $sendgrid->api_keys->post("Magic Key");
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$api_key_id = "Q5xdErWiSO6b8fYUgtYY8g";
$name = "My API Key 2";
$scopes = array("user.profile.read", "user.profile.update");
$response = $sendgrid->api_keys->put($api_key_id, $name, $scopes);
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$response = $sendgrid->api_keys->patch("<API Key ID>", "Magic Key Updated");
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$response = $sendgrid->api_keys->delete("<API Key ID>");
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

$response = $sendgrid->api_keys->get();
print("Status Code: " . $response->getStatusCode() . "\n");
print("Body: " . $response->getBody() . "\n");

*/


text:
/*** layout - shouldn't need to touch this ***/
._wHumanMsg_holder{display:none; position:absolute; left:0px; top:0px; width:100%; height:0px; font-size:0px; line-height:0px; text-align:center; z-index:999999999}
._wHumanMsg_outer{display:inline-block; position:relative;; z-index:999999999}
._wHumanMsg_bg{position:absolute; left:0px; top:0px; width:100%; height:100%;; z-index:999999999}
._wHumanMsg_msgHolder{position:relative;; z-index:999999999}
._wHumanMsg_msg, ._wHumanMsg_close{float:left;; z-index:999999999}

/*** styling ***/
._wHumanMsg_msgHolder{font-family:verdana;}
._wHumanMsg_bg{border-bottom-left-radius:5px; border-bottom-right-radius:5px; border:solid 1px; border-top:0px;}
._wHumanMsg_msg{padding:20px; font-size:12px; line-height:16px; font-weight:bold;}
._wHumanMsg_close{font-size:8px; line-height:8px; font-weight:bold; border-radius:5px; padding:4px; margin:5px 5px 0 0; cursor:pointer; }

/*** colors ***/
._wHumanMsg_color_red ._wHumanMsg_bg{background-color:#F79992; border-color:#CE6F6F;}
._wHumanMsg_color_red._wHumanMsg_outer{color:#9C2F2F;}
._wHumanMsg_color_red ._wHumanMsg_close{background-color:#9C2F2F; color:#F79992;}

._wHumanMsg_color_green ._wHumanMsg_bg{background-color:#CDE6AC; border-color:#A9DB66;}
._wHumanMsg_color_green._wHumanMsg_outer{color:#58792E;}
._wHumanMsg_color_green ._wHumanMsg_close{background-color:#58792E; color:#CDE6AC;}

._wHumanMsg_color_blue ._wHumanMsg_bg{background-color:#E5F6FE; border-color:#ADD9ED;}
._wHumanMsg_color_blue._wHumanMsg_outer{color:#4D9FBF;}
._wHumanMsg_color_blue ._wHumanMsg_close{background-color:#4D9FBF; color:#E5F6FE;}

._wHumanMsg_color_white ._wHumanMsg_bg{background-color:#FFFFFF; border-color:#E2E2E2;}
._wHumanMsg_color_white._wHumanMsg_outer{color:#454545;}
._wHumanMsg_color_white ._wHumanMsg_close{background-color:#454545; color:#FFFFFF;}

._wHumanMsg_color_black ._wHumanMsg_bg{background-color:#505050; border-color:#303030;}
._wHumanMsg_color_black._wHumanMsg_outer{color:#F3F3F3;}
._wHumanMsg_color_black ._wHumanMsg_close{background-color:#F3F3F3; color:#505050;}

._wHumanMsg_color_cream ._wHumanMsg_bg{background-color:#FBF7AA; border-color:#F9E98E;}
._wHumanMsg_color_cream._wHumanMsg_outer{color:#A27D35;}
._wHumanMsg_color_cream ._wHumanMsg_close{background-color:#A27D35; color:#FBF7AA;}

._wHumanMsg_color_yellow ._wHumanMsg_bg{background-color:#F9F2BA; border-color:#E9D315;}
._wHumanMsg_color_yellow._wHumanMsg_outer{color:#5B5316;}
._wHumanMsg_color_yellow ._wHumanMsg_close{background-color:#5B5316; color:#F9F2BA;}

._wHumanMsg_color_orange ._wHumanMsg_bg{background-color:#F87217; border-color:#E56717;}
._wHumanMsg_color_orange._wHumanMsg_outer{color:#9C2F2F;}
._wHumanMsg_color_orange ._wHumanMsg_close{background-color:#9C2F2F; color:#F87217;}

._wHumanMsg_color_plum ._wHumanMsg_bg{background-color:#B93B8F; border-color:#7E354D;}
._wHumanMsg_color_plum._wHumanMsg_outer{color:#F9B7FF;}
._wHumanMsg_color_plum ._wHumanMsg_close{background-color:#F9B7FF; color:#B93B8F;}


text:
'use strict';
const assert = require('assert');

it('should fail after timeout', done => {
	setTimeout(() => {
		assert(false);
	}, 10);
});


text:
package org.lwjgl.util.zstd;

import javax.annotation.*;

import java.nio.*;

import org.lwjgl.*;
import org.lwjgl.system.*;

import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.MemoryStack.*;

/**
 *
Layout

 *
 *

 * struct ZSTD_parameters {
 *     {@link ZSTDCompressionParameters ZSTD_compressionParameters} cParams;
 *     {@link ZSTDFrameParameters ZSTD_frameParameters} fParams;
 * }

 */
@NativeType("struct ZSTD_parameters")
public class ZSTDParameters extends Struct implements NativeResource {

    /** The struct size in bytes. */
    public static final int SIZEOF;

    /** The struct alignment in bytes. */
    public static final int ALIGNOF;

    /** The struct member offsets. */
    public static final int
        CPARAMS,
        FPARAMS;

    static {
        Layout layout = __struct(
            __member(ZSTDCompressionParameters.SIZEOF, ZSTDCompressionParameters.ALIGNOF),
            __member(ZSTDFrameParameters.SIZEOF, ZSTDFrameParameters.ALIGNOF)
        );

        SIZEOF = layout.getSize();
        ALIGNOF = layout.getAlignment();

        CPARAMS = layout.offsetof(0);
        FPARAMS = layout.offsetof(1);
    }

    /**
     * Creates a {@code ZSTDParameters} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be
     * visible to the struct instance and vice versa.
     *
     *
The created instance holds a strong reference to the container object.

     */
    public ZSTDParameters(ByteBuffer container) {
        super(memAddress(container), __checkContainer(container, SIZEOF));
    }

    @Override
    public int sizeof() { return SIZEOF; }

    /** @return a {@link ZSTDCompressionParameters} view of the {@code cParams} field. */
    @NativeType("ZSTD_compressionParameters")
    public ZSTDCompressionParameters cParams() { return ncParams(address()); }
    /** @return a {@link ZSTDFrameParameters} view of the {@code fParams} field. */
    @NativeType("ZSTD_frameParameters")
    public ZSTDFrameParameters fParams() { return nfParams(address()); }

    /** Copies the specified {@link ZSTDCompressionParameters} to the {@code cParams} field. */
    public ZSTDParameters cParams(@NativeType("ZSTD_compressionParameters") ZSTDCompressionParameters value) { ncParams(address(), value); return this; }
    /** Passes the {@code cParams} field to the specified {@link java.util.function.Consumer Consumer}. */
    public ZSTDParameters cParams(java.util.function.Consumer<ZSTDCompressionParameters> consumer) { consumer.accept(cParams()); return this; }
    /** Copies the specified {@link ZSTDFrameParameters} to the {@code fParams} field. */
    public ZSTDParameters fParams(@NativeType("ZSTD_frameParameters") ZSTDFrameParameters value) { nfParams(address(), value); return this; }
    /** Passes the {@code fParams} field to the specified {@link java.util.function.Consumer Consumer}. */
    public ZSTDParameters fParams(java.util.function.Consumer<ZSTDFrameParameters> consumer) { consumer.accept(fParams()); return this; }

    /** Initializes this struct with the specified values. */
    public ZSTDParameters set(
        ZSTDCompressionParameters cParams,
        ZSTDFrameParameters fParams
    ) {
        cParams(cParams);
        fParams(fParams);

        return this;
    }

    /**
     * Copies the specified struct data to this struct.
     *
     * @param src the source struct
     *
     * @return this struct
     */
    public ZSTDParameters set(ZSTDParameters src) {
        memCopy(src.address(), address(), SIZEOF);
        return this;
    }

    // -----------------------------------

    /** Returns a new {@code ZSTDParameters} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */
    public static ZSTDParameters malloc() {
        return wrap(ZSTDParameters.class, nmemAllocChecked(SIZEOF));
    }

    /** Returns a new {@code ZSTDParameters} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */
    public static ZSTDParameters calloc() {
        return wrap(ZSTDParameters.class, nmemCallocChecked(1, SIZEOF));
    }

    /** Returns a new {@code ZSTDParameters} instance allocated with {@link BufferUtils}. */
    public static ZSTDParameters create() {
        ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF);
        return wrap(ZSTDParameters.class, memAddress(container), container);
    }

    /** Returns a new {@code ZSTDParameters} instance for the specified memory address. */
    public static ZSTDParameters create(long address) {
        return wrap(ZSTDParameters.class, address);
    }

    /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */
    @Nullable
    public static ZSTDParameters createSafe(long address) {
        return address == NULL ? null : wrap(ZSTDParameters.class, address);
    }

    /**
     * Returns a new {@link ZSTDParameters.Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed.
     *
     * @param capacity the buffer capacity
     */
    public static ZSTDParameters.Buffer malloc(int capacity) {
        return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity);
    }

    /**
     * Returns a new {@link ZSTDParameters.Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed.
     *
     * @param capacity the buffer capacity
     */
    public static ZSTDParameters.Buffer calloc(int capacity) {
        return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity);
    }

    /**
     * Returns a new {@link ZSTDParameters.Buffer} instance allocated with {@link BufferUtils}.
     *
     * @param capacity the buffer capacity
     */
    public static ZSTDParameters.Buffer create(int capacity) {
        ByteBuffer container = __create(capacity, SIZEOF);
        return wrap(Buffer.class, memAddress(container), capacity, container);
    }

    /**
     * Create a {@link ZSTDParameters.Buffer} instance at the specified memory.
     *
     * @param address  the memory address
     * @param capacity the buffer capacity
     */
    public static ZSTDParameters.Buffer create(long address, int capacity) {
        return wrap(Buffer.class, address, capacity);
    }

    /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */
    @Nullable
    public static ZSTDParameters.Buffer createSafe(long address, int capacity) {
        return address == NULL ? null : wrap(Buffer.class, address, capacity);
    }

    // -----------------------------------

    /** Deprecated for removal in 3.4.0. Use {@link #malloc(MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters mallocStack() { return malloc(stackGet()); }
    /** Deprecated for removal in 3.4.0. Use {@link #calloc(MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters callocStack() { return calloc(stackGet()); }
    /** Deprecated for removal in 3.4.0. Use {@link #malloc(MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters mallocStack(MemoryStack stack) { return malloc(stack); }
    /** Deprecated for removal in 3.4.0. Use {@link #calloc(MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters callocStack(MemoryStack stack) { return calloc(stack); }
    /** Deprecated for removal in 3.4.0. Use {@link #malloc(int, MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters.Buffer mallocStack(int capacity) { return malloc(capacity, stackGet()); }
    /** Deprecated for removal in 3.4.0. Use {@link #calloc(int, MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters.Buffer callocStack(int capacity) { return calloc(capacity, stackGet()); }
    /** Deprecated for removal in 3.4.0. Use {@link #malloc(int, MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters.Buffer mallocStack(int capacity, MemoryStack stack) { return malloc(capacity, stack); }
    /** Deprecated for removal in 3.4.0. Use {@link #calloc(int, MemoryStack)} instead. */
    @Deprecated public static ZSTDParameters.Buffer callocStack(int capacity, MemoryStack stack) { return calloc(capacity, stack); }

    /**
     * Returns a new {@code ZSTDParameters} instance allocated on the specified {@link MemoryStack}.
     *
     * @param stack the stack from which to allocate
     */
    public static ZSTDParameters malloc(MemoryStack stack) {
        return wrap(ZSTDParameters.class, stack.nmalloc(ALIGNOF, SIZEOF));
    }

    /**
     * Returns a new {@code ZSTDParameters} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param stack the stack from which to allocate
     */
    public static ZSTDParameters calloc(MemoryStack stack) {
        return wrap(ZSTDParameters.class, stack.ncalloc(ALIGNOF, 1, SIZEOF));
    }

    /**
     * Returns a new {@link ZSTDParameters.Buffer} instance allocated on the specified {@link MemoryStack}.
     *
     * @param stack    the stack from which to allocate
     * @param capacity the buffer capacity
     */
    public static ZSTDParameters.Buffer malloc(int capacity, MemoryStack stack) {
        return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity);
    }

    /**
     * Returns a new {@link ZSTDParameters.Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param stack    the stack from which to allocate
     * @param capacity the buffer capacity
     */
    public static ZSTDParameters.Buffer calloc(int capacity, MemoryStack stack) {
        return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity);
    }

    // -----------------------------------

    /** Unsafe version of {@link #cParams}. */
    public static ZSTDCompressionParameters ncParams(long struct) { return ZSTDCompressionParameters.create(struct + ZSTDParameters.CPARAMS); }
    /** Unsafe version of {@link #fParams}. */
    public static ZSTDFrameParameters nfParams(long struct) { return ZSTDFrameParameters.create(struct + ZSTDParameters.FPARAMS); }

    /** Unsafe version of {@link #cParams(ZSTDCompressionParameters) cParams}. */
    public static void ncParams(long struct, ZSTDCompressionParameters value) { memCopy(value.address(), struct + ZSTDParameters.CPARAMS, ZSTDCompressionParameters.SIZEOF); }
    /** Unsafe version of {@link #fParams(ZSTDFrameParameters) fParams}. */
    public static void nfParams(long struct, ZSTDFrameParameters value) { memCopy(value.address(), struct + ZSTDParameters.FPARAMS, ZSTDFrameParameters.SIZEOF); }

    // -----------------------------------

    /** An array of {@link ZSTDParameters} structs. */
    public static class Buffer extends StructBuffer<ZSTDParameters, Buffer> implements NativeResource {

        private static final ZSTDParameters ELEMENT_FACTORY = ZSTDParameters.create(-1L);

        /**
         * Creates a new {@code ZSTDParameters.Buffer} instance backed by the specified container.
         *
         * Changes to the container's content will be visible to the struct buffer instance and vice versa. The two buffers' position, limit, and mark values
         * will be independent. The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer divided
         * by {@link ZSTDParameters#SIZEOF}, and its mark will be undefined.
         *
         *
The created buffer instance holds a strong reference to the container object.

         */
        public Buffer(ByteBuffer container) {
            super(container, container.remaining() / SIZEOF);
        }

        public Buffer(long address, int cap) {
            super(address, null, -1, 0, cap, cap);
        }

        Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) {
            super(address, container, mark, pos, lim, cap);
        }

        @Override
        protected Buffer self() {
            return this;
        }

        @Override
        protected ZSTDParameters getElementFactory() {
            return ELEMENT_FACTORY;
        }

        /** @return a {@link ZSTDCompressionParameters} view of the {@code cParams} field. */
        @NativeType("ZSTD_compressionParameters")
        public ZSTDCompressionParameters cParams() { return ZSTDParameters.ncParams(address()); }
        /** @return a {@link ZSTDFrameParameters} view of the {@code fParams} field. */
        @NativeType("ZSTD_frameParameters")
        public ZSTDFrameParameters fParams() { return ZSTDParameters.nfParams(address()); }

        /** Copies the specified {@link ZSTDCompressionParameters} to the {@code cParams} field. */
        public ZSTDParameters.Buffer cParams(@NativeType("ZSTD_compressionParameters") ZSTDCompressionParameters value) { ZSTDParameters.ncParams(address(), value); return this; }
        /** Passes the {@code cParams} field to the specified {@link java.util.function.Consumer Consumer}. */
        public ZSTDParameters.Buffer cParams(java.util.function.Consumer<ZSTDCompressionParameters> consumer) { consumer.accept(cParams()); return this; }
        /** Copies the specified {@link ZSTDFrameParameters} to the {@code fParams} field. */
        public ZSTDParameters.Buffer fParams(@NativeType("ZSTD_frameParameters") ZSTDFrameParameters value) { ZSTDParameters.nfParams(address(), value); return this; }
        /** Passes the {@code fParams} field to the specified {@link java.util.function.Consumer Consumer}. */
        public ZSTDParameters.Buffer fParams(java.util.function.Consumer<ZSTDFrameParameters> consumer) { consumer.accept(fParams()); return this; }

    }

}


text:
#include "config.h"
#include "QtPluginWidgetAdapter.h"

QtPluginWidgetAdapter::QtPluginWidgetAdapter()
{
}


text:
function Update () {
  transform.position.z += 0.3 ;

  if(transform.position.z > 14.5 )
  {
    Destroy(gameObject) ;
  }
}

function OnCollisionEnter(col : Collision) {
  if(col.gameObject.CompareTag('Enemy') || col.gameObject.tag == "Stone")
  {
    Destroy(gameObject) ;
  }
}


text:
package net.schmizz.sshj.xfer.scp;

import net.schmizz.sshj.connection.channel.direct.SessionFactory;
import net.schmizz.sshj.xfer.AbstractFileTransfer;
import net.schmizz.sshj.xfer.FileSystemFile;
import net.schmizz.sshj.xfer.FileTransfer;
import net.schmizz.sshj.xfer.LocalDestFile;
import net.schmizz.sshj.xfer.LocalSourceFile;

import java.io.IOException;

public class SCPFileTransfer
        extends AbstractFileTransfer
        implements FileTransfer {

    private final SessionFactory sessionFactory;

    public SCPFileTransfer(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public SCPDownloadClient newSCPDownloadClient() {
        return new SCPDownloadClient(newSCPEngine());
    }

    public SCPUploadClient newSCPUploadClient() {
        return new SCPUploadClient(newSCPEngine());
    }

    private SCPEngine newSCPEngine() {
        return new SCPEngine(sessionFactory, getTransferListener());
    }

    @Override
    public void upload(String localPath, String remotePath)
            throws IOException {
        newSCPUploadClient().copy(new FileSystemFile(localPath), remotePath);
    }

    @Override
    public void download(String remotePath, String localPath)
            throws IOException {
        download(remotePath, new FileSystemFile(localPath));
    }

    @Override
    public void download(String remotePath, LocalDestFile localFile)
            throws IOException {
        newSCPDownloadClient().copy(remotePath, localFile);
    }

    @Override
    public void upload(LocalSourceFile localFile, String remotePath)
            throws IOException {
        newSCPUploadClient().copy(localFile, remotePath);
    }

}


text:
swoole_server: getWorkerStatus
--SKIPIF--
<?php require __DIR__ . '/../include/skipif.inc'; ?>
--FILE--
<?php
require __DIR__ . '/../include/bootstrap.php';

$pm = new SwooleTest\ProcessManager;
$pm->parentFunc = function () use ($pm) {
    Co\run(function () use ($pm) {
        $client = new Co\Client(SWOOLE_SOCK_TCP);
        Assert::assert($client->connect('127.0.0.1', $pm->getFreePort()));
        Assert::assert($client->send('world'));

        $data = $client->recv();
        Assert::assert($data);
        $json = json_decode($data);
        Assert::assert($json);

        Assert::eq($json->current_worker, SWOOLE_WORKER_BUSY);
        Assert::eq($json->another_worker, SWOOLE_WORKER_IDLE);

        $pm->kill();
    });
};
$pm->childFunc = function () use ($pm) {
    $server = new Swoole\Server('127.0.0.1', $pm->getFreePort());
    $server->set([
        'worker_num' => 2,
        'log_file' => '/dev/null'
    ]);
    $server->on('workerStart', function (Swoole\Server $serv) use ($pm) {
        $pm->wakeup();
    });

    $server->on('receive', function (Swoole\Server $serv, int $fd, int $rid, string $data) {
        $serv->send($fd, json_encode([
            'current_worker' => $serv->getWorkerStatus(),
            'another_worker' => $serv->getWorkerStatus(1-$serv->getWorkerId()),
        ]));
    });

    $server->start();
};
$pm->childFirst();
$pm->run();
?>
--EXPECT--


text:
<?php

declare(strict_types=1);

namespace Unit\Tests\User\Domain\Model\VO;

use PHPUnit\Framework\TestCase;
use User\Domain\Exception\PasswordMustHaveDigitException;
use User\Domain\Exception\PasswordMustHaveSpecialCharactersException;
use User\Domain\Exception\PasswordMustHaveUpperException;
use User\Domain\Exception\PasswordMustReach8CharactersException;
use User\Domain\Model\VO\Password;

class PasswordTest extends TestCase
{
    final public function testCreateWithLessLongThrowADomainException(): void
    {
        // Arrange
        $this->expectException(PasswordMustReach8CharactersException::class);

        // Act, Assert
        Password::fromString('zaer');
    }

    final public function testCreateWithNoUpperThrowADomainException(): void
    {
        // Arrange
        $this->expectException(PasswordMustHaveUpperException::class);

        // Act, Assert
        Password::fromString('zaerty5rt');
    }

    final public function testCreateWithNoDigitThrowADomainException(): void
    {
        // Arrange
        $this->expectException(PasswordMustHaveDigitException::class);

        // Act, Assert
        Password::fromString('zaertyDghjP');
    }

    final public function testCreateWithNoSpecCharThrowADomainException(): void
    {
        // Arrange
        $this->expectException(PasswordMustHaveSpecialCharactersException::class);

        // Act, Assert
        Password::fromString('zaer5RTYJ5l');
    }
}


text:
"""This module contains utility functions for the Mythril support package."""
from typing import Dict
import logging
import _pysha3 as sha3

log = logging.getLogger(__name__)

class Singleton(type):
    """A metaclass type implementing the singleton pattern."""

    _instances = {}  # type: Dict

    def __call__(cls, *args, **kwargs):
        """Delegate the call to an existing resource or a a new one.

        This is not thread- or process-safe by default. It must be protected with
        a lock.

        :param args:
        :param kwargs:
        :return:
        """
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

def get_code_hash(code: str) -> str:
    """
    :param code: bytecode
    :return: Returns hash of the given bytecode
    """
    code = code[2:] if code[:2] == "0x" else code
    try:
        keccak = sha3.keccak_256()
        keccak.update(bytes.fromhex(code))
        return "0x" + keccak.hexdigest()
    except ValueError:
        log.debug("Unable to change the bytecode to bytes. Bytecode: {}".format(code))
        return ""


text:
"""
Integration testing the API endpoints of the ELMR app.
"""

##########################################################################
## Imports
##########################################################################

import elmr

from flask.ext.testing import TestCase

##########################################################################
## Test Cases
##########################################################################

EXPECTED_ENDPOINTS = {
    "heartbeat": "status",
    "series": "series",
    "sources": "source",
    "geography": "geo",
    "wealth of nations": "regions"
}

class APIListTests(TestCase):
    """
    Test the API list object
    """

    def create_app(self):
        elmr.app.config.from_object('elmr.config.TestingConfig')
        return elmr.app

    def get_endpoint(self, name):
        """
        Returns the computed API endpoint for a resource
        """
        return "http://localhost/api/%s/" % name

    def test_get_api_list(self):
        """
        Test that the api root returns an object
        """
        response = self.client.get("/api/")
        self.assertEquals(response.status_code, 200)

    def test_current_api_endpoint_list(self):
        """
        Test the response from the API root
        """
        response = self.client.get("/api/")
        self.assertEquals(response.status_code, 200)

        for key, val in EXPECTED_ENDPOINTS.items():
            self.assertIn(key, response.json)
            url = self.get_endpoint(val)
            self.assertEqual(response.json[key], url)

    def test_extra_api_endpoint_list(self):
        """
        Quick check for testing sanity, if anything isn't in expcted
        """
        response = self.client.get("/api/")
        self.assertEquals(response.status_code, 200)

        for key, val in response.json.items():
            self.assertIn(key, EXPECTED_ENDPOINTS)


text:
<?xml version="1.0" encoding="UTF-8"?>
<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="0"/>
    <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2">
        <group>
            <file>file:/D:/NetBeansProjects/MobileFilmstrip/src/js/viewModels/incidents.js</file>
            <file>file:/D:/NetBeansProjects/MobileFilmstrip/src/css/override.css</file>
            <file>file:/D:/NetBeansProjects/MobileFilmstrip/.gitignore</file>
            <file>file:/D:/NetBeansProjects/MobileFilmstrip/src/js/views/incidents.html</file>
            <file>file:/D:/NetBeansProjects/MobileFilmstrip/.npmignore</file>
        </group>
    </open-files>
</project-private>


text:
/**
 *
 */
package de.unibonn.iai.eis.irap.changeset;

import de.unibonn.iai.eis.irap.model.CMMethod;

/**
 * @author Kemele M. Endris
 *
 */
public interface ChangesetManager {

	public static final String LAST_DOWNLOAD = "../lastDownloadDate.dat";

	public static final int ERRORS_TO_ADVANCE = 5;

	public static final String EXTENSION_ADDED =  ".added.nt.gz";
	public static final String EXTENSION_REMOVED =  ".removed.nt.gz";
	public static final String EXTENSION_CLEAR = ".clear.nt.gz";
	public static final String EXTENSION_REINSERT = ".reinserted.nt.gz ";

	public static final String EXTENSION_ADDED_NT =  ".added.nt";
	public static final String EXTENSION_REMOVED_NT =  ".removed.nt";

	public void start(CMMethod cmMethod);

	public boolean end();

	public boolean setChangesetDownloadFolder(String folderurl);

	public void refreshChangesetAddress();

	public boolean deleteChangeset(String changesetId);

}


text:
package com.github.giantray.compositesSelectSql;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * declare if generate sql should has desc or asc order
 *
 * @author lizeyang
 *
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface SqlOrderType {

	public enum Order {
		/**
		 * When a group of things is listed or arranged in descending order,
		 * each thing is smaller or less important than the thing before it.
		 */
		DESC,
		/**
		 * If a group of things is arranged in ascending order, each thing is
		 * bigger, greater, or more important than the thing before it.
		 */
		ASC
	};

}


text:
package website

import "net/http"

// Assets contains project assets.
var Assets http.FileSystem = http.Dir("./assets")


text:
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.

using System;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Graphics.Containers;
using osu.Game.Graphics.UserInterface;
using osu.Game.Online;

namespace osu.Game.Overlays.BeatmapListing.Panels
{
    public class BeatmapPanelDownloadButton : BeatmapDownloadTrackingComposite
    {
        protected bool DownloadEnabled => button.Enabled.Value;

        /// <summary>
        /// Currently selected beatmap. Used to present the correct difficulty after completing a download.
        /// </summary>
        public readonly IBindable<BeatmapInfo> SelectedBeatmap = new Bindable<BeatmapInfo>();

        private readonly ShakeContainer shakeContainer;
        private readonly DownloadButton button;
        private Bindable<bool> noVideoSetting;

        public BeatmapPanelDownloadButton(BeatmapSetInfo beatmapSet)
            : base(beatmapSet)
        {
            InternalChild = shakeContainer = new ShakeContainer
            {
                RelativeSizeAxes = Axes.Both,
                Child = button = new DownloadButton
                {
                    RelativeSizeAxes = Axes.Both,
                },
            };

            button.Add(new DownloadProgressBar(beatmapSet)
            {
                Anchor = Anchor.BottomLeft,
                Origin = Anchor.BottomLeft,
                Depth = -1,
            });
        }

        protected override void LoadComplete()
        {
            base.LoadComplete();

            button.State.BindTo(State);
            FinishTransforms(true);
        }

        [BackgroundDependencyLoader(true)]
        private void load(OsuGame game, BeatmapManager beatmaps, OsuConfigManager osuConfig)
        {
            noVideoSetting = osuConfig.GetBindable<bool>(OsuSetting.PreferNoVideo);

            button.Action = () =>
            {
                switch (State.Value)
                {
                    case DownloadState.Downloading:
                    case DownloadState.Importing:
                        shakeContainer.Shake();
                        break;

                    case DownloadState.LocallyAvailable:
                        Predicate<BeatmapInfo> findPredicate = null;
                        if (SelectedBeatmap.Value != null)
                            findPredicate = b => b.OnlineBeatmapID == SelectedBeatmap.Value.OnlineBeatmapID;

                        game?.PresentBeatmap(BeatmapSet.Value, findPredicate);
                        break;

                    default:
                        beatmaps.Download(BeatmapSet.Value, noVideoSetting.Value);
                        break;
                }
            };

            State.BindValueChanged(state =>
            {
                switch (state.NewValue)
                {
                    case DownloadState.LocallyAvailable:
                        button.Enabled.Value = true;
                        button.TooltipText = "Go to beatmap";
                        break;

                    default:
                        if (BeatmapSet.Value?.OnlineInfo?.Availability?.DownloadDisabled ?? false)
                        {
                            button.Enabled.Value = false;
                            button.TooltipText = "this beatmap is currently not available for download.";
                        }

                        break;
                }
            }, true);
        }
    }
}


text:
<?php

class Credit extends Eloquent {

	protected $table = 'credits';
	public $timestamps = false;
	protected $softDelete = false;

}


text:
layout: page
title: Übersicht
permalink: "overview/de/overview/"
language: de
---

## OneConnexx - Enterprise Service Bus (ESB)

Der OneConnexx verbindet die unterschiedlichsten Applikationen und System sowohl innerhalb Ihrer IT Infrastruktur als auch mit den Systemen Ihrer Kunden bzw. Partner.
Der OneConnexx unterstützt Sie zudem mit diversen prozessunterstützenden Funktionen bei der Abwicklung Ihrer Geschäftsprozesse.

![x]({{ site.baseurl }}/assets/content-images/overview/de/overview.png "Übersicht")

## Konnektoren

Im Gegensatz zu anderen ESBs, bei denen die Umsysteme angepasst werden müssen, damit diese mit dem ESB kommunizieren können, stellt der OneConnexx Konnektoren zur Verfügung. Im obigen Diagramm sind die Konnektoren durch die grünen Pfeile dargestellt. Konnektoren sind in OneConnexx durch Add-Ins realisiert.
Für die gebräuchlichsten Kommunikationsprotokolle und einige Fremdsysteme sind in OneConnexx bereits Konnektoren enthalten (Liste nicht abschliessend):

* Datenbank (MS SQL Server)
* Dateisystem
* FTP, SFTP, FTPS, WebDAV, Amazon S3
* SOAP Web-Services
* E-Mail (SMTP)
* LDAP / Active Directory
* Microsoft SharePoint
* Bizagi
* OneOffixx

## Prozessunterstützende Funktionen

Bei der Datenverarbeitung und Prozessabwicklung werden oft auch prozessunterstützende Funktionen benötigt. Dazu gehört z.B. das Starten eines Prozesses zu vordefinierten Zeitpunkten oder sobald eine Datei in einem überwachten Verzeichnis abgelegt wird. Aber auch Datentransformationen oder das Versenden von E-Mails gehören in diese Kategorie von Funktionen.
OneConnexx bietet bereits viele prozessunterstützende Funktionen als Add-Ins an (Liste nicht abschliessend):

* Timer (Interval, täglich, wöchentlich, monatlich, jährlich)
* Verzeichnisse überwachen
* E-Mails versenden
* Dateien komprimieren / dekomprimieren
* XSL Transformationen
* Löschen von alten Dateien
* Überwachen der Servererreichbarkeit (Ping)

## Kundenspezifische Add-Ins

Gründe für kundenspezifische Entwicklungen sind vielseitig. Kundenspezifische Add-Ins enthalten oftmals kundenspezifische Geschäftslogik wie Validierung von Daten oder spezielle Transformationen. Solche sind mit Standard Add-Ins und dynamischer Konfiguration kaum oder nur mit erheblichem Aufwand zu bewerkstelligen. Auch die Anbindung an spezielle Umsysteme kann eine kundenspezifische Entwicklung erfordern.
Nebst den bereits vorhandenen Konnektoren und prozessunterstützenden Funktionen können wir ohne grossen Aufwand neue Add-Ins implementieren. Der Entwicklungsaufwand ist gering, da bei der Implementation auf eine Vielzahl von Basisfunktionen zurückgegriffen werden kann.
Durch unser Framework profitieren neu entwickelte Add-Ins automatisch von folgenden Basisfunktionen:

* Logging
* Überwachung der Ausführung
* Verknüpfen von Add-Ins über Ereignisse
* Konfiguration der Add-Ins über eine Webseite

## Abbilden von Prozessen durch Verknüpfen von Add-Ins

Durch Verknüpfen von Konnektoren und prozessunterstützenden Funktionen können komplexe Prozesse abgebildet werden. Ein möglicher Prozess wäre beispielsweise:

![x]({{ site.baseurl }}/assets/content-images/overview/de/process.png "Prozess")

Timer (z.B. am 1. jedes Monats) -> Exportieren von Benutzern aus dem Active Directory in eine CSV Datei -> Kopieren dieser CSV Datei auf einen FTP Server -> Informieren einer Person via E-Mail

## Administration und Management

Die Administration und Konfiguration des OneConnexx erfolgt über eine moderne Web-Applikation die mit jedem modernen Browser bedient werden kann. Die OneConnexx Web-Administration unterstützt sowohl bei der Konfiguration als auch im Betrieb bei der Auswertung der Log- und der Monitoringdaten.

#### Add-Ins konfigurieren

Add-Ins werden in der OneConnexx Web-Administration hinzugefügt, konfiguriert oder gelöscht. Add-Ins können ausserdem miteinander verknüpft werden. Die Web-Administration unterstützt den Benutzer dabei mit einer kurzen Beschreibung der Add-In Parameter und sorgt für eine fehlerfreie Konfiguration.

#### Log

Bei der Analyse von Problemen oder beim Umsetzen neuer Prozesse sind umfangreiche Protokolldateien unverzichtbar. Die Web-Administration bietet einerseits eine Echtzeitansicht und andererseits eine Auswertung der Vergangenheit mit detaillierten Filtermöglichkeiten.

#### Überwachung und Alarmierung

Die fehlerfreie Ausführung der konfigurierten Prozesse kann durch vielfältige Regeln überwacht werden. Es können E-Mails definiert werden, die bei Verletzung einer Regel an vordefinierte Empfänger versendet werden.


text:
<?php

/**
 * The "exclusions" collection of methods.
 * Typical usage is:
 *  <code>
 *   $loggingService = new Google_Service_Logging(...);
 *   $exclusions = $loggingService->exclusions;
 *  </code>
 */
class Google_Service_Logging_Resource_FoldersExclusions extends Google_Service_Resource
{
  /**
   * Creates a new exclusion in a specified parent resource. Only log entries
   * belonging to that resource can be excluded. You can have up to 10 exclusions
   * in a resource. (exclusions.create)
   *
   * @param string $parent Required. The parent resource in which to create the
   * exclusion: "projects/[PROJECT_ID]" "organizations/[ORGANIZATION_ID]"
   * "billingAccounts/[BILLING_ACCOUNT_ID]" "folders/[FOLDER_ID]" Examples:
   * "projects/my-logging-project", "organizations/123456789".
   * @param Google_Service_Logging_LogExclusion $postBody
   * @param array $optParams Optional parameters.
   * @return Google_Service_Logging_LogExclusion
   */
  public function create($parent, Google_Service_Logging_LogExclusion $postBody, $optParams = array())
  {
    $params = array('parent' => $parent, 'postBody' => $postBody);
    $params = array_merge($params, $optParams);
    return $this->call('create', array($params), "Google_Service_Logging_LogExclusion");
  }
  /**
   * Deletes an exclusion. (exclusions.delete)
   *
   * @param string $name Required. The resource name of an existing exclusion to
   * delete: "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"
   * "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"
   * "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"
   * "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]" Example: "projects/my-
   * project-id/exclusions/my-exclusion-id".
   * @param array $optParams Optional parameters.
   * @return Google_Service_Logging_LoggingEmpty
   */
  public function delete($name, $optParams = array())
  {
    $params = array('name' => $name);
    $params = array_merge($params, $optParams);
    return $this->call('delete', array($params), "Google_Service_Logging_LoggingEmpty");
  }
  /**
   * Gets the description of an exclusion. (exclusions.get)
   *
   * @param string $name Required. The resource name of an existing exclusion:
   * "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"
   * "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"
   * "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"
   * "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]" Example: "projects/my-
   * project-id/exclusions/my-exclusion-id".
   * @param array $optParams Optional parameters.
   * @return Google_Service_Logging_LogExclusion
   */
  public function get($name, $optParams = array())
  {
    $params = array('name' => $name);
    $params = array_merge($params, $optParams);
    return $this->call('get', array($params), "Google_Service_Logging_LogExclusion");
  }
  /**
   * Lists all the exclusions in a parent resource.
   * (exclusions.listFoldersExclusions)
   *
   * @param string $parent Required. The parent resource whose exclusions are to
   * be listed. "projects/[PROJECT_ID]" "organizations/[ORGANIZATION_ID]"
   * "billingAccounts/[BILLING_ACCOUNT_ID]" "folders/[FOLDER_ID]"
   * @param array $optParams Optional parameters.
   *
   * @opt_param string pageToken Optional. If present, then retrieve the next
   * batch of results from the preceding call to this method. pageToken must be
   * the value of nextPageToken from the previous response. The values of other
   * method parameters should be identical to those in the previous call.
   * @opt_param int pageSize Optional. The maximum number of results to return
   * from this request. Non-positive values are ignored. The presence of
   * nextPageToken in the response indicates that more results might be available.
   * @return Google_Service_Logging_ListExclusionsResponse
   */
  public function listFoldersExclusions($parent, $optParams = array())
  {
    $params = array('parent' => $parent);
    $params = array_merge($params, $optParams);
    return $this->call('list', array($params), "Google_Service_Logging_ListExclusionsResponse");
  }
  /**
   * Changes one or more properties of an existing exclusion. (exclusions.patch)
   *
   * @param string $name Required. The resource name of the exclusion to update:
   * "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"
   * "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"
   * "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"
   * "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]" Example: "projects/my-
   * project-id/exclusions/my-exclusion-id".
   * @param Google_Service_Logging_LogExclusion $postBody
   * @param array $optParams Optional parameters.
   *
   * @opt_param string updateMask Required. A non-empty list of fields to change
   * in the existing exclusion. New values for the fields are taken from the
   * corresponding fields in the LogExclusion included in this request. Fields not
   * mentioned in update_mask are not changed and are ignored in the request.For
   * example, to change the filter and description of an exclusion, specify an
   * update_mask of "filter,description".
   * @return Google_Service_Logging_LogExclusion
   */
  public function patch($name, Google_Service_Logging_LogExclusion $postBody, $optParams = array())
  {
    $params = array('name' => $name, 'postBody' => $postBody);
    $params = array_merge($params, $optParams);
    return $this->call('patch', array($params), "Google_Service_Logging_LogExclusion");
  }
}


text:
.center {
	text-align:center;
}

button.choice-food-burger {
	background-image: url(../img/food-burger.png) !important;
}

button.choice-food-pizza {
	background-image: url(../img/food-pizza.png) !important;
}

.custom-ionic {
  background-image: url(../img/ionic.png);
}

/***************************
Override Button Styles Here
***************************/

/***************************
.button.irk-button-step-previous,
.button.irk-button-step-cancel,
.button.irk-button-step-next,
.button.irk-button-step-skip {
	border-color: #cccccc;
	background-color: #cccccc;
	color: #fff;
}
.button.irk-button-step-previous:hover,
.button.irk-button-step-cancel:hover,
.button.irk-button-step-next:hover,
.button.irk-button-step-skip:hover {
	color: #fff;
	text-decoration: none;
}
.button.irk-button-step-previous.active, .button.irk-button-step-previous.activated,
.button.irk-button-step-cancel.active, .button.irk-button-step-cancel.activated,
.button.irk-button-step-next.active, .button.irk-button-step-next.activated,
.button.irk-button-step-skip.active, .button.irk-button-step-skip.activated {
	border-color: #cccccc;
	background-color: #cccccc;
	box-shadow: inset 0 1px 4px rgba(0, 0, 0, 0.1);
}
.button.irk-button-step-previous.button-clear,
.button.irk-button-step-cancel.button-clear,
.button.irk-button-step-next.button-clear,
.button.irk-button-step-skip.button-clear {
	border-color: transparent;
	background: none;
	box-shadow: none;
	color: #cccccc;
}
.button.irk-button-step-previous.button-icon,
.button.irk-button-step-cancel.button-icon,
.button.irk-button-step-next.button-icon,
.button.irk-button-step-skip.button-icon {
	border-color: transparent;
	background: none;
}
.button.irk-button-step-previous.button-outline,
.button.irk-button-step-cancel.button-outline,
.button.irk-button-step-next.button-outline,
.button.irk-button-step-skip.button-outline {
	border-color: #cccccc;
	background: transparent;
	color: #cccccc;
}
.button.irk-button-step-previous.button-outline.active, .button.irk-button-step-previous.button-outline.activated,
.button.irk-button-step-cancel.button-outline.active, .button.irk-button-step-cancel.button-outline.activated,
.button.irk-button-step-next.button-outline.active, .button.irk-button-step-next.button-outline.activated,
.button.irk-button-step-skip.button-outline.active, .button.irk-button-step-skip.button-outline.activated {
	background-color: #cccccc;
	box-shadow: none;
	color: #fff;
}
***************************/


text:
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');

// ------------------------------------------------------------------------

/**
 * CodeIgniter Email Helpers
 *
 * @package		CodeIgniter
 * @subpackage	Helpers
 * @category	Helpers
 * @author		ExpressionEngine Dev Team
 * @link		http://codeigniter.com/user_guide/helpers/email_helper.html
 */

// ------------------------------------------------------------------------

/**
 * Validate email address
 *
 * @access	public
 * @return	bool
 */
if ( ! function_exists('valid_email'))
{
	function valid_email($address)
	{
		return ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $address)) ? FALSE : TRUE;
	}
}

// ------------------------------------------------------------------------

/**
 * Send an email
 *
 * @access	public
 * @return	bool
 */
if ( ! function_exists('send_email'))
{
	function send_email($recipient, $subject = 'Test email', $message = 'Hello World')
	{
		return @mail($recipient, $subject, $message);
	}
}

/* End of file email_helper.php */
/* Location: ./system/helpers/email_helper.php */


text:
Chocolatey sources for pure GHC installs

This repository contains the sources for the GHC Chocolatey packages.

To use these get Chocolatey https://chocolatey.org/

and then just install the version of GHC you want.

    cinst ghc

for the latest version

    cinst ghc -pre

for the latest pre-release version

    cinst ghc -version 7.8.4

for  specific version, e.g. `7.8.4`

The installer will automatically pick the right bitness for your OS, but if you would
like to force it to get `x86` on `x86_64` you can:

    cinst ghc -x86

The installer will also always install in `C:\ghc` if this is a problem create an issue and I will
attempt to address it.

uninstalling can be done with

    cuninst ghc

If more than one version of `GHC` is present then you will be presented with prompt on which version you
would like to install.

     Note: You need to run `refreshenv` or restart your console before ghc is available.


text:
using System;
using Xunit;

namespace SingletonVsStatic.SingletonLib.Tests
{
    public class SingletonCache_Tests
    {
        private readonly SingletonCache _singletonCache;

        public SingletonCache_Tests()
        {
            _singletonCache = new SingletonCache();

            _singletonCache.Add("TestKey1", "TestValue1");
            _singletonCache.Add("TestKey2", "TestValue2");
        }

        [Fact]
        public void Should_Contain_Initial_Values()
        {
            Assert.Equal(2, _singletonCache.GetCount());

            Assert.Equal("TestValue1", _singletonCache.GetOrNull("TestKey1"));
            Assert.Equal("TestValue2", _singletonCache.GetOrNull("TestKey2"));
        }

        [Fact]
        public void Should_Add_And_Get_Values()
        {
            _singletonCache.Add("MyNumber", 42);

            Assert.Equal(42, _singletonCache.GetOrNull("MyNumber"));
        }

        [Fact]
        public void Should_Increase_Count_When_A_New_Item_Added()
        {
            Assert.Equal(2, _singletonCache.GetCount());

            _singletonCache.Add("TestKeyX", "X");

            Assert.Equal(3, _singletonCache.GetCount());
        }

        [Fact]
        public void Clear_Should_Delete_All_Values()
        {
            _singletonCache.Clear();

            Assert.Equal(0, _singletonCache.GetCount());
            Assert.Null(_singletonCache.GetOrNull("TestKey1"));
        }

        [Fact]
        public void Should_Remove_Values()
        {
            _singletonCache.Remove("TestKey1");

            Assert.Null(_singletonCache.GetOrNull("TestKey1"));
        }

        [Fact]
        public void Should_Use_Factory_Only_If_The_Value_Was_Not_Present()
        {
            //The key is already present, so it doesn't use the factory to create a new one
            Assert.Equal("TestValue1", _singletonCache.GetOrAdd("TestKey1", () => "TestValue1_Changed"));

            _singletonCache.Remove("TestKey1");

            //The key is not present, so it uses the factory to create a new one
            Assert.Equal("TestValue1_Changed", _singletonCache.GetOrAdd("TestKey1", () => "TestValue1_Changed"));
        }

        [Fact]
        public void GetOrThrowException_Should_Throw_Exception_For_Unknown_Keys()
        {
            Assert.Throws<ApplicationException>(() =>
            {
                _singletonCache.GetOrThrowException("UnknownKey");
            });
        }
    }
}


text:
var sinon = require('sinon')
  , EventEmitter = require('events').EventEmitter
  , TestDom = require('../../test_dom')
  , Controller = require('../../../src/remark/controllers/defaultController')
  ;

describe('Controller', function () {
  describe('initial navigation', function () {
    it('should naviate to first slide when slideshow is embedded ', function () {
      createController({embedded: true});

      events.emit.should.be.calledWithExactly('gotoSlide', 1);
    });

    it('should naviate by hash when slideshow is not embedded', function () {
      dom.getLocationHash = function () { return '#2'; };

      createController({embedded: false});

      events.emit.should.be.calledWithExactly('gotoSlide', '2');
    });
  });

  describe('hash change', function () {
    it('should not navigate by hash when slideshow is embedded', function () {
      createController({embedded: true});

      dom.getLocationHash = function () { return '#3'; };
      events.emit('hashchange');

      events.emit.should.not.be.calledWithExactly('gotoSlide', '3');
    });

    it('should navigate by hash when slideshow is not embedded', function () {
      createController({embedded: false});

      dom.getLocationHash = function () { return '#3'; };
      events.emit('hashchange');

      events.emit.should.be.calledWithExactly('gotoSlide', '3');
    });
  });

  describe('keyboard navigation', function () {
    it('should navigate to previous slide when pressing page up', function () {
      events.emit('keydown', {keyCode: 33});

      events.emit.should.be.calledWithExactly('gotoPreviousSlide');
    });

    it('should navigate to previous slide when pressing arrow left', function () {
      events.emit('keydown', {keyCode: 37});

      events.emit.should.be.calledWithExactly('gotoPreviousSlide');
    });

    it('should navigate to previous slide when pressing arrow up', function () {
      events.emit('keydown', {keyCode: 38});

      events.emit.should.be.calledWithExactly('gotoPreviousSlide');
    });

    it('should navigate to next slide when pressing space', function () {
      events.emit('keydown', {keyCode: 32});

      events.emit.should.be.calledWithExactly('gotoNextSlide');
    });

    it('should navigate to next slide when pressing page down', function () {
      events.emit('keydown', {keyCode: 34});

      events.emit.should.be.calledWithExactly('gotoNextSlide');
    });

    it('should navigate to next slide when pressing arrow right', function () {
      events.emit('keydown', {keyCode: 39});

      events.emit.should.be.calledWithExactly('gotoNextSlide');
    });

    it('should navigate to next slide when pressing arrow down', function () {
      events.emit('keydown', {keyCode: 39});

      events.emit.should.be.calledWithExactly('gotoNextSlide');
    });

    it('should navigate to first slide when pressing home', function () {
      events.emit('keydown', {keyCode: 36});

      events.emit.should.be.calledWithExactly('gotoFirstSlide');
    });

    it('should navigate to last slide when pressing end', function () {
      events.emit('keydown', {keyCode: 35});

      events.emit.should.be.calledWithExactly('gotoLastSlide');
    });

    beforeEach(function () {
      createController();
    });
  });

  describe('commands', function () {
    it('should toggle blackout mode when pressing "b"', function () {
      events.emit('keypress', {which: 98});
      events.emit.should.be.calledWithExactly('toggleBlackout');
    });

    it('should toggle mirrored mode when pressing "m"', function () {
      events.emit('keypress', {which: 109});
      events.emit.should.be.calledWithExactly('toggleMirrored');
    });

    beforeEach(function () {
      createController();
    });
  });

  describe('custom controller', function () {
    it('should do nothing when pressing page up', function () {
      events.emit('keydown', {keyCode: 33});

      events.emit.should.not.be.calledWithExactly('gotoPreviousSlide');
    });

    beforeEach(function () {
      controller = function() {};
    });
  });

  var events
    , dom
    , controller
    ;

  function createController (options) {
    options = options || {embedded: false};

    controller = new Controller(events, dom, {
      isEmbedded: function () { return options.embedded; }
    });
  }

  beforeEach(function () {
    events = new EventEmitter();
    sinon.spy(events, 'emit');

    dom = new TestDom();
  });

  afterEach(function () {
    events.emit.restore();
  });
});


text:
/**
 *
 */
package com.mcac0006.siftscience.event.domain;

import java.util.Arrays;

import org.codehaus.jackson.annotate.JsonProperty;

import com.mcac0006.siftscience.types.Address;
import com.mcac0006.siftscience.types.PaymentMethod;
import com.mcac0006.siftscience.types.SocialSignOnType;

/**
 *
 * Use {@link UpdateAccount} to record changes to the user's account information. For user accounts created
 * prior to integrating with Sift, there's no need to call {@link CreateAccount} before {@link UpdateAccount}.
 * Simply call {@link UpdateAccount} and we'll infer that account was created before integration.
 *
 * @author Matthew Cachia
 *
 */
public class UpdateAccount extends Event {

	/**
	 * The user's account ID according to your systems. Use the same ID that you would use to look up users
	 * on your website's databases. This field is required on all events performed by the user while logged in.
	 * Users without an assigned {@link #userId} will not show up in the console. Note: User IDs are
	 * case sensitive. You may need to normalize the capitalization of your user IDs.
	 */
	@JsonProperty("$user_id")
	private String userId;

	/**
	 * If the user changed their password, set this field and mark as {@link Boolean#TRUE}.
	 */
	@JsonProperty("$changed_password")
	private Boolean changedPassword;

	@JsonProperty("$user_email")
	private String userEmail;

	/**
	 * Provide the full name of the user here. Concatenate first name and last name together if you collect
	 * them separately in your system.
	 */
	@JsonProperty("$name")
	private String name;

	/**
	 * The primary phone number of the user associated with this account. Provide the phone number as a string,
	 * starting with the country code. For example: "1-415-555-6041".
	 */
	@JsonProperty("$phone")
	private String phone;

	/**
	 * The ID of the user that referred the current user to your business. This field is required for detecting
	 * referral fraud. Note: User IDs are case sensitive. You may need to normalize the capitalization of your
	 * user IDs.
	 */
	@JsonProperty("$referrer_user_id")
	private String referrerUserId;

	/**
	 * The payment information associated with this order. Represented as an array of nested {@link PaymentMethod}
	 * objects containing payment type, payment gateway, credit card bin, etc.
	 */
	@JsonProperty("$payment_methods")
	private PaymentMethod[] paymentMethods;

	/**
	 * The billing address as entered by the user. Represented as a nested {@link Address} object.
	 */
	@JsonProperty("$billing_address")
	private Address billingAddress;

	/**
	 * Provide the name of the social identity provider (e.g., $twitter, $facebook) in this field if the user
	 * uses them to log in to their account.
	 */
	@JsonProperty("$social_sign_on_type")
	private SocialSignOnType socialSignOnType;

	public UpdateAccount() {
		super("$update_account");
	}

	public String getUserId() {
		return userId;
	}

	public Boolean getChangedPassword() {
		return changedPassword;
	}

	public String getUserEmail() {
		return userEmail;
	}

	public String getName() {
		return name;
	}

	public String getPhone() {
		return phone;
	}

	public String getReferrerUserId() {
		return referrerUserId;
	}

	public PaymentMethod[] getPaymentMethods() {
		return paymentMethods;
	}

	public Address getBillingAddress() {
		return billingAddress;
	}

	public SocialSignOnType getSocialSignOnType() {
		return socialSignOnType;
	}

	public UpdateAccount setUserId(String userId) {
		this.userId = userId;
		return this;
	}

	public UpdateAccount setChangedPassword(Boolean changedPassword) {
		this.changedPassword = changedPassword;
		return this;
	}

	public UpdateAccount setUserEmail(String userEmail) {
		this.userEmail = userEmail;
		return this;
	}

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

	public UpdateAccount setPhone(String phone) {
		this.phone = phone;
		return this;
	}

	public UpdateAccount setReferrerUserId(String referrerUserId) {
		this.referrerUserId = referrerUserId;
		return this;
	}

	public UpdateAccount setPaymentMethods(PaymentMethod[] paymentMethods) {
		this.paymentMethods = paymentMethods;
		return this;
	}

	public UpdateAccount setBillingAddress(Address billingAddress) {
		this.billingAddress = billingAddress;
		return this;
	}

	public UpdateAccount setSocialSignOnType(SocialSignOnType socialSignOnType) {
		this.socialSignOnType = socialSignOnType;
		return this;
	}

	@Override
	public boolean equals(Object obj) {

		if (!super.equals(obj)) {
			return false;
		}

		if (obj == null || !(obj instanceof UpdateAccount)) {
			return false;
		}

		final UpdateAccount ua = (UpdateAccount)obj;

		if (this.billingAddress == null) {
			if (ua.getBillingAddress() != null) {
				return false;
			}
		} else if (!this.billingAddress.equals(ua.getBillingAddress())) {
			return false;
		}

		if (this.name == null) {
			if (ua.getName() != null) {
				return false;
			}
		} else if (!this.name.equals(ua.getName())) {
			return false;
		}

		if (this.paymentMethods == null) {
			if (ua.getPaymentMethods() != null) {
				return false;
			}
		} else if (!Arrays.equals(this.paymentMethods, ua.getPaymentMethods())) {
			return false;
		}

		if (this.phone == null) {
			if (ua.getPhone() != null) {
				return false;
			}
		} else if (!this.phone.equals(ua.getPhone())) {
			return false;
		}

		if (this.referrerUserId == null) {
			if (ua.getReferrerUserId() != null) {
				return false;
			}
		} else if (!this.referrerUserId.equals(ua.getReferrerUserId())) {
			return false;
		}

		if (this.socialSignOnType == null) {
			if (ua.getSocialSignOnType() != null) {
				return false;
			}
		} else if (!this.socialSignOnType.equals(ua.getSocialSignOnType())) {
			return false;
		}

		if (this.userEmail == null) {
			if (ua.getUserEmail() != null) {
				return false;
			}
		} else if (!this.userEmail.equals(ua.getUserEmail())) {
			return false;
		}

		if (this.userId == null) {
			if (ua.getUserId() != null) {
				return false;
			}
		} else if (!this.userId.equals(ua.getUserId())) {
			return false;
		}

		if (this.changedPassword == null) {
			if (ua.getChangedPassword() != null) {
				return false;
			}
		} else if (!this.changedPassword.equals(ua.getChangedPassword())) {
			return false;
		}

		if (this.socialSignOnType == null) {
			if (ua.getSocialSignOnType() != null) {
				return false;
			}
		} else if (!this.socialSignOnType.equals(ua.getSocialSignOnType())) {
			return false;
		}

		return true;

	}
}


text:
#include <aws/rbin/model/ResourceType.h>
#include <aws/core/utils/HashingUtils.h>
#include <aws/core/Globals.h>
#include <aws/core/utils/EnumParseOverflowContainer.h>

using namespace Aws::Utils;

namespace Aws
{
  namespace RecycleBin
  {
    namespace Model
    {
      namespace ResourceTypeMapper
      {

        static const int EBS_SNAPSHOT_HASH = HashingUtils::HashString("EBS_SNAPSHOT");
        static const int EC2_IMAGE_HASH = HashingUtils::HashString("EC2_IMAGE");

        ResourceType GetResourceTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == EBS_SNAPSHOT_HASH)
          {
            return ResourceType::EBS_SNAPSHOT;
          }
          else if (hashCode == EC2_IMAGE_HASH)
          {
            return ResourceType::EC2_IMAGE;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ResourceType>(hashCode);
          }

          return ResourceType::NOT_SET;
        }

        Aws::String GetNameForResourceType(ResourceType enumValue)
        {
          switch(enumValue)
          {
          case ResourceType::EBS_SNAPSHOT:
            return "EBS_SNAPSHOT";
          case ResourceType::EC2_IMAGE:
            return "EC2_IMAGE";
          default:
            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
            if(overflowContainer)
            {
              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
            }

            return {};
          }
        }

      } // namespace ResourceTypeMapper
    } // namespace Model
  } // namespace RecycleBin
} // namespace Aws


text:
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <objectAnimator
        android:duration="5000"
        android:propertyName="trimPathStart"
        android:repeatCount="infinite"
        android:repeatMode="restart"
        android:valueFrom="1"
        android:valueTo="0" />
    <objectAnimator
        android:duration="5000"
        android:propertyName="strokeColor"
        android:repeatCount="infinite"
        android:repeatMode="restart"
        android:valueFrom="@color/colorAccent"
        android:valueTo="@color/colorPrimaryDark" />
</set>


text:
package dominio;

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

import ataques.*;
import castas.*;
import habilidades.Fuerza;
import habilidades.Velocidad;
import items.*;
import razas.*;

public class PersonajeTest {

	 @Test
	 public void constructorTest(){
		Personaje h = new Humano("Humanito 1");
		h.setClase(new Guerrero());

		Personaje e = new Elfo("Elfito 2");
		e.setClase(new Hechicero());

		Personaje o = new Orco("Orquito 3");
		o.setClase(new Chaman());

		// Humano - Valores estandar de Ataque (10) , Defensa (10) y Magia (0)
		Assert.assertEquals("Humanito 1", h.getNombre());
		Assert.assertEquals("HUMANO",h.getRaza());
		Assert.assertEquals("GUERRERO", h.getClase().getNombre());
		Assert.assertEquals(100,h.getVida());
		Assert.assertEquals(0,h.getExperiencia());
		Assert.assertEquals(15,h.calcularPuntosDeAtaque());
		Assert.assertEquals(5,h.calcularPuntosDeDefensa());
		Assert.assertEquals(0,h.calcularPuntosDeMagia());
		Assert.assertEquals(0, h.getMochila().size());

		// Elfo - Valores estandar de Ataque (5) , Defensa (5) y Magia (10)
		Assert.assertEquals("Elfito 2", e.getNombre());
		Assert.assertEquals("ELFO", e.getRaza());
		Assert.assertEquals("HECHICERO", e.getClase().getNombre());
		Assert.assertEquals(1, e.getNivel());
		Assert.assertEquals(6,e.calcularPuntosDeAtaque());
		Assert.assertEquals(4,e.calcularPuntosDeDefensa());
		Assert.assertEquals(10,e.calcularPuntosDeMagia());
		Assert.assertEquals(0, h.getMochila().size());

		// Orco - Valores estandar de Ataque (12) , Defensa (5) y Magia (3)
		Assert.assertEquals("Orquito 3", o.getNombre());
		Assert.assertEquals("ORCO", o.getRaza());
		Assert.assertEquals("CHAMAN", o.getClase().getNombre());
		Assert.assertEquals(5,o.calcularPuntosDeDefensa());
		Assert.assertEquals(3,o.calcularPuntosDeMagia());
		Assert.assertEquals(12, o.calcularPuntosDeAtaque());
		Assert.assertEquals(0, h.getMochila().size());
	 }

	 @Test
	 public void personajeEquipadoYDesequipadoTest(){
		 Personaje h = new Humano("Humanito 1");
		 h.agregarItem(new EspadaDeAragorn());
		 h.agregarItem(new ArmaduraDeAzorAhai());

		 /*
		  * Compruebo de tener 2 items en mi mochila
		  * */
		 Assert.assertEquals(2, h.getMochila().size());

		 /*
		  * Quito el item y compruebo que sea el de mayor prioridad
		  * */
		 Item item = h.dejarItem();
		 Assert.assertEquals(1, h.getMochila().size());
		 Assert.assertEquals("Espada de Aragorn", item.getNombre());
	 }

	 @Test
	 public void clonarPersonajeSimpleConAtaquesYEquipamientoTest() throws CloneNotSupportedException{
		/*
		 * Armo un personaje con experiencia
		 * */
		Personaje p1 = new Humano("Lero");
		p1.setClase(new Hechicero());
		p1.setNivel(3);
		p1.setExperiencia(440);
		p1.setPuedeAgregarAtaque(1);
		p1.agregarAtaque(new CuerpoACuerpo());
		p1.agregarItem(new ArmaduraDeAzorAhai());

		/*
		 * Clono y comparo
		 * */
		Personaje p2 = new Humano(p1);

		/*
		 * Atributos propios de personaje
		 * */
		Assert.assertEquals(p1.getVida(), p2.getVida());
		Assert.assertEquals(p1.getExperiencia(), p2.getExperiencia());
		/*
		 * Atributos básicos
		 * */
		Assert.assertEquals(p1.calcularPuntosDeAtaque(), p2.calcularPuntosDeAtaque());
		Assert.assertEquals(p1.calcularPuntosDeDefensa(), p2.calcularPuntosDeDefensa());
		Assert.assertEquals(p1.calcularPuntosDeMagia(), p2.calcularPuntosDeMagia());
		Assert.assertEquals(p1.getPotencia(), p2.getPotencia());
		Assert.assertEquals(p1.getVelocidad(), p2.getVelocidad());
		Assert.assertEquals(p1.getDestreza(), p2.getDestreza());

		/*
		 * Casta y Raza
		 * */
		Assert.assertEquals(p1.getRaza(), p2.getRaza());
		Assert.assertEquals(p1.getClase(), p2.getClase());

		/*
		 * Mapa de ataques
		 * */
		Assert.assertEquals(p1.getAtaques(), p2.getAtaques());

		/*
		 * Items
		 * */
		Assert.assertEquals(1, p1.mochila.size());
		Assert.assertEquals(p1.mochila.size(), p2.mochila.size());

		/*
		 * Habilidades
		 * */
		Assert.assertEquals(p1.getClase().getHabilidades(), p2.getClase().getHabilidades());

		/*
		 * Puntajes
		 * */
		Assert.assertEquals(p1.getPuedeAgregarAtaque(), p2.getPuedeAgregarAtaque());
		Assert.assertEquals(p1.getPuntos(), p2.getPuntos());

	}

	 @Test
		public void clonarPersonajeConItemsConAtaquesConHabilidadesTest() throws CloneNotSupportedException{
			/*
			 * Armo un personaje con habilidades, ataques e items
			 * */
			Personaje p1 = new Humano("Lero");
			p1.setClase(new Hechicero());
			p1.setNivel(3);
			p1.setExperiencia(440);
			p1.setPuedeAgregarAtaque(1);
			p1.agregarAtaque(new CuerpoACuerpo());
			p1.setPuntos(2);
			p1.getClase().agregarHabilidad(new Velocidad());
			p1.getClase().getHabilidades().get(6).afectar(p1);
			p1.getClase().agregarHabilidad(new Fuerza());
			p1.getClase().getHabilidades().get(3).afectar(p1);
			p1.agregarItem(new ArmaduraDeAzorAhai());

			/*
			 * Clono y comparo
			 * */
			Personaje p2 = p1;

			/*
			 * Atributos propios de personaje
			 * */
			Assert.assertEquals(p1.getVida(), p2.getVida());
			Assert.assertEquals(p1.getExperiencia(), p2.getExperiencia());
			/*
			 * Atributos básicos
			 * */
			Assert.assertEquals(p1.calcularPuntosDeAtaque(), p2.calcularPuntosDeAtaque());
			Assert.assertEquals(p1.calcularPuntosDeDefensa(), p2.calcularPuntosDeDefensa());
			Assert.assertEquals(p1.calcularPuntosDeMagia(), p2.calcularPuntosDeMagia());
			Assert.assertEquals(p1.getPotencia(), p2.getPotencia());
			Assert.assertEquals(p1.getVelocidad(), p2.getVelocidad());
			Assert.assertEquals(p1.getDestreza(), p2.getDestreza());
			/*
			 * Casta y Raza
			 * */
			Assert.assertEquals(p1.getRaza(), p2.getRaza());
			Assert.assertEquals(p1.getClase(), p2.getClase());
			/*
			 * Mapa de ataques
			 * */
			Assert.assertEquals(p1.getAtaques(), p2.getAtaques());
			/*
			 * Habilidades
			 * */
			Assert.assertEquals(p1.getClase().getHabilidades(), p2.getClase().getHabilidades());
			/*
			 * Puntajes
			 * */
			Assert.assertEquals(p1.getPuedeAgregarAtaque(), p2.getPuedeAgregarAtaque());
			Assert.assertEquals(p1.getPuntos(), p2.getPuntos());

			//p2.setNivel(5);
		}

}


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

import com.facebook.presto.spi.ConnectorTableHandle;
import com.facebook.presto.spi.SchemaTableName;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

import java.util.Objects;

import static com.facebook.presto.metadata.MetadataUtil.checkSchemaName;
import static com.facebook.presto.metadata.MetadataUtil.checkTableName;
import static com.google.common.base.Preconditions.checkNotNull;

public class SystemTableHandle
        implements ConnectorTableHandle
{
    private final String schemaName;
    private final String tableName;

    @JsonCreator
    public SystemTableHandle(@JsonProperty("schemaName") String schemaName, @JsonProperty("tableName") String tableName)
    {
        this.schemaName = checkSchemaName(schemaName);
        this.tableName = checkTableName(tableName);
    }

    public SystemTableHandle(SchemaTableName tableName)
    {
        checkNotNull(tableName, "tableName is null");
        this.schemaName = tableName.getSchemaName();
        this.tableName = tableName.getTableName();
    }

    @JsonProperty
    public String getSchemaName()
    {
        return schemaName;
    }

    @JsonProperty
    public String getTableName()
    {
        return tableName;
    }

    public SchemaTableName getSchemaTableName()
    {
        return new SchemaTableName(schemaName, tableName);
    }

    @Override
    public String toString()
    {
        return "system:" + schemaName + "." + tableName;
    }

    @Override
    public int hashCode()
    {
        return Objects.hash(schemaName, tableName);
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final SystemTableHandle other = (SystemTableHandle) obj;
        return Objects.equals(this.schemaName, other.schemaName) &&
                Objects.equals(this.tableName, other.tableName);
    }
}