text:
package org.apache.camel.component.aws2.ddb;

import org.apache.camel.test.junit5.CamelTestSupport;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class DdbComponentRegistryClientTest extends CamelTestSupport {

    @Test
    public void createEndpointWithRegistryClient() throws Exception {
        AmazonDDBClientMock ddbClient = new AmazonDDBClientMock();
        context.getRegistry().bind("ddbClient", ddbClient);
        Ddb2Component component = context.getComponent("aws2-ddb", Ddb2Component.class);
        Ddb2Endpoint endpoint = (Ddb2Endpoint)component.createEndpoint("aws2-ddb://myTable");

        assertEquals("myTable", endpoint.getConfiguration().getTableName());
    }

    @Test
    public void createEndpointWithoutRegistryClient() throws Exception {
        Ddb2Component component = context.getComponent("aws2-ddb", Ddb2Component.class);
        assertThrows(IllegalArgumentException.class, () -> {
            component.createEndpoint("aws2-ddb://myTable");
        });
    }
}


text:
<?php

namespace Mr\BookBundle\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;

class DeleteType extends AbstractType {
    public function buildForm(FormBuilderInterface $builder, array $options) {
        $builder
            ->add('confirm', 'checkbox', array(
                'required' => true,
                'label' => 'mr.book.delete.confirm.label'
            ))
            ->add('save', 'submit', array(
                'label' => 'mr.book.delete.submit'
            ));
    }

    public function getName() {
        return 'mr_book_delete';
    }
}

redpajama_set_name: RedPajamaGithub


text:
package com.amazonaws.services.cloudtrail.model.transform;

import java.util.Map;
import java.util.Map.Entry;

import com.amazonaws.services.cloudtrail.model.*;
import com.amazonaws.transform.SimpleTypeJsonUnmarshallers.*;
import com.amazonaws.transform.*;

import com.fasterxml.jackson.core.JsonToken;
import static com.fasterxml.jackson.core.JsonToken.*;

/**
 * Get Trail Status Result JSON Unmarshaller
 */
public class GetTrailStatusResultJsonUnmarshaller implements Unmarshaller<GetTrailStatusResult, JsonUnmarshallerContext> {

    public GetTrailStatusResult unmarshall(JsonUnmarshallerContext context) throws Exception {
        GetTrailStatusResult getTrailStatusResult = new GetTrailStatusResult();

        int originalDepth = context.getCurrentDepth();
        String currentParentElement = context.getCurrentParentElement();
        int targetDepth = originalDepth + 1;

        JsonToken token = context.getCurrentToken();
        if (token == null) token = context.nextToken();
        if (token == VALUE_NULL) return null;

        while (true) {
            if (token == null) break;

            if (token == FIELD_NAME || token == START_OBJECT) {
                if (context.testExpression("IsLogging", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setIsLogging(BooleanJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("LatestDeliveryError", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setLatestDeliveryError(StringJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("LatestNotificationError", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setLatestNotificationError(StringJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("LatestDeliveryTime", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setLatestDeliveryTime(DateJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("LatestNotificationTime", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setLatestNotificationTime(DateJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("StartLoggingTime", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setStartLoggingTime(DateJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("StopLoggingTime", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setStopLoggingTime(DateJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("LatestCloudWatchLogsDeliveryError", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setLatestCloudWatchLogsDeliveryError(StringJsonUnmarshaller.getInstance().unmarshall(context));
                }
                if (context.testExpression("LatestCloudWatchLogsDeliveryTime", targetDepth)) {
                    context.nextToken();
                    getTrailStatusResult.setLatestCloudWatchLogsDeliveryTime(DateJsonUnmarshaller.getInstance().unmarshall(context));
                }
            } else if (token == END_ARRAY || token == END_OBJECT) {
                if (context.getLastParsedParentElement() == null || context.getLastParsedParentElement().equals(currentParentElement)) {
                    if (context.getCurrentDepth() <= originalDepth) break;
                }
            }

            token = context.nextToken();
        }

        return getTrailStatusResult;
    }

    private static GetTrailStatusResultJsonUnmarshaller instance;
    public static GetTrailStatusResultJsonUnmarshaller getInstance() {
        if (instance == null) instance = new GetTrailStatusResultJsonUnmarshaller();
        return instance;
    }
}


text:
namespace ui {
class HWNDMessageFilter;
}

namespace content {
class WebContentsDragWin;
class WebContentsImpl;
class WebContentsViewDelegate;
class WebDragDest;

// An implementation of WebContentsView for Windows.
class CONTENT_EXPORT WebContentsViewWin
    : public WebContentsViewPort,
      public RenderViewHostDelegateView,
      public gfx::WindowImpl {
 public:
  WebContentsViewWin(WebContentsImpl* web_contents,
                     WebContentsViewDelegate* delegate);
  virtual ~WebContentsViewWin();

  BEGIN_MSG_MAP_EX(WebContentsViewWin)
    MESSAGE_HANDLER(WM_CREATE, OnCreate)
    MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
    MESSAGE_HANDLER(WM_WINDOWPOSCHANGED, OnWindowPosChanged)
    MESSAGE_HANDLER(WM_LBUTTONDOWN, OnMouseDown)
    MESSAGE_HANDLER(WM_MBUTTONDOWN, OnMouseDown)
    MESSAGE_HANDLER(WM_RBUTTONDOWN, OnMouseDown)
    MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
    // Hacks for old ThinkPad touchpads/scroll points.
    MESSAGE_HANDLER(WM_NCCALCSIZE, OnNCCalcSize)
    MESSAGE_HANDLER(WM_NCHITTEST, OnNCHitTest)
    MESSAGE_HANDLER(WM_HSCROLL, OnScroll)
    MESSAGE_HANDLER(WM_VSCROLL, OnScroll)
    MESSAGE_HANDLER(WM_SIZE, OnSize)
  END_MSG_MAP()

  // Overridden from WebContentsView:
  virtual gfx::NativeView GetNativeView() const OVERRIDE;
  virtual gfx::NativeView GetContentNativeView() const OVERRIDE;
  virtual gfx::NativeWindow GetTopLevelNativeWindow() const OVERRIDE;
  virtual void GetContainerBounds(gfx::Rect *out) const OVERRIDE;
  virtual void OnTabCrashed(base::TerminationStatus status,
                            int error_code) OVERRIDE;
  virtual void SizeContents(const gfx::Size& size) OVERRIDE;
  virtual void Focus() OVERRIDE;
  virtual void SetInitialFocus() OVERRIDE;
  virtual void StoreFocus() OVERRIDE;
  virtual void RestoreFocus() OVERRIDE;
  virtual DropData* GetDropData() const OVERRIDE;
  virtual gfx::Rect GetViewBounds() const OVERRIDE;

  // Overridden from WebContentsViewPort:
  virtual void CreateView(
      const gfx::Size& initial_size, gfx::NativeView context) OVERRIDE;
  virtual RenderWidgetHostView* CreateViewForWidget(
      RenderWidgetHost* render_widget_host) OVERRIDE;
  virtual RenderWidgetHostView* CreateViewForPopupWidget(
      RenderWidgetHost* render_widget_host) OVERRIDE;
  virtual void SetPageTitle(const string16& title) OVERRIDE;
  virtual void RenderViewCreated(RenderViewHost* host) OVERRIDE;
  virtual void RenderViewSwappedIn(RenderViewHost* host) OVERRIDE;
  virtual void SetOverscrollControllerEnabled(bool enabled) OVERRIDE;

  // Implementation of RenderViewHostDelegateView.
  virtual void ShowContextMenu(const ContextMenuParams& params) OVERRIDE;
  virtual void ShowPopupMenu(const gfx::Rect& bounds,
                             int item_height,
                             double item_font_size,
                             int selected_item,
                             const std::vector<MenuItem>& items,
                             bool right_aligned,
                             bool allow_multiple_selection) OVERRIDE;
  virtual void StartDragging(const DropData& drop_data,
                             blink::WebDragOperationsMask operations,
                             const gfx::ImageSkia& image,
                             const gfx::Vector2d& image_offset,
                             const DragEventSourceInfo& event_info) OVERRIDE;
  virtual void UpdateDragCursor(blink::WebDragOperation operation) OVERRIDE;
  virtual void GotFocus() OVERRIDE;
  virtual void TakeFocus(bool reverse) OVERRIDE;

  WebContentsImpl* web_contents() const { return web_contents_; }

 private:
  void EndDragging();
  void CloseTab();

  LRESULT OnCreate(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnDestroy(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnWindowPosChanged(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnMouseDown(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnMouseMove(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnReflectedMessage(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnNCCalcSize(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnNCHitTest(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnScroll(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);
  LRESULT OnSize(
      UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled);

  gfx::Size initial_size_;

  // The WebContentsImpl whose contents we display.
  WebContentsImpl* web_contents_;

  scoped_ptr<WebContentsViewDelegate> delegate_;

  // The helper object that handles drag destination related interactions with
  // Windows.
  scoped_refptr<WebDragDest> drag_dest_;

  // Used to handle the drag-and-drop.
  scoped_refptr<WebContentsDragWin> drag_handler_;

  scoped_ptr<ui::HWNDMessageFilter> hwnd_message_filter_;

  DISALLOW_COPY_AND_ASSIGN(WebContentsViewWin);
};

} // namespace content

#endif  // CONTENT_BROWSER_WEB_CONTENTS_WEB_CONTENTS_VIEW_WIN_H_


text:
namespace LiteCppDB_Tests
{
	class AutoIndexDatabaseTest
	{
	public:
	};
}


text:
cd /home/meteor/build/bundle
echo "Starting Meteor Application..."
exec node ./main.js


text:
require File.dirname(__FILE__) + '/helper'

EM.run do
  array = (1..100).to_a

  tickloop = EM.tick_loop do
    if array.empty?
      :stop
    else
      puts array.shift
    end
  end

  tickloop.on_stop { EM.stop }
end


text:
@interface AZSAccessCondition()

-(instancetype)init AZS_DESIGNATED_INITIALIZER;

@end

@implementation AZSAccessCondition

-(instancetype) init
{
    return nil;
}

-(instancetype) initWithIfMatchCondition:(NSString*)eTag
{
    self = [super init];
    if (self)
    {
        _ifMatchETag = eTag;
    }

    return self;
}

-(instancetype) initWithIfNoneMatchCondition:(NSString*)eTag
{
    self = [super init];
    if (self)
    {
        _ifNoneMatchETag = eTag;
    }

    return self;
}

-(instancetype) initWithIfModifiedSinceCondition:(NSDate*)modifiedDate
{
    self = [super init];
    if (self)
    {
        _ifModifiedSinceDate = modifiedDate;
    }

    return self;
}

-(instancetype) initWithIfNotModifiedSinceCondition:(NSDate*)modifiedDate
{
    self = [super init];
    if (self)
    {
        _ifNotModifiedSinceDate = modifiedDate;
    }

    return self;
}

-(instancetype) initWithLeaseId:(NSString*)leaseId
{
    self = [super init];
    if (self)
    {
        _leaseId = leaseId;
    }

    return self;
}

+(instancetype) cloneWithEtag:(NSString*)etag accessCondition:(AZSAccessCondition*)condition;
{
    AZSAccessCondition* clone = [[AZSAccessCondition alloc] init];
    clone->_ifMatchETag = etag;

    if (condition)
    {
        clone.leaseId = condition.leaseId;
    }

    return clone;
}
@end


text:
/* ========================================================================== */
/* === umfpack_get_symbolic ================================================= */
/* ========================================================================== */

/* -------------------------------------------------------------------------- */
/* UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A.      */
/* Davis.  All Rights Reserved.  See ../README for License.                   */
/* email: davis@cise.ufl.edu    CISE Department, Univ. of Florida.            */
/* web: http://www.cise.ufl.edu/research/sparse/umfpack                       */
/* -------------------------------------------------------------------------- */

int umfpack_di_get_symbolic
(
    int *n_row,
    int *n_col,
    int *n1,
    int *nz,
    int *nfr,
    int *nchains,
    int P [ ],
    int Q [ ],
    int Front_npivcol [ ],
    int Front_parent [ ],
    int Front_1strow [ ],
    int Front_leftmostdesc [ ],
    int Chain_start [ ],
    int Chain_maxrows [ ],
    int Chain_maxcols [ ],
    void *Symbolic
) ;

long umfpack_dl_get_symbolic
(
    long *n_row,
    long *n_col,
    long *n1,
    long *nz,
    long *nfr,
    long *nchains,
    long P [ ],
    long Q [ ],
    long Front_npivcol [ ],
    long Front_parent [ ],
    long Front_1strow [ ],
    long Front_leftmostdesc [ ],
    long Chain_start [ ],
    long Chain_maxrows [ ],
    long Chain_maxcols [ ],
    void *Symbolic
) ;

int umfpack_zi_get_symbolic
(
    int *n_row,
    int *n_col,
    int *n1,
    int *nz,
    int *nfr,
    int *nchains,
    int P [ ],
    int Q [ ],
    int Front_npivcol [ ],
    int Front_parent [ ],
    int Front_1strow [ ],
    int Front_leftmostdesc [ ],
    int Chain_start [ ],
    int Chain_maxrows [ ],
    int Chain_maxcols [ ],
    void *Symbolic
) ;

long umfpack_zl_get_symbolic
(
    long *n_row,
    long *n_col,
    long *n1,
    long *nz,
    long *nfr,
    long *nchains,
    long P [ ],
    long Q [ ],
    long Front_npivcol [ ],
    long Front_parent [ ],
    long Front_1strow [ ],
    long Front_leftmostdesc [ ],
    long Chain_start [ ],
    long Chain_maxrows [ ],
    long Chain_maxcols [ ],
    void *Symbolic
) ;

/*

double int Syntax:

    #include "umfpack.h"
    int status, n_row, n_col, nz, nfr, nchains, *P, *Q,
	*Front_npivcol, *Front_parent, *Front_1strow, *Front_leftmostdesc,
	*Chain_start, *Chain_maxrows, *Chain_maxcols ;
    void *Symbolic ;
    status = umfpack_di_get_symbolic (&n_row, &n_col, &nz, &nfr, &nchains,
	P, Q, Front_npivcol, Front_parent, Front_1strow,
	Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols,
	Symbolic) ;

double long Syntax:

    #include "umfpack.h"
    long status, n_row, n_col, nz, nfr, nchains, *P, *Q,
	*Front_npivcol, *Front_parent, *Front_1strow, *Front_leftmostdesc,
	*Chain_start, *Chain_maxrows, *Chain_maxcols ;
    void *Symbolic ;
    status = umfpack_dl_get_symbolic (&n_row, &n_col, &nz, &nfr, &nchains,
	P, Q, Front_npivcol, Front_parent, Front_1strow,
	Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols,
	Symbolic) ;

complex int Syntax:

    #include "umfpack.h"
    int status, n_row, n_col, nz, nfr, nchains, *P, *Q,
	*Front_npivcol, *Front_parent, *Front_1strow, *Front_leftmostdesc,
	*Chain_start, *Chain_maxrows, *Chain_maxcols ;
    void *Symbolic ;
    status = umfpack_zi_get_symbolic (&n_row, &n_col, &nz, &nfr, &nchains,
	P, Q, Front_npivcol, Front_parent, Front_1strow,
	Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols,
	Symbolic) ;

complex long Syntax:

    #include "umfpack.h"
    long status, n_row, n_col, nz, nfr, nchains, *P, *Q,
	*Front_npivcol, *Front_parent, *Front_1strow, *Front_leftmostdesc,
	*Chain_start, *Chain_maxrows, *Chain_maxcols ;
    void *Symbolic ;
    status = umfpack_zl_get_symbolic (&n_row, &n_col, &nz, &nfr, &nchains,
	P, Q, Front_npivcol, Front_parent, Front_1strow,
	Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols,
	Symbolic) ;

Purpose:

    Copies the contents of the Symbolic object into simple integer arrays
    accessible to the user.  This routine is not needed to factorize and/or
    solve a sparse linear system using UMFPACK.  Note that the output arrays
    P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc,
    Chain_start, Chain_maxrows, and Chain_maxcols are not allocated by
    umfpack_*_get_symbolic; they must exist on input.

    All output arguments are optional.  If any of them are NULL
    on input, then that part of the symbolic analysis is not copied.  You can
    use this routine to extract just the parts of the symbolic analysis that
    you want.  For example, to retrieve just the column permutation Q, use:

    #define noI (int *) NULL
    status = umfpack_di_get_symbolic (noI, noI, noI, noI, noI, noI, noI,
	    Q, noI, noI, noI, noI, noI, noI, noI, Symbolic) ;

    The only required argument the last one, the pointer to the Symbolic object.

    The Symbolic object is small.  Its size for an n-by-n square matrix varies
    from 4*n to 13*n, depending on the matrix.  The object holds the initial
    column permutation, the supernodal column elimination tree, and information
    about each frontal matrix.  You can print it with umfpack_*_report_symbolic.

Returns:

    Returns UMFPACK_OK if successful, UMFPACK_ERROR_invalid_Symbolic_object
    if Symbolic is an invalid object.

Arguments:

    Int *n_row ;	Output argument.
    Int *n_col ;	Output argument.

	The dimensions of the matrix A analyzed by the call to
	umfpack_*_symbolic that generated the Symbolic object.

    Int *n1 ;		Output argument.

	The number of pivots with zero Markowitz cost (they have just one entry
	in the pivot row, or the pivot column, or both).  These appear first in
	the output permutations P and Q.

	NOTE: this argument is new to version 4.1.

    Int *nz ;		Output argument.

	The number of nonzeros in A.

    Int *nfr ;	Output argument.

	The number of frontal matrices that will be used by umfpack_*_numeric
	to factorize the matrix A.  It is in the range 0 to n_col.

    Int *nchains ;	Output argument.

	The frontal matrices are related to one another by the supernodal
	column elimination tree.  Each node in this tree is one frontal matrix.
	The tree is partitioned into a set of disjoint paths, and a frontal
	matrix chain is one path in this tree.  Each chain is factorized using
	a unifrontal technique, with a single working array that holds each
	frontal matrix in the chain, one at a time.  nchains is in the range
	0 to nfr.

    Int P [n_row] ;	Output argument.

	The initial row permutation.  If P [k] = i, then this means that
	row i is the kth row in the pre-ordered matrix.  In general, this P is
	not the same as the final row permutation computed by umfpack_*_numeric.

	For the unsymmetric strategy, P defines the row-merge order.  Let j be
	the column index of the leftmost nonzero entry in row i of A*Q.  Then
	P defines a sort of the rows according to this value.  A row can appear
	earlier in this ordering if it is aggressively absorbed before it can
	become a pivot row.  If P [k] = i, row i typically will not be the kth
	pivot row.

	For the symmetric strategy, P = Q.  For the 2-by-2 strategy, P is the
	row permutation that places large entries on the diagonal of P*A*Q.
	If no pivoting occurs during numerical factorization, P [k] = i also
	defines the final permutation of umfpack_*_numeric, for either the
	symmetric or 2-by-2 strategies.

    Int Q [n_col] ;	Output argument.

	The initial column permutation.  If Q [k] = j, then this means that
	column j is the kth pivot column in the pre-ordered matrix.  Q is
	not necessarily the same as the final column permutation Q, computed by
	umfpack_*_numeric.  The numeric factorization may reorder the pivot
	columns within each frontal matrix to reduce fill-in.  If the matrix is
	structurally singular, and if the symmetric or 2-by-2 strategies or
	used (or if Control [UMFPACK_FIXQ] > 0), then this Q will be the same
	as the final column permutation computed in umfpack_*_numeric.

    Int Front_npivcol [n_col+1] ;	Output argument.

	This array should be of size at least n_col+1, in order to guarantee
	that it will be large enough to hold the output.  Only the first nfr+1
	entries are used, however.

	The kth frontal matrix holds Front_npivcol [k] pivot columns.  Thus, the
	first frontal matrix, front 0, is used to factorize the first
	Front_npivcol [0] columns; these correspond to the original columns
	Q [0] through Q [Front_npivcol [0]-1].  The next frontal matrix
	is used to factorize the next Front_npivcol [1] columns, which are thus
	the original columns Q [Front_npivcol [0]] through
	Q [Front_npivcol [0] + Front_npivcol [1] - 1], and so on.  Columns
	with no entries at all are put in a placeholder "front",
	Front_npivcol [nfr].  The sum of Front_npivcol [0..nfr] is equal to
	n_col.

	Any modifications that umfpack_*_numeric makes to the initial column
	permutation are constrained to within each frontal matrix.  Thus, for
	the first frontal matrix, Q [0] through Q [Front_npivcol [0]-1] is some
	permutation of the columns Q [0] through
	Q [Front_npivcol [0]-1].  For second frontal matrix,
	Q [Front_npivcol [0]] through Q [Front_npivcol [0] + Front_npivcol[1]-1]
	is some permutation of the same portion of Q, and so on.  All pivot
	columns are numerically factorized within the frontal matrix originally
	determined by the symbolic factorization; there is no delayed pivoting
	across frontal matrices.

    Int Front_parent [n_col+1] ;	Output argument.

	This array should be of size at least n_col+1, in order to guarantee
	that it will be large enough to hold the output.  Only the first nfr+1
	entries are used, however.

	Front_parent [0..nfr] holds the supernodal column elimination tree
	(including the placeholder front nfr, which may be empty).  Each node in
	the tree corresponds to a single frontal matrix.  The parent of node f
	is Front_parent [f].

    Int Front_1strow [n_col+1] ;	Output argument.

	This array should be of size at least n_col+1, in order to guarantee
	that it will be large enough to hold the output.  Only the first nfr+1
	entries are used, however.

	Front_1strow [k] is the row index of the first row in A (P,Q)
	whose leftmost entry is in a pivot column for the kth front.  This is
	necessary only to properly factorize singular matrices.  It is new to
	Version 4.0.  Rows in the range Front_1strow [k] to
	Front_1strow [k+1]-1 first become pivot row candidates at the kth front.
	Any rows not eliminated in the kth front may be selected as pivot rows
	in the parent of k (Front_parent [k]) and so on up the tree.

    Int Front_leftmostdesc [n_col+1] ;	Output argument.

	This array should be of size at least n_col+1, in order to guarantee
	that it will be large enough to hold the output.  Only the first nfr+1
	entries are used, however.

	Front_leftmostdesc [k] is the leftmost descendant of front k, or k
	if the front has no children in the tree.  Since the rows and columns
	(P and Q) have been post-ordered via a depth-first-search of
	the tree, rows in the range Front_1strow [Front_leftmostdesc [k]] to
	Front_1strow [k+1]-1 form the entire set of candidate pivot rows for
	the kth front (some of these will typically have already been selected
	by fronts in the range Front_leftmostdesc [k] to front k-1, before
	the factorization reaches front k).

    Chain_start [n_col+1] ;	Output argument.

	This array should be of size at least n_col+1, in order to guarantee
	that it will be large enough to hold the output.  Only the first
	nchains+1 entries are used, however.

	The kth frontal matrix chain consists of frontal matrices Chain_start[k]
	through Chain_start [k+1]-1.  Thus, Chain_start [0] is always 0, and
	Chain_start [nchains] is the total number of frontal matrices, nfr.  For
	two adjacent fronts f and f+1 within a single chain, f+1 is always the
	parent of f (that is, Front_parent [f] = f+1).

    Int Chain_maxrows [n_col+1] ;	Output argument.
    Int Chain_maxcols [n_col+1] ;	Output argument.

	These arrays should be of size at least n_col+1, in order to guarantee
	that they will be large enough to hold the output.  Only the first
	nchains entries are used, however.

	The kth frontal matrix chain requires a single working array of
	dimension Chain_maxrows [k] by Chain_maxcols [k], for the unifrontal
	technique that factorizes the frontal matrix chain.  Since the symbolic
	factorization only provides an upper bound on the size of each frontal
	matrix, not all of the working array is necessarily used during the
	numerical factorization.

	Note that the upper bound on the number of rows and columns of each
	frontal matrix is computed by umfpack_*_symbolic, but all that is
	required by umfpack_*_numeric is the maximum of these two sets of
	values for each frontal matrix chain.  Thus, the size of each
	individual frontal matrix is not preserved in the Symbolic object.

    void *Symbolic ;			Input argument, not modified.

	The Symbolic object, which holds the symbolic factorization computed by
	umfpack_*_symbolic.  The Symbolic object is not modified by
	umfpack_*_get_symbolic.
*/


text:
package org.wso2.carbon.apimgt.rest.api.util.interceptors.eTag;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.cxf.helpers.CastUtils;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.jaxrs.model.OperationResourceInfo;
import org.apache.cxf.message.Message;
import org.apache.cxf.message.MessageContentsList;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.wso2.carbon.apimgt.rest.api.util.RestApiConstants;
import org.wso2.carbon.apimgt.rest.api.util.utils.ETagGenerator;

import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Response;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import static org.wso2.carbon.apimgt.rest.api.util.utils.RestApiUtil.checkETagSkipList;

public class ETagInInterceptor extends AbstractPhaseInterceptor<Message> {
    private static final Log log = LogFactory.getLog(ETagInInterceptor.class);

    public ETagInInterceptor() {
        super(Phase.PRE_INVOKE);
    }

    @Override
    public void handleMessage(Message message) throws Fault {

        if (checkETagSkipList(message.get(Message.PATH_INFO).toString(),
                message.get(Message.HTTP_REQUEST_METHOD).toString())) {
            if (log.isDebugEnabled()){
                log.debug("Skipping ETagInInterceptor for URI : " + message.get(Message.PATH_INFO).toString());
            }
            return;
        }

        OperationResourceInfo operationResource = message.getExchange().get(OperationResourceInfo.class);
        Map<String, List<String>> headers = CastUtils.cast((Map) message.get(Message.PROTOCOL_HEADERS));
        List<Object> arguments = MessageContentsList.getContentsList(message);
        try {
            Class aClass = Class.forName(operationResource.getMethodToInvoke().getDeclaringClass().getName());
            Method aClassMethod = aClass.getMethod(operationResource.getMethodToInvoke().getName() +
                    RestApiConstants.GET_LAST_UPDATED, operationResource.getMethodToInvoke().getParameterTypes());
            Object o = aClass.newInstance();
            String lastUpdatedTime = String.valueOf(aClassMethod.invoke(o, arguments.toArray()));
            if (message.get(Message.HTTP_REQUEST_METHOD).equals(RestApiConstants.GET)) {
                if (!Objects.equals(lastUpdatedTime, "null")) {
                    String eTag = ETagGenerator.getETag(lastUpdatedTime);
                    if (headers.containsKey(HttpHeaders.IF_NONE_MATCH)) {
                        String headerValue = headers.get(HttpHeaders.IF_NONE_MATCH).get(0);
                        if (Objects.equals(eTag, headerValue)) {
                            Response response = Response.notModified(eTag).build();
                            message.getExchange().put(Response.class, response);
                            return;
                        }
                    }
                    message.getExchange().put(RestApiConstants.ETAG, eTag);
                }
            }
            /*
            If the request method is a PUT or a DELETE and the If-Match header is given then the ETag value for the
            resource and the header value will be compared and if they do not match then the flow will be terminated
            with 412 PRECONDITION FAILED
             */
            if (((RestApiConstants.PUT.equals(message.get(Message.HTTP_REQUEST_METHOD))
                    || RestApiConstants.DELETE.equals(message.get(Message.HTTP_REQUEST_METHOD))))
                    && headers.containsKey(HttpHeaders.IF_MATCH)) {
                String ifMatchHeaderValue;
                ifMatchHeaderValue = String.valueOf(headers.get(HttpHeaders.IF_MATCH).get(0));
                if (!Objects.equals(lastUpdatedTime, "null")) {
                    String eTag = ETagGenerator.getETag(lastUpdatedTime);
                    if (!Objects.equals(ifMatchHeaderValue, eTag)) {
                        Response response = Response.status(Response.Status.PRECONDITION_FAILED).build();
                        message.getExchange().put(Response.class, response);
                    }
                }
            }
        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException |
                InvocationTargetException | InstantiationException e) {
            if (log.isDebugEnabled()) {
                log.debug(" Error while retrieving the ETag Resource timestamps due to " + e.getMessage(), e);
            }
        }

    }

}


text:
import {NgModule} from '@angular/core';
import {CommonModule} from '@angular/common';
import {FormsModule} from '@angular/forms';
import {TinymceModule} from 'angular2-tinymce';
import {NgbModule} from '@ng-bootstrap/ng-bootstrap';
import {CustomerComponent} from './customer.component';
import {CustomerRoutingModule} from './customer-routing.module';
import {PageHeaderModule, ModalModule} from './../../shared';
import {ModalComponent} from "../../shared/modules/modal/modal.component";

@NgModule({
    imports: [
        CommonModule,
        FormsModule,
        NgbModule.forRoot(),
        CustomerRoutingModule,
        ModalModule,
        PageHeaderModule,
        TinymceModule.withConfig({})

    ],
    providers: [ModalComponent],
    declarations: [CustomerComponent]
})
export class CustomerModule {
}


text:
package org.vaadin.marcus;

import com.vaadin.server.AbstractClientConnector;
import com.vaadin.server.AbstractExtension;
import org.vaadin.marcus.client.MouseEventsRPC;

import java.io.Serializable;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class MouseEvents extends AbstractExtension {

    private Set<MouseOverListener> mouseOverListeners = new HashSet<MouseOverListener>();
    private Set<MouseOutListener> mouseOutListeners = new HashSet<MouseOutListener>();

    public interface MouseOverListener extends Serializable {
        void mouseOver();
    }

    public interface MouseOutListener extends Serializable  {
        void mouseOut();
    }

    MouseEventsRPC rpc = new MouseEventsRPC() {
        @Override
        public void mouseOver() {
            fireMouseOverEvents();
        }

        @Override
        public void mouseOut() {
            fireMouseOutEvents();
        }
    };

    protected MouseEvents(AbstractClientConnector component) {
        registerRpc(rpc);
        extend(component);
    }

    public static MouseEvents enableFor(AbstractClientConnector component) {
        return new MouseEvents(component);
    }

    private void fireMouseOverEvents() {
        for (MouseOverListener listener : Collections.unmodifiableCollection(mouseOverListeners)) {
            listener.mouseOver();
        }
    }

    private void fireMouseOutEvents() {
        for (MouseOutListener listener : Collections.unmodifiableCollection(mouseOutListeners)) {
            listener.mouseOut();
        }
    }

    public void addMouseOverListener(MouseOverListener listener) {
        mouseOverListeners.add(listener);
    }

    public void removeMouseOverListener(MouseOverListener listener) {
        mouseOverListeners.remove(listener);
    }

    public void addMouseOutListener(MouseOutListener listener) {
        mouseOutListeners.add(listener);
    }

    public void removeMouseOutListener(MouseOutListener listener) {
        mouseOutListeners.remove(listener);
    }
}


text:
**This repository is DEPRECATED and is no longer maintained.**

Guild AI examples are now hosted in the main repository at this
location:

https://github.com/guildai/guildai/tree/master/examples

## About Guild AI

Guild AI is an open source tool for running, tracking, and comparing
machine learning experiments. It supports all ML platforms including
TensorFlow, PyTorch, Keras, MXNet, scikit-learn, and XGBoost.

For more information, visit https://guild.ai.


text:
package ludum.mighty.ld36.actors;

import java.util.ArrayList;

import ludum.mighty.ld36.actions.Action;
import ludum.mighty.ld36.animations.AnimatorBoomerang;
import ludum.mighty.ld36.settings.DefaultValues;

import com.badlogic.gdx.scenes.scene2d.actions.MoveByAction;

/**
 * Created by dchaves on 27/08/16.
 */
public class Item_Boomerang extends Actor_Powerup
{

	private AnimatorBoomerang animator;

	public Item_Boomerang(BasicMaruto parent)
	{
		super(parent);

		this.turnsLife = DefaultValues.RANDOM_TURNS_LIFE;
		this.life = DefaultValues.RANDOM_LIFE;
		this.shiftProbability = (float) DefaultValues.RANDOM_SHIFT_PROB;
		this.punch = DefaultValues.RANDOM_DAMAGE;
		this.speed = DefaultValues.RANDOM_SPEED;
		this.name = DefaultValues.POWERUPS.RANDOM.toString();

		// Put an idle action by default
		ArrayList<Action> actionList = new ArrayList<Action>();
		actionList.add(new Action(DefaultValues.ACTIONS.WALK));
		/**
		 * // Put an idle action by default ArrayList<Action> actionList = new
		 * ArrayList<Action>(); actionList.add(new
		 * Action(DefaultValues.ACTIONS.IDLE));
		 **/

		this.movementList = actionList;

		this.animator = new AnimatorBoomerang("items_spreadsheet.png");
		anim = animator.anim;
	}

private void doMovementWalk() {

		MoveByAction mba = new MoveByAction();

		anim = animator.animBoomerang;
		switch (facing) {

		case NORTH:

			mba.setAmount(0, DefaultValues.TILESIZE);
			break;

		case EAST:

			mba.setAmount(DefaultValues.TILESIZE, 0);
			break;

		case SOUTH:

			mba.setAmount(0, -DefaultValues.TILESIZE);
			break;

		case WEST:

			mba.setAmount(-DefaultValues.TILESIZE, 0);
			break;

		case NORTHEAST:

			mba.setAmount(DefaultValues.TILESIZE, DefaultValues.TILESIZE);
			break;

		case NORTHWEST:

			mba.setAmount(-DefaultValues.TILESIZE, DefaultValues.TILESIZE);
			break;

		case SOUTHEAST:

			mba.setAmount(DefaultValues.TILESIZE, -DefaultValues.TILESIZE);
			break;

		case SOUTHWEST:

			mba.setAmount(-DefaultValues.TILESIZE, -DefaultValues.TILESIZE);
			break;

		}

		mba.setDuration(1f);
		this.addAction(mba);

		moveFlag = true;

	}

private void doMovementTurn() {

	anim = animator.animStopBoomerang;
	MoveByAction mba = new MoveByAction();
	mba.setAmount(0, 0);
	mba.setDuration(1f);
	this.addAction(mba);
	//}
}

	@Override
	public void doMovement(Action action) {

			this.doTilesetWalk();
			doMovementWalk();

	}

}


text:
from wtforms import StringField
from flask_babelpkg import lazy_gettext
from wtforms.validators import DataRequired
from flask_appbuilder.fieldwidgets import BS3TextFieldWidget
from flask_appbuilder.forms import DynamicForm

class TestForm(DynamicForm):
    TestFieldOne = StringField(lazy_gettext('Test Field One'), validators=[DataRequired()], widget=BS3TextFieldWidget())
    TestFieldTwo = StringField(lazy_gettext('Test Field One'), validators=[DataRequired()], widget=BS3TextFieldWidget())


text:
<?php

namespace App;

use App\User;
use DB;
use Illuminate\Database\Eloquent\Model;

class Issue extends Model
{
	protected $table = 'issues';

    public static function getAll()
    {
        return Issue::all();
    }

    public function book()
    {
        return $this->belongsTo(Book::class);
    }

    public function user()
    {
        return $this->belongsTo(User::class);
    }
    /**
    *  Returning a book involves the following steps:
    *   - Deleting the record from the issue table for the book/user
    *   - Inecrementing the available number of copies of the book and updating the respective book record in the book table
    **/
    public function returnBook()
    {
        DB::beginTransaction();
        try
        {

            DB::delete("DELETE FROM issues WHERE Id = :issueId", ['issueId' => $this->id]);

            $availableCopies = DB::table('books')->select('available_copies')->where('id', $this->book_id)->first();

            DB::update("UPDATE books SET available_copies=? WHERE Id=?",[++$availableCopies->available_copies, $this->book_id] );

            DB::commit();
            $retVal = TRUE;
        }
        catch(Exception $e)
        {
            DB::rollBack();
            $retVal = FALSE;

        }
        return $retVal;
    }

}


text:
package org.broadinstitute.hellbender.tools.copynumber;

import htsjdk.samtools.ValidationStringency;
import org.broadinstitute.hellbender.CommandLineProgramTest;
import org.broadinstitute.hellbender.cmdline.ExomeStandardArgumentDefinitions;
import org.broadinstitute.hellbender.cmdline.StandardArgumentDefinitions;
import org.broadinstitute.hellbender.exceptions.UserException;
import org.broadinstitute.hellbender.tools.copynumber.allelic.alleliccount.AllelicCount;
import org.broadinstitute.hellbender.tools.copynumber.allelic.alleliccount.AllelicCountCollection;
import org.broadinstitute.hellbender.utils.SimpleInterval;
import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

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

/**
 * Integration test for {@link CollectAllelicCounts}.  Uses BAM and SNP files generated from hg19mini using wgsim.
 *
 * @author Samuel Lee <slee@broadinstitute.org>
 */
public final class CollectAllelicCountsIntegrationTest extends CommandLineProgramTest {

    private static final String TEST_SUB_DIR = publicTestDir + "org/broadinstitute/hellbender/tools/copynumber/allelic";
    private static final File NORMAL_BAM_FILE = new File(TEST_SUB_DIR, "collect-allelic-counts-normal.bam");
    private static final File TUMOR_BAM_FILE = new File(TEST_SUB_DIR, "collect-allelic-counts-tumor.bam");
    private static final File NON_STRICT_BAM_FILE = new File(TEST_SUB_DIR, "collect-allelic-counts-simple-overhang.sam");
    private static final File SITES_FILE = new File(TEST_SUB_DIR, "collect-allelic-counts-sites.interval_list");
    private static final File REF_FILE = new File(hg19MiniReference);

    @DataProvider(name = "testData")
    public Object[][] testData() throws IOException {
        //counts from IGV with minMQ = 30 and minBQ = 20
        final AllelicCountCollection normalCountsExpected = new AllelicCountCollection();
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 10736, 10736), 0, 0));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 11522, 11522), 7, 4));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 12098, 12098), 8, 6));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 12444, 12444), 0, 18));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 13059, 13059), 0, 8));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 14630, 14630), 9, 8));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("1", 15204, 15204), 4, 4));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("2", 14689, 14689), 6, 9));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("2", 14982, 14982), 6, 5));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("2", 15110, 15110), 6, 0));
        normalCountsExpected.add(new AllelicCount(new SimpleInterval("2", 15629, 15629), 5, 3));

        final AllelicCountCollection tumorCountsExpected = new AllelicCountCollection();
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 10736, 10736), 0, 0));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 11522, 11522), 7, 4));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 12098, 12098), 8, 6));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 12444, 12444), 0, 17));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 13059, 13059), 0, 8));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 14630, 14630), 9, 8));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("1", 15204, 15204), 4, 3));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("2", 14689, 14689), 6, 9));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("2", 14982, 14982), 6, 5));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("2", 15110, 15110), 6, 0));
        tumorCountsExpected.add(new AllelicCount(new SimpleInterval("2", 15629, 15629), 5, 3));

        return new Object[][]{
                {NORMAL_BAM_FILE, normalCountsExpected},
                {TUMOR_BAM_FILE, tumorCountsExpected}
        };
    }

    @Test(dataProvider = "testData")
    public void test(final File inputBAMFile,
                     final AllelicCountCollection countsExpected) {
        final File outputFile = createTempFile("collect-allelic-counts-test-output", ".tsv");
        final String[] arguments = {
                "-" + StandardArgumentDefinitions.INPUT_SHORT_NAME, inputBAMFile.getAbsolutePath(),
                "-" + ExomeStandardArgumentDefinitions.SITES_FILE_SHORT_NAME, SITES_FILE.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.REFERENCE_SHORT_NAME, REF_FILE.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.OUTPUT_SHORT_NAME, outputFile.getAbsolutePath()
        };
        runCommandLine(arguments);
        final AllelicCountCollection countsResult = new AllelicCountCollection(outputFile);
        Assert.assertEquals(countsExpected, countsResult);
    }

    //Regression test for https://github.com/broadinstitute/gatk-protected/issues/373
    @Test(expectedExceptions = UserException.class)
    public void testNonStrictBAM() {
        final File outputFile = createTempFile("collect-allelic-counts-test-output", ".tsv");
        final String[] arguments = {
                "-" + StandardArgumentDefinitions.INPUT_SHORT_NAME, NON_STRICT_BAM_FILE.getAbsolutePath(),
                "-" + ExomeStandardArgumentDefinitions.SITES_FILE_SHORT_NAME, SITES_FILE.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.REFERENCE_SHORT_NAME, REF_FILE.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.OUTPUT_SHORT_NAME, outputFile.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.READ_VALIDATION_STRINGENCY_SHORT_NAME, ValidationStringency.STRICT.toString()
        };
        runCommandLine(arguments);
        //should catch SAMFormatException and throw new UserException with --readValidationStringency STRICT
    }

    //Regression test for https://github.com/broadinstitute/gatk-protected/issues/373
    @Test
    public void testNonStrictBAMWithSilentValidationStringency() {
        final File outputFile = createTempFile("collect-allelic-counts-test-output", ".tsv");
        final String[] arguments = {
                "-" + StandardArgumentDefinitions.INPUT_SHORT_NAME, NON_STRICT_BAM_FILE.getAbsolutePath(),
                "-" + ExomeStandardArgumentDefinitions.SITES_FILE_SHORT_NAME, SITES_FILE.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.REFERENCE_SHORT_NAME, REF_FILE.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.OUTPUT_SHORT_NAME, outputFile.getAbsolutePath(),
                "-" + StandardArgumentDefinitions.READ_VALIDATION_STRINGENCY_SHORT_NAME, ValidationStringency.SILENT.toString()
        };
        runCommandLine(arguments);
        //should complete successfully with --readValidationStringency SILENT
    }
}


text:
@interface RxElementAtSink<O : id<RxObserverType>> : RxSink<O> <RxObserverType>
@end

@implementation RxElementAtSink {
    RxElementAt *__nonnull _parent;
    NSUInteger _i;
}

- (nonnull instancetype)initWithParent:(nonnull RxElementAt *)parent observer:(nonnull id <RxObserverType>)observer {
    self = [super initWithObserver:observer];
    if (self) {
        _parent = parent;
        _i = _parent->_index;
    }
    return self;
}

- (void)on:(nonnull RxEvent *)event {
    switch (event.type) {
        case RxEventTypeNext: {
            if (_i == 0) {
                [self forwardOn:event];
                [self forwardOn:[RxEvent completed]];
                [self dispose];
            }

            rx_tryCatch(^{
                rx_decrementCheckedUnsigned(&_i);
            }, ^(NSError *error) {
                [self forwardOn:[RxEvent error:error]];
                [self dispose];
            });
            break;
        }
        case RxEventTypeError: {
            [self forwardOn:event];
            [self dispose];
            break;
        }
        case RxEventTypeCompleted: {
            if (_parent->_throwOnEmpty) {
                [self forwardOn:[RxEvent error:[RxError argumentOutOfRange]]];
            } else {
                [self forwardOn:[RxEvent completed]];
            }
            [self dispose];
            break;
        }
    }
}

@end

@implementation RxElementAt

- (nonnull instancetype)initWithSource:(nonnull RxObservable<id> *)source index:(NSUInteger)index throwOnEmpty:(BOOL)throwOnEmpty {
    self = [super init];
    if (self) {
        _source = source;
        _index = index;
        _throwOnEmpty = throwOnEmpty;
    }
    return self;
}

- (nonnull id <RxDisposable>)run:(nonnull id <RxObserverType>)observer {
    RxElementAtSink *sink = [[RxElementAtSink alloc] initWithParent:self observer:observer];
    sink.disposable = [_source subscribeSafe:sink];
    return sink;
}

@end


text:
#ifndef ALIVZERORECONSTRUCTOR_H
#define ALIVZERORECONSTRUCTOR_H

/* See cxx source for full Copyright notice                              */
/* $Id$  */

///////////////////////////////////////////////////////////////////////////
///                                                                      //
/// class for VZERO reconstruction                                       //
///                                                                      //
///////////////////////////////////////////////////////////////////////////

#include "AliReconstructor.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"

#include "AliLog.h"
#include "AliESDVZERO.h"
#include "AliVZERORecoParam.h"

class TF1;
class TH1F;
class AliVZEROCalibData;
class AliVZEROTriggerData;
class AliESDEvent;
class AliESDVZEROfriend;

class AliVZEROReconstructor: public AliReconstructor {
public:
  AliVZEROReconstructor();
  virtual ~AliVZEROReconstructor();
  virtual void   Init();

  virtual void   Reconstruct(AliRawReader* /*rawReader*/,
		             TTree* /*clustersTree*/) const {
                 AliError("Method not implemented"); return;};
  virtual void   Reconstruct(TTree*, TTree*) const {return;};

  virtual void   FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
			 AliESDEvent* esd) const;

  virtual void   FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/,
			 AliESDEvent* /*esd*/) const {
                 AliError("Method not implemented"); return;};

  virtual Bool_t HasDigitConversion() const { return kTRUE; }
  virtual void   ConvertDigits(AliRawReader* rawReader,
			       TTree* digitsTree) const;

  static const AliVZERORecoParam* GetRecoParam() { return dynamic_cast<const AliVZERORecoParam*>(AliReconstructor::GetRecoParam(12)); }

  AliCDBStorage     *SetStorage(const char* uri);
  void GetCollisionMode();

  AliVZEROCalibData *GetCalibData() const;
  Float_t            CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const;

  enum {kInvalidADC   =  -1024,
        kInvalidTime  =  -1024};

  AliESDVZERO*    GetESDVZERO() { return fESDVZERO; }

  AliESDVZEROfriend*    GetESDVZEROfriend() { return fESDVZEROfriend; }

protected:
  AliESDVZERO*        fESDVZERO;       // ESD output object
  AliESDEvent*             fESD;       // ESD object
  AliESDVZEROfriend*  fESDVZEROfriend; // ESD friend object (complete raw data)

private:
  AliVZEROReconstructor(const AliVZEROReconstructor& reconstructor);
  AliVZEROReconstructor& operator = (const AliVZEROReconstructor& reconstructor);

  AliVZEROCalibData* fCalibData;      //! calibration data
  AliVZEROTriggerData* fTriggerData;    //! calibration data
  Float_t            fTimeOffset[64]; //! HPTDC time offsets channel by channel
  TF1*               fTimeSlewing;    //! Function for time slewing correction
  TObjArray*         fSaturationCorr; //! Array with functions for correcting the signal saturation
  TH1F*              fEqFactors;      //! Histogram with the equalization factors used in event-plane reconstruction

  Int_t              fCollisionMode;  // =0->p-p, =1->A-A
  Float_t            fBeamEnergy;     // beam energy

  mutable TClonesArray *fDigitsArray; // clones-array for ConvertDigits() and FillESD()

  ClassDef(AliVZEROReconstructor, 5)  // class for the VZERO reconstruction
};

#endif


text:
import { Pipe, PipeTransform, NgModule } from '@angular/core';
import { isString } from '../utils/utils';

@Pipe({
  name: 'split',
})
export class SplitPipe implements PipeTransform {
  transform(input: any, separator: string = ' ', limit?: number): any {
    if (!isString(input)) {
      return input;
    }

    return input.split(separator, limit);
  }
}

@NgModule({
  declarations: [SplitPipe],
  exports: [SplitPipe],
})
export class NgSplitPipeModule {}


text:
"""Utilities derived from the VAT code."""
import tensorflow as tf

def generate_perturbation(x, logit, forward, epsilon, xi=1e-6):
    """Generate an adversarial perturbation.

    Args:
        x: Model inputs.
        logit: Original model output without perturbation.
        forward: Callable which computs logits given input.
        epsilon: Gradient multiplier.
        xi: Small constant.

    Returns:
        Aversarial perturbation to be applied to x.
    """
    d = tf.random_normal(shape=tf.shape(x))

    for _ in range(1):
        d = xi * get_normalized_vector(d)
        logit_p = logit
        logit_m = forward(x + d)
        dist = kl_divergence_with_logit(logit_p, logit_m)
        grad = tf.gradients(tf.reduce_mean(dist), [d], aggregation_method=2)[0]
        d = tf.stop_gradient(grad)

    return epsilon * get_normalized_vector(d)

def kl_divergence_with_logit(q_logit, p_logit):
    """Compute the per-element KL-divergence of a batch."""
    q = tf.nn.softmax(q_logit)
    qlogq = tf.reduce_sum(q * logsoftmax(q_logit), 1)
    qlogp = tf.reduce_sum(q * logsoftmax(p_logit), 1)
    return qlogq - qlogp

def get_normalized_vector(d):
    """Normalize d by infinity and L2 norms."""
    d /= 1e-12 + tf.reduce_max(
        tf.abs(d), list(range(1, len(d.get_shape()))), keepdims=True
    )
    d /= tf.sqrt(
        1e-6
        + tf.reduce_sum(
            tf.pow(d, 2.0), list(range(1, len(d.get_shape()))), keepdims=True
        )
    )
    return d

def logsoftmax(x):
    """Compute log-domain softmax of logits."""
    xdev = x - tf.reduce_max(x, 1, keepdims=True)
    lsm = xdev - tf.log(tf.reduce_sum(tf.exp(xdev), 1, keepdims=True))
    return lsm


text:
module.exports = {
  target: 'server'
}


text:
require 'chef/knife'
require 'open3'

class Chef
  class Knife
    class RoleTest < Chef::Knife

      banner "knife role test [-a|ROLE...]"

      option :all,
        :short => "-a",
        :long => "--all",
        :description => "Test all roles",
        :boolean => true

      def test_pattern
        name_args.map {|x| "^test_role_#{Regexp.escape(x)}$" }.join('|')
      end

      def test_args
        if config[:all]
          []
        elsif name_args.size > 0
          ['-n', "/#{test_pattern}/"]
        else
          ui.fatal "Must specify -a or some roles"
          exit 1
        end
      end

      def run
        test_path = "#{::KnifeRoleTest.root}/lib/knife_role_test/roles.rb"
        env_vars = {
          "KRT_ROLE_PATH" => Chef::Config[:role_path]
        }
        Open3.popen3(env_vars, test_path, *test_args) do |stdin, stdout, stderr, wait_thr|
          stderr_text = stderr.read
          stdout_text = stdout.read
          puts stderr_text
          puts stdout_text
          stdout_text
        end
      end
    end
  end
end


text:
package Servlet;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import Java.Tools;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.RequestDispatcher;

/**
 *
 * @author by-cr
 */
@WebServlet(urlPatterns = {"/Add"})
public class Add extends HttpServlet {

    /**
     * Processes requests for both HTTP GET and POST
     * methods.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        try (PrintWriter out = response.getWriter()) {
            /* TODO output your page here. You may use following sample code. */
             out.println("<!DOCTYPE html>");
            out.println("");
            out.println("");
            out.println("<title>Servlet ModulLagrer</title>");
            out.println("");
            out.println("");
            out.println("
Servlet ModulLagrer at " + request.getContextPath() + "
");

            String first;
            String last;
            String email;
            String status;
            first = request.getParameter("first");
            last = request.getParameter("last");
            email = request.getParameter("email");
            status = request.getParameter("status");
            Tools dbTools = new Tools();
            dbTools.connect();
            dbTools.newUser(first, last, email, status);

            out.println("");
            out.println("");
            RequestDispatcher rd = request.getRequestDispatcher("AddUser");
            rd.forward(request, response);
        }
    }

    // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
    /**
     * Handles the HTTP GET method.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Handles the HTTP POST method.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Returns a short description of the servlet.
     *
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }// </editor-fold>

}


text:
using System;

namespace StackExchange.Opserver.Data.MongoDB
{
    [AttributeUsage(AttributeTargets.Property)]
    public class MongoDBInfoPropertyAttribute : Attribute
    {
        public string PropertyName;
        public MongoDBInfoPropertyAttribute(string propertyName)
        {
            PropertyName = propertyName;
        }
    }
}


text:
package org.neo4j.consistency.checking.full;

import org.neo4j.consistency.checking.CheckerEngine;
import org.neo4j.consistency.checking.RecordCheck;
import org.neo4j.consistency.report.ConsistencyReport;
import org.neo4j.consistency.store.RecordAccess;
import org.neo4j.consistency.store.synthetic.IndexEntry;
import org.neo4j.kernel.impl.store.record.IndexRule;

public class IndexCheck implements RecordCheck<IndexEntry, ConsistencyReport.IndexConsistencyReport>
{
    private final IndexRule indexRule;

    public IndexCheck( IndexRule indexRule )
    {
        this.indexRule = indexRule;
    }

    @Override
    public void check( IndexEntry record, CheckerEngine<IndexEntry, ConsistencyReport.IndexConsistencyReport> engine, RecordAccess records )
    {
        engine.comparativeCheck( records.node( record.getId() ),
                new NodeInUseWithCorrectLabelsCheck<IndexEntry,ConsistencyReport.IndexConsistencyReport>(new long[] {indexRule.getLabel()}) );
    }
}


text:
import getpass
import os
os.system("clear")
pw = getpass.getpass()
minuscula=0
mayuscula=0
numero=0
especial =0
if (len(pw)<5) or (len(pw)>15):
    print("Error, out of range")
for i in pw:
    if (ord(i)>47) and (ord(i)<58):
        numero = 1
    elif (ord(i)>64) and (ord(i)<91):
        mayuscula = 1
    elif (ord(i)>96) and (ord(i)<123):
        minuscula = 1
    else:
        especial = 1
if (minuscula == 1 and mayuscula == 0 and numero == 0 and especial ==0) or (minuscula == 0 and mayuscula == 1 and numero == 0 and especial ==0) or (minuscula == 0 and mayuscula == 0 and numero == 1 and especial ==0):
    print("nivel 1")
elif (minuscula == 1 and mayuscula == 1 and numero == 0 and especial ==0) or (minuscula == 1 and mayuscula == 0 and numero == 1 and especial ==0) or (minuscula == 0 and mayuscula == 1 and numero == 1 and especial ==0):
    print("nivel 2")
elif(minuscula == 1 and mayuscula == 0 and numero == 0 and especial ==1) or (minuscula == 0 and mayuscula == 1 and numero == 0 and especial ==1) or (minuscula == 0 and mayuscula == 0 and numero == 1 and especial ==1):
    print("nivel 3")
elif(minuscula == 1 and mayuscula == 1 and numero == 1 and especial ==0):
    print("nivel 4")
elif(minuscula == 1 and mayuscula == 1 and numero == 1 and especial ==1):
    print("nivel 5")
print(pw)


text:
const { join } = require('path')
const Puck = require(join(__dirname, 'puck'))
const { debug, error } = console
const app = window.angular.module('puck', ['ngMaterial'])

app.controller('puck-controller', function ($scope, $timeout) {
  $scope.devices = {}
  $scope.status = 'none'
  $scope.puck = new Puck()
  $scope.search = function () {
    debug($scope.puck)
    $scope.puck.connect(function (err, ok) {
      $timeout(function () {
        if (err) error(err)
        debug.log(ok)
      })
    })
  }
  $scope.setStatus = function (name, val) {
    $timeout(function () {
      $scope.statusName = name
      $scope.statusValue = val
    })
  }
  $scope.puck.on('error', function () { $scope.setStatus('error', ...arguments) })
  $scope.puck.on('open', function () { $scope.setStatus('open', ...arguments) })
  $scope.puck.on('opening', function () { $scope.setStatus('opening', ...arguments) })
  $scope.puck.on('data', function () { $scope.setStatus('data', ...arguments) })
  $scope.puck.on('device', function () { $scope.setStatus('device', ...arguments) })
  $scope.puck.on('connected', function () { $scope.setStatus('connected', ...arguments) })
  $scope.puck.on('rx', function () { $scope.setStatus('rx', ...arguments) })
  $scope.puck.on('tx', function () { $scope.setStatus('tx', ...arguments) })
})


text:
class GURL;

namespace base {
class FilePath;
}

namespace storage {
class FileStreamReader;
}

namespace storage {
class FileSystemContext;

// A request job that handles reading filesystem: URLs
class STORAGE_EXPORT FileSystemURLRequestJob : public net::URLRequestJob {
 public:
  FileSystemURLRequestJob(
      net::URLRequest* request,
      net::NetworkDelegate* network_delegate,
      const std::string& storage_domain,
      FileSystemContext* file_system_context);

  // URLRequestJob methods:
  void Start() override;
  void Kill() override;
  int ReadRawData(net::IOBuffer* buf, int buf_size) override;
  bool IsRedirectResponse(GURL* location, int* http_status_code) override;
  void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers) override;
  void GetResponseInfo(net::HttpResponseInfo* info) override;
  int GetResponseCode() const override;

  // FilterContext methods (via URLRequestJob):
  bool GetMimeType(std::string* mime_type) const override;

 private:
  class CallbackDispatcher;

  ~FileSystemURLRequestJob() override;

  void StartAsync();
  void DidAttemptAutoMount(base::File::Error result);
  void DidGetMetadata(base::File::Error error_code,
                      const base::File::Info& file_info);
  void DidRead(int result);

  const std::string storage_domain_;
  FileSystemContext* file_system_context_;
  scoped_ptr<storage::FileStreamReader> reader_;
  FileSystemURL url_;
  bool is_directory_;
  scoped_ptr<net::HttpResponseInfo> response_info_;
  int64_t remaining_bytes_;
  net::Error range_parse_result_;
  net::HttpByteRange byte_range_;
  base::WeakPtrFactory<FileSystemURLRequestJob> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(FileSystemURLRequestJob);
};

}  // namespace storage

#endif  // STORAGE_BROWSER_FILEAPI_FILE_SYSTEM_URL_REQUEST_JOB_H_


text:
import os, sys, argparse, os.path, json, time, signal, atexit
from collections import defaultdict
from pixelterm.pixelterm import termify_pixels, reset_sequence
from pixelterm.unpixelterm import unpixelterm
from PIL import Image, PngImagePlugin, GifImagePlugin, ImageSequence
import re

def pixelterm():
	import os, sys, argparse, os.path, json
	from multiprocessing.dummy import Pool
	from PIL import Image, PngImagePlugin

	parser = argparse.ArgumentParser(description='Render pixel images on 256-color ANSI terminals')
	parser.add_argument('image', type=str, nargs='*')
	parser.add_argument('-d', '--output-dir', type=str, help='Output directory (if not given, output to stdout)')
	args = parser.parse_args()

	def convert(f):
		img = Image.open(f).convert("RGBA")
		if args.output_dir:
			print(f)
			foo, _, _ = f.rpartition('.png')
			output = os.path.join(args.output_dir, os.path.basename(foo)+'.pony')
			metadata = json.loads(img.info.get('pixelterm-metadata'))
			comment = metadata.get('_comment')
			if comment is not None:
				del metadata['_comment']
				comment = '\n'+comment
			else:
				comment = ''
			metadataarea = '$$$\n' +\
				'\n'.join([ '\n'.join([ k.upper() + ': ' + v for v in metadata[k] ]) for k in sorted(metadata.keys()) ]) +\
				comment + '\n$$$\n'
			with open(output, 'w') as of:
				of.write(metadataarea)
				of.write(termify_pixels(img))
		else:
			print(termify_pixels(img))

	p = Pool()
	p.map(convert, args.image)

def unpixelterm():
	import argparse, json

	parser = argparse.ArgumentParser(description='Convert images rendered by pixelterm-like utilities back to PNG')
	parser.add_argument('-v', '--verbose', action='store_true')
	output_group = parser.add_mutually_exclusive_group()
	output_group.add_argument('-o', '--output', type=str, help='Output file name, defaults to ${input%.pony}.png')
	output_group.add_argument('-d', '--output-dir', type=str, help='Place output files here')
	parser.add_argument('input', type=argparse.FileType('r'), nargs='+')
	args = parser.parse_args()
	if len(args.input) > 1 and args.output:
		parser.print_help()
		print('You probably do not want to overwrite the given output file {} times.'.format(len(args.input)))
		sys.exit(1)

	for f in args.input:
		if len(args.input) > 1:
			print(f.name)
		img, metadata = unpixelterm(f.read())
		pnginfo = PngImagePlugin.PngInfo()
		pnginfo.add_text('pixelterm-metadata', json.dumps(metadata))
		foo, _, _ = f.name.rpartition('.pony')
		output = args.output or foo+'.png'
		if args.output_dir:
			output = os.path.join(args.output_dir, os.path.basename(output))
		img.save(output, 'PNG', pnginfo=pnginfo)

clear_screen = '\033[H\033[2J'
home_cursor = '\033[H'
cursor_invisible = '\033[?25l'
cursor_visible = '\033[?25h'

def gifterm():
	parser = argparse.ArgumentParser(description='Render pixel images on 256-color ANSI terminals')
	parser.add_argument('image', type=str)
	parser.add_argument('-s', '--size', type=str, help='Terminal size, [W]x[H]')
	parser.add_argument('--serve', type=int, help='Serve via TCP on given port')
	args = parser.parse_args()

	tw, th = None, None
	if args.size:
		tw, th = map(int, args.size.split('x'))
	else:
		try:
			tw, th = os.get_terminal_size()
		except: # If this is not a regular terminal
			pass
	th = th*2

	img = Image.open(args.image)
	palette = img.getpalette()
	last_frame = Image.new("RGBA", img.size)
	frames = []

	for frame in ImageSequence.Iterator(img):
		#This works around a known bug in Pillow
		#See also: http://stackoverflow.com/questions/4904940/python-converting-gif-frames-to-png
		frame.putpalette(palette)
		c = frame.convert("RGBA")

		if img.info['background'] != img.info.get('transparency'):
			last_frame.paste(c, c)
		else:
			last_frame = c

		im = last_frame.copy()
		if (tw, th) != (None, None):
			im.thumbnail((tw, th), Image.NEAREST)
		frames.append(termify_pixels(im, True))

	if args.serve:
		from socketserver import ThreadingMixIn, TCPServer, BaseRequestHandler

		# Quote-Of-The-Day protocol implementation
		# See RFC865 ( https://tools.ietf.org/html/rfc865 ) for details.

		class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

		class QOTDHandler(BaseRequestHandler):
			def handle(self):
				try:
					self.request.sendall(bytes(cursor_invisible, "UTF-8"))
					while True:
						for frame in frames:
							self.request.sendall(bytes(home_cursor + reset_sequence, "UTF-8"))
							self.request.sendall(bytes(frame, "UTF-8"))
							time.sleep(min(1/10, img.info['duration']/1000.0))
				except:
					pass

		server = ThreadingTCPServer(('', args.serve), QOTDHandler)
		server.serve_forever()
	else:
		print(cursor_invisible)
		atexit.register(lambda:print(cursor_visible))
		signal.signal(signal.SIGTERM, lambda signum, stack_frame: exit(1))

		try:
			while True:
				for frame in frames:
					print(home_cursor)
					print(reset_sequence)
					print(frame)
					time.sleep(min(1/10, img.info['duration']/1000.0))
		except KeyboardInterrupt:
			pass

# Display an xterm-256color color palette on the terminal, including color ids

reset_sequence = '\033[39;49m'

def _esc(i):
	return '\033[48;5;'+str(i)+'m'

def colorcube():
	print(''.join([str(i).ljust(4) for i in range(16)]))
	print('    '.join([_esc(i) for i in range(16)])+'    ' + reset_sequence)

	for j in range(6):
		for k in range(6):
			c = 16+j*6+k*6*6
			print(''.join([str(c+i).ljust(4) for i in range(6)]))
			print('    '.join([_esc(c+i) for i in range(6)])+'    ' + reset_sequence)

	print(''.join([str(i).ljust(4) for i in range(16+6*6*6, 16+6*6*6+24)]))
	print('    '.join([_esc(i) for i in range(16+6*6*6, 16+6*6*6+24)])+'    ' + reset_sequence)

def pngmeta():
	parser = argparse.ArgumentParser(description='Print PNG metadata')
	parser.add_argument('image', type=str)
	args = parser.parse_args()
	img = Image.open(args.image)
	for k, v in img.info.items():
		print('{:15}: {}'.format(k, v))

def resolvecolor():
	import os, sys, argparse, os.path, json, re
	from pixelterm.xtermcolors import closest_color

	# Resolve HTML-style hex RGB color codes to xterm-256color color numbers

	if len(sys.argv) != 2:
		print('Usage: resolvecolor.py #RRGGBB')
		exit()

	print(closest_color(*[int(s, 16) for s in re.match('#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})', sys.argv[1]).groups()]))


text:
suite('HTMLHeadElement', function() {

  var wrap = ShadowDOMPolyfill.wrap;

  var div, div2;

  teardown(function() {
    if (div && div.parentNode)
      div.parentNode.removeChild(div);
    if (div2 && div2.parentNode)
      div2.parentNode.removeChild(div2);
    div = div2 = undefined;
  });

  test('appendChild', function() {
    div = document.createElement('div');
    document.head.appendChild(div);
    assert.equal(wrap(document.head.lastChild), div);
  });

  test('appendChild (through wrapper)', function() {
    var doc = wrap(document);
    div = doc.createElement('div');
    doc.body.appendChild(div);
    assert.equal(doc.body.lastChild, div);
  });

  test('insertBefore', function() {
    div = document.createElement('div');
    document.head.appendChild(div);
    div2 = document.createElement('div');
    document.head.insertBefore(div2, div);
    assert.equal(wrap(document.head.lastChild), div);
    assert.equal(div2.nextSibling, div);
    assert.equal(div.previousSibling, div2);
  });

  test('insertBefore (through wrapper)', function() {
    var doc = wrap(document);
    div = doc.createElement('div');
    doc.body.appendChild(div);
    div2 = doc.createElement('div');
    doc.body.insertBefore(div2, div);
    assert.equal(doc.body.lastChild, div);
    assert.equal(div2.nextSibling, div);
    assert.equal(div.previousSibling, div2);
  });

  test('replaceChild', function() {
    div = document.createElement('div');
    document.head.appendChild(div);
    div2 = document.createElement('div');
    document.head.replaceChild(div2, div);
    assert.equal(wrap(document.head.lastChild), div2);
    assert.isNull(div.parentNode);
  });

  test('replaceChild (through wrapper)', function() {
    var doc = wrap(document);
    div = doc.createElement('div');
    doc.body.appendChild(div);
    div2 = doc.createElement('div');
    doc.body.replaceChild(div2, div);
    assert.equal(doc.body.lastChild, div2);
    assert.isNull(div.parentNode);
  });

  test('removeChild', function() {
    div = document.createElement('div');
    document.head.appendChild(div);
    document.head.removeChild(div);
    assert.isNull(div.parentNode);
  });

  test('removeChild (through wrapper)', function() {
    var doc = wrap(document);
    div = doc.createElement('div');
    doc.body.appendChild(div);
    doc.body.removeChild(div);
    assert.isNull(div.parentNode);
  });

  test('document.head.contains', function() {
    var doc = wrap(document);
    assert.isTrue(doc.head.contains(doc.head.firstChild));
    assert.isTrue(doc.head.contains(document.head.firstChild));
    assert.isTrue(document.head.contains(doc.head.firstChild));
    assert.isTrue(document.head.contains(document.head.firstChild));
  });

  test('instanceof', function() {
    assert.instanceOf(document.createElement('head'), HTMLHeadElement);
  });

  test('constructor', function() {
    assert.equal(HTMLHeadElement,
                 document.createElement('head').constructor);
  });

});


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Biologia, Lahore 25(Special Suppl. ): 52 (1982)

#### Original name
Phaeopolynema suttonii N.D. Sharma

### Remarks
null


text:
gem 'minitest'
require 'minitest/autorun'

require_relative '../lib/jacman/utils.rb'

include JacintheManagement

if __FILE__ == $PROGRAM_NAME

  Dir.glob('*_spec.rb') { |f| require_relative f }

end


text:
import React, { useState, useEffect } from 'react'
import { GridList, List, Paper, useMediaQuery } from '@material-ui/core'
import { makeStyles } from '@material-ui/core/styles'
import SearchStore from '../../store/SearchStore'
import SearchPagination from './SearchPagination'
import ItemListItem from './ItemListItem'
import SearchSidebar from './SearchSidebar'

const useStyles = makeStyles({
  header: {
    width: '100%',
  },
  listContainer: {
    width: props => props.isSmall ? '100%' : '74%',
  },
  noItems: {
    color: 'rgba(0, 0, 0, 0.870588)',
    fontStyle: 'italic',
    textAlign: 'center',
  },
})

const SearchDisplayList = () => {
  const sidebar = !!(SearchStore.facets && SearchStore.facets.length)
  const [view, setView] = useState(SearchStore.view)
  const [storeChanged, setStoreChanged] = useState(new Date()) // eslint-disable-line no-unused-vars

  useEffect(() => {
    const action = () => setStoreChanged(new Date())
    SearchStore.on('SearchStoreChanged', action)
    return () => SearchStore.off('SearchStoreChanged', action)
  })

  useEffect(() => {
    const action = () => setView(SearchStore.view)
    SearchStore.on('SearchStoreViewChanged', action)
    return () => SearchStore.off('SearchStoreViewChanged', action)
  })

  const isSmall = useMediaQuery('(max-width: 799px)')
  const isLarge = useMediaQuery('(min-width: 1280px)')
  const classes = useStyles({
    isSmall,
  })

  const gridColumns = isLarge ? 3 : (isSmall ? 1 : 2)
  const itemNodes = SearchStore.items.length ? SearchStore.items.map(item => (
    <ItemListItem key={item.id} item={item} view={view} />
  )) : (

      No matching results could be found.

  )
  return (
    <React.Fragment>
      <Paper className={classes.header} elevation={0}>

Browse Collection

      </Paper>
      {!isSmall && (
        <SearchSidebar show={sidebar} />
      )}
      <Paper className={classes.listContainer} elevation={0}>
        <SearchPagination />
        {view === 'grid' ? (
          <GridList cols={gridColumns} cellHeight='auto' spacing={20}>
            {itemNodes}
          </GridList>
        ) : (
          <List>
            {itemNodes}
          </List>
        )}
        <SearchPagination />
      </Paper>
    </React.Fragment>
  )
}

export default SearchDisplayList


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

namespace Drunkler.Entities
{
    /// <summary>
    /// HomeCinema Rental Info
    /// </summary>
    public class Rental : IEntityBase
    {
        public int ID { get; set; }
        public int CustomerId { get; set; }
        public int StockId { get; set; }
        public virtual Stock Stock { get; set; }
        public DateTime RentalDate { get; set; }
        public Nullable<DateTime> ReturnedDate { get; set; }
        public string Status { get; set; }
    }
}


text:
package org.springframework.boot.logging.log4j2;

import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.DefaultConfiguration;
import org.apache.logging.log4j.core.config.Order;
import org.apache.logging.log4j.core.config.plugins.Plugin;

import org.springframework.boot.logging.LoggingSystem;

/**
 * Spring Boot {@link ConfigurationFactory} that customizes Log4J2's default configuration
 * to:
 *
 *

 *
Prevent logger warnings from being printed when the application first starts.
 *
Disable its shutdown hook
 *

 *
 * This factory is ordered last and is triggered by a {@code log4j2.springboot} classpath
 * resource (which is bundled in this jar). If the {@link Log4J2LoggingSystem} is active,
 * a custom {@link DefaultConfiguration} is returned with the expectation that the system
 * will later re-initialize Log4J2 with the correct configuration file.
 *
 * @author Phillip Webb
 * @since 1.5.0
 */
@Plugin(name = "SpringBootConfigurationFactory", category = ConfigurationFactory.CATEGORY)
@Order(0)
public class SpringBootConfigurationFactory extends ConfigurationFactory {

	private static final String[] TYPES = { ".springboot" };

	@Override
	protected String[] getSupportedTypes() {
		return TYPES;
	}

	@Override
	public Configuration getConfiguration(LoggerContext loggerContext,
			ConfigurationSource source) {
		if (source != null && source != ConfigurationSource.NULL_SOURCE
				&& LoggingSystem.get(loggerContext.getClass().getClassLoader()) != null) {
			return new SpringBootConfiguration();
		}
		return null;
	}

	private static final class SpringBootConfiguration extends DefaultConfiguration {

		private SpringBootConfiguration() {
			this.isShutdownHookEnabled = false;
		}

	}

}


text:
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// Eigen is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// Alternatively, you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.

#ifndef EIGEN_REDUX_H
#define EIGEN_REDUX_H

// TODO
//  * implement other kind of vectorization
//  * factorize code

/***************************************************************************
* Part 1 : the logic deciding a strategy for vectorization and unrolling
***************************************************************************/

template<typename Func, typename Derived>
struct ei_redux_traits
{
public:
  enum {
    PacketSize = ei_packet_traits<typename Derived::Scalar>::size,
    InnerMaxSize = int(Derived::IsRowMajor)
                 ? Derived::MaxColsAtCompileTime
                 : Derived::MaxRowsAtCompileTime
  };

  enum {
    MightVectorize = (int(Derived::Flags)&ActualPacketAccessBit)
                  && (ei_functor_traits<Func>::PacketAccess),
    MayLinearVectorize = MightVectorize && (int(Derived::Flags)&LinearAccessBit),
    MaySliceVectorize  = MightVectorize && int(InnerMaxSize)>=3*PacketSize
  };

public:
  enum {
    Traversal = int(MayLinearVectorize) ? int(LinearVectorizedTraversal)
              : int(MaySliceVectorize)  ? int(SliceVectorizedTraversal)
                                        : int(DefaultTraversal)
  };

public:
  enum {
    Cost = (  Derived::SizeAtCompileTime == Dynamic
           || Derived::CoeffReadCost == Dynamic
           || (Derived::SizeAtCompileTime!=1 && ei_functor_traits<Func>::Cost == Dynamic)
           ) ? Dynamic
           : Derived::SizeAtCompileTime * Derived::CoeffReadCost
               + (Derived::SizeAtCompileTime-1) * ei_functor_traits<Func>::Cost,
    UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize))
  };

public:
  enum {
    Unrolling = Cost != Dynamic && Cost <= UnrollingLimit
              ? CompleteUnrolling
              : NoUnrolling
  };
};

/***************************************************************************
* Part 2 : unrollers
***************************************************************************/

/*** no vectorization ***/

template<typename Func, typename Derived, int Start, int Length>
struct ei_redux_novec_unroller
{
  enum {
    HalfLength = Length/2
  };

  typedef typename Derived::Scalar Scalar;

  EIGEN_STRONG_INLINE static Scalar run(const Derived &mat, const Func& func)
  {
    return func(ei_redux_novec_unroller<Func, Derived, Start, HalfLength>::run(mat,func),
                ei_redux_novec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func));
  }
};

template<typename Func, typename Derived, int Start>
struct ei_redux_novec_unroller<Func, Derived, Start, 1>
{
  enum {
    outer = Start / Derived::InnerSizeAtCompileTime,
    inner = Start % Derived::InnerSizeAtCompileTime
  };

  typedef typename Derived::Scalar Scalar;

  EIGEN_STRONG_INLINE static Scalar run(const Derived &mat, const Func&)
  {
    return mat.coeffByOuterInner(outer, inner);
  }
};

// This is actually dead code and will never be called. It is required
// to prevent false warnings regarding failed inlining though
// for 0 length run() will never be called at all.
template<typename Func, typename Derived, int Start>
struct ei_redux_novec_unroller<Func, Derived, Start, 0>
{
  typedef typename Derived::Scalar Scalar;
  EIGEN_STRONG_INLINE static Scalar run(const Derived&, const Func&) { return Scalar(); }
};

/*** vectorization ***/

template<typename Func, typename Derived, int Start, int Length>
struct ei_redux_vec_unroller
{
  enum {
    PacketSize = ei_packet_traits<typename Derived::Scalar>::size,
    HalfLength = Length/2
  };

  typedef typename Derived::Scalar Scalar;
  typedef typename ei_packet_traits<Scalar>::type PacketScalar;

  EIGEN_STRONG_INLINE static PacketScalar run(const Derived &mat, const Func& func)
  {
    return func.packetOp(
            ei_redux_vec_unroller<Func, Derived, Start, HalfLength>::run(mat,func),
            ei_redux_vec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func) );
  }
};

template<typename Func, typename Derived, int Start>
struct ei_redux_vec_unroller<Func, Derived, Start, 1>
{
  enum {
    index = Start * ei_packet_traits<typename Derived::Scalar>::size,
    outer = index / int(Derived::InnerSizeAtCompileTime),
    inner = index % int(Derived::InnerSizeAtCompileTime),
    alignment = (Derived::Flags & AlignedBit) ? Aligned : Unaligned
  };

  typedef typename Derived::Scalar Scalar;
  typedef typename ei_packet_traits<Scalar>::type PacketScalar;

  EIGEN_STRONG_INLINE static PacketScalar run(const Derived &mat, const Func&)
  {
    return mat.template packetByOuterInner<alignment>(outer, inner);
  }
};

/***************************************************************************
* Part 3 : implementation of all cases
***************************************************************************/

template<typename Func, typename Derived,
         int Traversal = ei_redux_traits<Func, Derived>::Traversal,
         int Unrolling = ei_redux_traits<Func, Derived>::Unrolling
>
struct ei_redux_impl;

template<typename Func, typename Derived>
struct ei_redux_impl<Func, Derived, DefaultTraversal, NoUnrolling>
{
  typedef typename Derived::Scalar Scalar;
  typedef typename Derived::Index Index;
  static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func)
  {
    ei_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
    Scalar res;
    res = mat.coeffByOuterInner(0, 0);
    for(Index i = 1; i < mat.innerSize(); ++i)
      res = func(res, mat.coeffByOuterInner(0, i));
    for(Index i = 1; i < mat.outerSize(); ++i)
      for(Index j = 0; j < mat.innerSize(); ++j)
        res = func(res, mat.coeffByOuterInner(i, j));
    return res;
  }
};

template<typename Func, typename Derived>
struct ei_redux_impl<Func,Derived, DefaultTraversal, CompleteUnrolling>
  : public ei_redux_novec_unroller<Func,Derived, 0, Derived::SizeAtCompileTime>
{};

template<typename Func, typename Derived>
struct ei_redux_impl<Func, Derived, LinearVectorizedTraversal, NoUnrolling>
{
  typedef typename Derived::Scalar Scalar;
  typedef typename ei_packet_traits<Scalar>::type PacketScalar;
  typedef typename Derived::Index Index;

  static Scalar run(const Derived& mat, const Func& func)
  {
    const Index size = mat.size();
    ei_assert(size && "you are using an empty matrix");
    const Index packetSize = ei_packet_traits<Scalar>::size;
    const Index alignedStart = ei_first_aligned(mat);
    enum {
      alignment = (Derived::Flags & DirectAccessBit) || (Derived::Flags & AlignedBit)
                ? Aligned : Unaligned
    };
    const Index alignedSize = ((size-alignedStart)/packetSize)*packetSize;
    const Index alignedEnd = alignedStart + alignedSize;
    Scalar res;
    if(alignedSize)
    {
      PacketScalar packet_res = mat.template packet<alignment>(alignedStart);
      for(Index index = alignedStart + packetSize; index < alignedEnd; index += packetSize)
        packet_res = func.packetOp(packet_res, mat.template packet<alignment>(index));
      res = func.predux(packet_res);

      for(Index index = 0; index < alignedStart; ++index)
        res = func(res,mat.coeff(index));

      for(Index index = alignedEnd; index < size; ++index)
        res = func(res,mat.coeff(index));
    }
    else // too small to vectorize anything.
         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
    {
      res = mat.coeff(0);
      for(Index index = 1; index < size; ++index)
        res = func(res,mat.coeff(index));
    }

    return res;
  }
};

template<typename Func, typename Derived>
struct ei_redux_impl<Func, Derived, SliceVectorizedTraversal, NoUnrolling>
{
  typedef typename Derived::Scalar Scalar;
  typedef typename ei_packet_traits<Scalar>::type PacketScalar;
  typedef typename Derived::Index Index;

  static Scalar run(const Derived& mat, const Func& func)
  {
    ei_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
    const Index innerSize = mat.innerSize();
    const Index outerSize = mat.outerSize();
    enum {
      packetSize = ei_packet_traits<Scalar>::size
    };
    const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize;
    Scalar res;
    if(packetedInnerSize)
    {
      PacketScalar packet_res = mat.template packet<Unaligned>(0,0);
      for(Index j=0; j<outerSize; ++j)
        for(Index i=(j==0?packetSize:0); i<packetedInnerSize; i+=Index(packetSize))
          packet_res = func.packetOp(packet_res, mat.template packetByOuterInner<Unaligned>(j,i));

      res = func.predux(packet_res);
      for(Index j=0; j<outerSize; ++j)
        for(Index i=packetedInnerSize; i<innerSize; ++i)
          res = func(res, mat.coeffByOuterInner(j,i));
    }
    else // too small to vectorize anything.
         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
    {
      res = ei_redux_impl<Func, Derived, DefaultTraversal, NoUnrolling>::run(mat, func);
    }

    return res;
  }
};

template<typename Func, typename Derived>
struct ei_redux_impl<Func, Derived, LinearVectorizedTraversal, CompleteUnrolling>
{
  typedef typename Derived::Scalar Scalar;
  typedef typename ei_packet_traits<Scalar>::type PacketScalar;
  enum {
    PacketSize = ei_packet_traits<Scalar>::size,
    Size = Derived::SizeAtCompileTime,
    VectorizedSize = (Size / PacketSize) * PacketSize
  };
  EIGEN_STRONG_INLINE static Scalar run(const Derived& mat, const Func& func)
  {
    ei_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
    Scalar res = func.predux(ei_redux_vec_unroller<Func, Derived, 0, Size / PacketSize>::run(mat,func));
    if (VectorizedSize != Size)
      res = func(res,ei_redux_novec_unroller<Func, Derived, VectorizedSize, Size-VectorizedSize>::run(mat,func));
    return res;
  }
};

/** \returns the result of a full redux operation on the whole matrix or vector using \a func
  *
  * The template parameter \a BinaryOp is the type of the functor \a func which must be
  * an associative operator. Both current STL and TR1 functor styles are handled.
  *
  * \sa DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise()
  */
template<typename Derived>
template<typename Func>
EIGEN_STRONG_INLINE typename ei_result_of<Func(typename ei_traits<Derived>::Scalar)>::type
DenseBase<Derived>::redux(const Func& func) const
{
  typedef typename ei_cleantype<typename Derived::Nested>::type ThisNested;
  return ei_redux_impl<Func, ThisNested>
            ::run(derived(), func);
}

/** \returns the minimum of all coefficients of *this
  */
template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
DenseBase<Derived>::minCoeff() const
{
  return this->redux(Eigen::ei_scalar_min_op<Scalar>());
}

/** \returns the maximum of all coefficients of *this
  */
template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
DenseBase<Derived>::maxCoeff() const
{
  return this->redux(Eigen::ei_scalar_max_op<Scalar>());
}

/** \returns the sum of all coefficients of *this
  *
  * \sa trace(), prod(), mean()
  */
template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
DenseBase<Derived>::sum() const
{
  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
    return Scalar(0);
  return this->redux(Eigen::ei_scalar_sum_op<Scalar>());
}

/** \returns the mean of all coefficients of *this
*
* \sa trace(), prod(), sum()
*/
template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
DenseBase<Derived>::mean() const
{
  return Scalar(this->redux(Eigen::ei_scalar_sum_op<Scalar>())) / Scalar(this->size());
}

/** \returns the product of all coefficients of *this
  *
  * Example: \include MatrixBase_prod.cpp
  * Output: \verbinclude MatrixBase_prod.out
  *
  * \sa sum(), mean(), trace()
  */
template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
DenseBase<Derived>::prod() const
{
  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
    return Scalar(1);
  return this->redux(Eigen::ei_scalar_product_op<Scalar>());
}

/** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal.
  *
  * \c *this can be any matrix, not necessarily square.
  *
  * \sa diagonal(), sum()
  */
template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::trace() const
{
  return derived().diagonal().sum();
}

#endif // EIGEN_REDUX_H


text:
import {ActivatedRouteSnapshot, Resolve, RouterStateSnapshot} from '@angular/router';
import {Observable} from 'rxjs/Observable';
import {ServersService} from '../servers.service';
import {Injectable} from '@angular/core';

interface Server {
  id: number;
  name: string;
  status: string;
}

@Injectable()
export class ServerResolverService implements Resolve<Server> {

  constructor(private serversService: ServersService) {
  }

  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Server> | Promise<Server> | Server {

    return this.serversService.getServer(+route.params['id']);
  }
}


text:
This directory contains a mock ICD driver designed for validation layer testing.

## Introduction

The mock ICD is focused on enabling validation testing apart from an actual device. Because the validation layers
sit on top of the ICD and don't depend upon the results of Vulkan rendering, they can be tested without having actual
GPU hardware backing the ICD. The final mock driver will be composed of three main features: a null driver, flexible
device configuration, and entrypoint tracking & verification.

### Null Driver
The intial mock driver features just the null driver capability. This allows all of the validation tests to be run
on a fixed device configuration that is hard-coded into the ICD.

### Device Configuration
Device configuration can be added by running the DevSim layer below the validation layers, but above the mock driver.
The current plan is that if device customization beyond DevSim's capabilities are required for validation layer testing
then the DevSim layer will be enhanced with the required features. The mock layer itself is just planned to have some
hard-coded device settings that will enable it to run all of the validation tests.

### Entrypoint Tracking & Verification
Entrypoint tracking and verification will be added to the mock layer as a later feature. The idea is that all expected
Vulkan function calls and their parameters can be stored in the ICD and then a separate call can be made to verify that
the exepected calls and parameters actually entered the ICD. This allows verification that the validation layers are
correctly passing calls and their parameters through to the ICD unchanged.

## Using the Mock ICD

To enable the mock ICD, set VK\_ICD\_FILENAMES environment variable to point to your {BUILD_DIR}/icd/VkICD\_mock\_icd.json.

## Plans

The initial mock ICD is just the null driver which can be used in combination with DevSim to test validation layers on
simulated devices. Here's a rough sequence of tasks planned for the mock driver going forward:
- [X] Get all LVL tests passing on the bare null driver
- [X] Get failing tests passing
- [X] Get skipped tests passing as able
- [ ] Get all LVL tests to run without unexpected errors
- [X] Develop automated test flow using mock ICD (alternative to or replacement for run\_all\_tests.sh)
- [X] Get all LVL tests to pass on a selection of device profiles using DevSim layer
- [ ] Update LVL tests with device dependencies to target specific device profiles
- [ ] Add entrypoint tracking & verification
- [ ] Initially track expected calls
- [ ] Update some tests to verify expected capability
- [ ] Expand tracking to include parameters

## Beyond Validation Layer Testing

The focus of the mock icd is for validation testing, but the code is available to use and enhance for anyone wishing to apply it for alternative
purposes.
With the following enhancements, the mock driver state available to the app should very closely mimic an actual ICD:
- Update various function return codes
- Simulated synchronization objects
- Simulated query with mock data
- Basic command buffer state tracking to note synch object transitions and query state updates

Beyond that it's certainly possible that the mock icd could be hooked up to a SW renderer and serve as a virtual GPU with complete rendering/compute
capabilities.

## Status

This is a temporary section used for tracking as the mock icd is being developed. Once all tests are passing with the mock, this section can be removed.
Currently 333/333 tests are passing with the mock icd, but many passing tests have unexpected validation errors that need to be cleaned up.

### Failing Tests

NONE

### Passing Tests With Unexpected Errors

- VkLayerTest.RenderPassInUseDestroyedSignaled
- VkLayerTest.RenderPassIncompatible

### Skipped Tests

- VkLayerTest.BindImageInvalidMemoryType
- VkLayerTest.CreatePipelineBadVertexAttributeFormat
- VkLayerTest.MiscBlitImageTests
- VkLayerTest.TemporaryExternalSemaphore
- VkLayerTest.TemporaryExternalFence
- VkLayerTest.InvalidBarriers
- VkLayerTest.CommandQueueFlags
- VkPositiveLayerTest.TwoQueuesEnsureCorrectRetirementWithWorkStolen
- VkPositiveLayerTest.ExternalSemaphore
- VkPositiveLayerTest.ExternalFence
- VkPositiveLayerTest.ExternalMemory