text:
package ariba.util.fieldvalue;

import java.util.Map;

/**
    The Extensible interface can be implemented when a given class
    wants to provide dynamically added fields.  Once this is implemented
    to return a Map, the FieldValue system will be able to look in
    the Map to see if the desired field exists.

    One restriction applies for extensible fields -- you must set the value
    of the field before attempting to access itr, else an exception will
    be thrown.

    @aribaapi private

*/
public interface Extensible
{
    /**
    Returns the Map in which the dynamically added fields reside.
    */
    public Map extendedFields ();
}

redpajama_set_name: RedPajamaGithub


text:
ARDUINO_LIBS = SPI IRremote
OTHER_LIBS = bitlash SdFat-beta/SdFat SdFat-beta/SdFat/utility base64
ARDUINO_SKETCHBOOK = ../
EXTRA_FLAGS = -DIR_RAWBUF=256 -DBITLASH_INTERNAL -DBITLASH_PROMPT='">\r\n"' -DSDFILE
ARDUINO_DIR=../../ide

ifneq ($(board),)
	BOARD=$(board)
else
	BOARD=teensy3
endif

ifeq ($(BOARD),teensy3)

USER_LIBS = $(OTHER_LIBS)
OPTIONS = $(EXTRA_FLAGS) -DLAYOUT_US_ENGLISH -DUSB_SERIAL

include ../Teensy.mk

else

ARDUINO_LIBS += $(OTHER_LIBS)
EXTRA_FLAGS += -DTINY_BUILD -DUSER_FUNCTIONS -DBAUD_RATE=9600 -DARDUINO_TIMER_SCALE=1

ifeq ($(BOARD),pro2)
    BOARD = pro5v328
	EXTRA_FLAGS += -DBOARD_PRO2
endif
ifeq ($(BOARD),nano3)
    BOARD = nano328
endif
BOARD_TAG = $(BOARD)

include ../Arduino-Makefile/Arduino.mk

endif


text:
Installation / Setup
=====================

On versions of Ubuntu greater than 16.0, you need to install a few system
packages first:

.. code-block:: bash

    $ sudo apt-get install libffi-dev libssl-dev

Nautilus is availible using pip:

.. code-block:: bash

    $ pip install nautilus

Necessary Background Processes
-------------------------------

In order to run a nautilus cloud, you must have kafka running on your local machine. For more information on
kafka including how to run it locally, go `here <http://www.bogotobogo.com/Hadoop/BigData_hadoop_Zookeeper_Kafka_single_node_single_broker_cluster.php>`_.


text:
project_path: /web/_project.yaml
book_path: /web/tools/_book.yaml
description: Documentación de referencia para la auditoría de Lighthouse "El sitio no usa eventos de mutación en sus propias secuencias de comandos".

{# wf_updated_on: 2016-10-04 #}
{# wf_published_on: 2016-10-04 #}

# El sitio no usa eventos de mutación en sus propias secuencias de comandos  {: .page-title }

## Por qué es importante la auditoría {: #why }

Los siguientes eventos de mutación afectan negativamente el rendimiento y dejaron de estar disponibles en las
especificaciones de los eventos del DOM:

* `DOMAttrModified`
* `DOMAttributeNameChanged`
* `DOMCharacterDataModified`
* `DOMElementNameChanged`
* `DOMNodeInserted`
* `DOMNodeInsertedIntoDocument`
* `DOMNodeRemoved`
* `DOMNodeRemovedFromDocument`
* `DOMSubtreeModified`

## Cómo aprobar la auditoría {: #how }

En **URLs**, Lighthouse informa los detectores de eventos de mutación que encontró en
tu código. Reemplaza cada uno de estos eventos de mutación con `MutationObserver`.
Consulta [`MutationObserver`][mdn] en MDN para obtener más información.

[mdn]: https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver

{% include "web/tools/lighthouse/audits/implementation-heading.html" %}

Lighthouse recopila todos los detectores de eventos de la página y marca
aquellos que usan los tipos de eventos indicados en la sección [Por qué es
importante la auditoría](#why).

{# wf_devsite_translation #}


text:
namespace VertexAsylum
{

    class vaRenderingGlobalsDX11 : public vaRenderingGlobals, VertexAsylum::vaDirectXNotifyTarget
    {
        VA_RENDERING_MODULE_MAKE_FRIENDS( );

    private:

        vaDirectXConstantsBuffer < ShaderGlobalConstants >
                                        m_constantsBuffer;

    private:
        vaRenderingGlobalsDX11( const vaConstructorParamsBase * params );
        ~vaRenderingGlobalsDX11( );

    public:
        const shared_ptr<vaTexture> &   GetCurrentShaderDebugOutput( );
        ID3D11UnorderedAccessView *     GetCurrentShaderDebugOutputUAV( );

    private:
        // vaDirectXNotifyTarget
        virtual void                    OnDeviceCreated( ID3D11Device* device, IDXGISwapChain* swapChain );
        virtual void                    OnDeviceDestroyed( );

    private:
        // vaRenderingGlobals
        virtual void                    SetAPIGlobals( vaDrawContext & drawContext );
        virtual void                    UpdateDebugOutputFloats( vaDrawContext & drawContext );
    };
}


text:
This is an empty repository ... used by tests when they write test packages.

All of the property files in this repository shoudl be written using a
`.ston` extension.


text:
package no.uib.mitraq.util;

import java.awt.Component;
import java.awt.Rectangle;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import javax.swing.JComponent;
import org.apache.batik.dom.svg.SVGDOMImplementation;
import org.apache.batik.svggen.SVGGraphics2D;
import org.apache.batik.transcoder.Transcoder;
import org.apache.batik.transcoder.TranscoderException;
import org.apache.batik.transcoder.TranscoderInput;
import org.apache.batik.transcoder.TranscoderOutput;
import org.apache.batik.transcoder.image.JPEGTranscoder;
import org.apache.batik.transcoder.image.PNGTranscoder;
import org.apache.batik.transcoder.image.TIFFTranscoder;
import org.apache.fop.svg.PDFTranscoder;
import org.jfree.chart.JFreeChart;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.svg.SVGDocument;

/**
 * Includes export to figure formats for Components and JFreeCharts.
 *
 * @author  Harald Barsnes
 */
public class Export {

    /**
     * Exports the contents of a JFreeChart to an svg, png, pdf etc.
     *
     * @param chart chart to export
     * @param bounds the dimensions of the viewport
     * @param exportFile the output file
     * @param imageType the image type
     * @throws IOException
     * @throws TranscoderException
     */
    public static void exportChart(JFreeChart chart, Rectangle bounds, File exportFile, ImageType imageType)
            throws IOException, TranscoderException {

        // draw the component in the SVG graphics
        SVGGraphics2D svgGenerator = drawSvgGraphics(chart, bounds);

        // export the plot
        exportPlot(exportFile, imageType, svgGenerator);
    }

    /**
     * Exports the contents of a Component to an svg, png, pdf etc.
     *
     * @param component component to export
     * @param bounds the dimensions of the viewport
     * @param exportFile the output file
     * @param imageType the image type
     * @throws IOException
     * @throws TranscoderException
     */
    public static void exportComponent(Component component, Rectangle bounds, File exportFile, ImageType imageType)
            throws IOException, TranscoderException {

        // draw the component in the SVG graphics
        SVGGraphics2D svgGenerator = drawSvgGraphics(component, bounds);

        // export the plot
        exportPlot(exportFile, imageType, svgGenerator);
    }

    /**
     * Draws the selected component (assumed to be a Component) into the provided
     * SVGGraphics2D object.
     *
     * @param component
     * @param bounds
     */
    private static SVGGraphics2D drawSvgGraphics(Object component, Rectangle bounds) {

        // Get a SVGDOMImplementation and create an XML document
        DOMImplementation domImpl = SVGDOMImplementation.getDOMImplementation();
        String svgNS = "http://www.w3.org/2000/svg";
        SVGDocument svgDocument = (SVGDocument) domImpl.createDocument(svgNS, "svg", null);

        // Create an instance of the SVG Generator
        SVGGraphics2D svgGenerator = new SVGGraphics2D(svgDocument);
        svgGenerator.setSVGCanvasSize(bounds.getSize());

        // draw the panel in the SVG generator
        if (component instanceof JFreeChart) {
            ((JFreeChart) component).draw(svgGenerator, bounds);
        } else if (component instanceof JComponent) {
            ((JComponent) component).paintAll(svgGenerator);
        }

        return svgGenerator;
    }

    /**
     * Exports the selected file to the wanted format.
     *
     * @param exportFile
     * @param imageType
     * @param svgGenerator
     * @throws IOException
     * @throws TranscoderException
     */
    private static void exportPlot(File exportFile, ImageType imageType, SVGGraphics2D svgGenerator)
            throws IOException, TranscoderException {

        // write the svg file
        File svgFile = exportFile;

        if (imageType != ImageType.SVG) {
            svgFile = new File(exportFile.getAbsolutePath() + ".temp");
        }

        OutputStream outputStream = new FileOutputStream(svgFile);
        Writer out = new OutputStreamWriter(outputStream, "UTF-8");
        svgGenerator.stream(out, true /* use css */);
        outputStream.flush();
        outputStream.close();

        // if selected image format is not svg, convert the image
        if (imageType != ImageType.SVG) {

            // set up the svg input
            String svgURI = svgFile.toURI().toString();
            TranscoderInput svgInputFile = new TranscoderInput(svgURI);

            OutputStream outstream = new FileOutputStream(exportFile);
            TranscoderOutput output = new TranscoderOutput(outstream);

            if (imageType == ImageType.PDF) {

                // write as pdf
                Transcoder pdfTranscoder = new PDFTranscoder();
                pdfTranscoder.addTranscodingHint(PDFTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, new Float(0.084666f));
                pdfTranscoder.transcode(svgInputFile, output);

            } else if (imageType == ImageType.JPEG) {

                // write as jpeg
                Transcoder jpegTranscoder = new JPEGTranscoder();
                jpegTranscoder.addTranscodingHint(JPEGTranscoder.KEY_QUALITY, new Float(1.0));
                jpegTranscoder.transcode(svgInputFile, output);

            } else if (imageType == ImageType.TIFF) {

                // write as tiff
                Transcoder tiffTranscoder = new TIFFTranscoder();
                tiffTranscoder.addTranscodingHint(TIFFTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, new Float(0.084666f));
                tiffTranscoder.addTranscodingHint(TIFFTranscoder.KEY_FORCE_TRANSPARENT_WHITE, true);
                tiffTranscoder.transcode(svgInputFile, output);

            } else if (imageType == ImageType.PNG) {

                // write as png
                Transcoder pngTranscoder = new PNGTranscoder();
                pngTranscoder.addTranscodingHint(PNGTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, new Float(0.084666f));
                pngTranscoder.transcode(svgInputFile, output);

            }

            //close the stream
            outstream.flush();
            outstream.close();

            // delete the svg file given that the selected format is not svg
            if (svgFile.exists()) {
                svgFile.delete();
            }
        }
    }
}


text:
<?php

/**
 * @namespace
 */
namespace Application\UsersToRoles;

/**
 * User
 *
 * @category Application
 * @package  Roles
 */
class Row extends \Bluz\Db\Row
{
    /**
     * @var integer
     */
    public $userId;

    /**
     * @var integer
     */
    public $roleId;
}


text:
package test.aperture.web.rest;

import aperture.config.SpringBootApertureApiTestConfiguration;
import aperture.model.Room;
import aperture.repository.RoomRepository;
import aperture.service.RoomService;
import aperture.web.rest.RoomResource;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

/**
 * Tests on room rest resource.
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootApertureApiTestConfiguration.class)
public class RoomResourceTests {
    @Autowired
    private MappingJackson2HttpMessageConverter jacksonMessageConverter;

    @Autowired
    private RoomService roomService;

    @Autowired
    private RoomRepository roomRepository;

    private MockMvc mockMvc;

    // -- Variables used for tests
    private static final int FOURTYTWO = 42;
    private static final int EIGHT = 8888;

    private Room room42 = new Room("5063114bd386d8fadbd6b00a",
        FOURTYTWO,
        "Answer to life room"
    );
    private Room room42Updated = new Room("5063114bd386d8fadbd6b00a",
        FOURTYTWO,
        "Answer to life room updated"
    );
    private Room roomWrongUpdated = new Room("5063114bd386d8fadb",
        FOURTYTWO,
        "WRONG ROOM"
    );
    private Room newRoom = new Room("0",
        EIGHT,
        "ADD ROOM TEST"
    );

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);

        RoomResource roomResource = new RoomResource(roomService, roomRepository);

        this.mockMvc = MockMvcBuilders.standaloneSetup(roomResource)
            .setMessageConverters(jacksonMessageConverter)
            .build();

        TestUtil.executeAllMongeezScripts();
    }

    // -- HttpStatus codes tests

    @Test
    public void shouldReturn200RoomsRoute() throws Exception {
        mockMvc.perform(get("/api/rooms"))
            .andExpect(status().isOk());
    }

    @Test
    public void shouldReturn200RoomsIdFoundRoute() throws Exception {
        mockMvc.perform(get("/api/rooms/id/" + room42.getId()))
            .andExpect(status().isOk());
    }

    @Test
    public void shouldReturn204RoomsIdNotFoundRoute() throws Exception {
        mockMvc.perform(get("/api/rooms/id/42"))
            .andExpect(status().isNoContent());
    }

    // -- Content returned tests

    @Test
    public void shouldReturnElementsAndRoom42RoomsRoute() throws Exception {
        String jsonPathExpression = "$.[?(@.id==\"" + room42.getId() + "\")]";

        mockMvc.perform(get("/api/rooms"))
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$").isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression + ".name").value(room42.getName()))
            .andExpect(jsonPath(jsonPathExpression + ".number").value(room42.getNumber()));
    }

    @Test
    public void shouldReturnElementRoomsIdRoute() throws Exception {
        String jsonPathExpression = "$.[?(@.id==\"" + room42.getId() + "\")]";

        mockMvc.perform(get("/api/rooms/id/" + room42.getId()))
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$").isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression + ".name").value(room42.getName()))
            .andExpect(jsonPath(jsonPathExpression + ".number").value(room42.getNumber()));
    }

    @Test
    public void shouldReturnElementRoomsNumberRoute() throws Exception {
        String jsonPathExpression = "$.[?(@.number==\"" + room42.getNumber() + "\")]";

        mockMvc.perform(get("/api/rooms/number/" + room42.getNumber()))
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$").isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression + ".name").value(room42.getName()))
            .andExpect(jsonPath(jsonPathExpression + ".id").value(room42.getId()));
    }

    @Test
    public void shouldReturnElementRoomsNameRoute() throws Exception {
        String jsonPathExpression = "$.[?(@.name==\"" + room42.getName() + "\")]";

        mockMvc.perform(post("/api/rooms/name").param("name", room42.getName()))
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$").isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty())
            .andExpect(jsonPath(jsonPathExpression + ".name").value(room42.getName()))
            .andExpect(jsonPath(jsonPathExpression + ".id").value(room42.getId()));
    }

    // -- Mutability handling operations tests (Create/Delete/Update)

    @Test
    public void should200AndReturnNewRoomWithIdCreateRoute() throws Exception {
        String jsonPathExpression = "$.[?(@.name==\"" + newRoom.getName() + "\")]";
        int databaseSizeBeforeCreate = roomRepository.findAll().size();

        mockMvc.perform(post("/api/rooms/create")
            .contentType(TestUtil.APPLICATION_JSON_UTF8)
            .content(TestUtil.convertObjectToJsonBytes(newRoom))
        )
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty());

        int databaseSizeAfterCreate = roomRepository.findAll().size();
        assertThat(databaseSizeAfterCreate > databaseSizeBeforeCreate);
    }

    @Test
    public void should400NewRoomWithExistantNumberCreateRoute() throws Exception {
        int databaseSizeBeforeCreate = roomRepository.findAll().size();

        mockMvc.perform(post("/api/rooms/create")
            .contentType(TestUtil.APPLICATION_JSON_UTF8)
            .content(TestUtil.convertObjectToJsonBytes(room42))
        )
            .andExpect(status().isBadRequest());

        int databaseSizeAfterCreate = roomRepository.findAll().size();
        assertThat(databaseSizeAfterCreate == databaseSizeBeforeCreate);
    }

    @Test
    public void should200AndReturnUpdatedRoom() throws Exception {
        String jsonPathExpression = "$.[?(@.name==\"" + room42Updated.getName() + "\")]";

        mockMvc.perform(put("/api/rooms/update")
            .contentType(TestUtil.APPLICATION_JSON_UTF8)
            .content(TestUtil.convertObjectToJsonBytes(room42Updated))
        )
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty());
    }

    @Test
    public void should400UpdateInexistantRoom() throws Exception {
        mockMvc.perform(put("/api/rooms/update")
            .contentType(TestUtil.APPLICATION_JSON_UTF8)
            .content(TestUtil.convertObjectToJsonBytes(roomWrongUpdated))
        )
            .andExpect(status().isBadRequest());
    }

    @Test
    public void should200AndReturnDeletedRoomWithIdDeleteRoute() throws Exception {
        String jsonPathExpression = "$.[?(@.name==\"" + room42.getName() + "\")]";
        int databaseSizeBeforeDelete = roomRepository.findAll().size();

        mockMvc.perform(delete("/api/rooms/delete/" + room42.getId()))
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath(jsonPathExpression).isNotEmpty());

        int databaseSizeAfterDelete = roomRepository.findAll().size();
        assertThat(databaseSizeAfterDelete < databaseSizeBeforeDelete);
    }

    @Test
    public void should400DeleteInexistantRoomDeleteRoute() throws Exception {
        int databaseSizeBeforeDelete = roomRepository.findAll().size();

        mockMvc.perform(delete("/api/rooms/delete/perlimpinpin"))
            .andExpect(status().isBadRequest());

        int databaseSizeAfterDelete = roomRepository.findAll().size();
        assertThat(databaseSizeAfterDelete == databaseSizeBeforeDelete);
    }

}


text:
//
// Novell.Directory.Ldap.Asn1.Asn1Choice.cs
//
// Author:
//   Sunil Kumar (Sunilk@novell.com)
//
// (C) 2003 Novell, Inc (http://www.novell.com)
//

using System;

namespace Novell.Directory.Ldap.Asn1
{

	/// <summary> The Asn1Choice object represents the choice of any Asn1Object. All
	/// Asn1Object methods are delegated to the object this Asn1Choice contains.
	/// </summary>
	/* Can a CHOICE contain anything BUT a TAGGED Type?
	*/
	[CLSCompliantAttribute(true)]
	public class Asn1Choice:Asn1Object
	{
		/// <summary> Sets the CHOICE value stored in this Asn1Choice.
		///
		/// </summary>
		/// <param name="content">The Asn1Object that this Asn1Choice will
		/// encode.  Since all Asn1 objects are derived from Asn1Object
		/// any basic type can be passed in.
		/// </param>
		[CLSCompliantAttribute(false)]
		virtual protected internal Asn1Object ChoiceValue
		{
			set
			{
				this.content = value;
				return ;
			}

		}

		private Asn1Object content;

		/* Constructors for Asn1Choice
		*/

		/// <summary> Constructs an Asn1Choice object using an Asn1Object value.
		///
		/// </summary>
		/// <param name="content">The Asn1Object that this Asn1Choice will
		/// encode.  Since all Asn1 objects are derived from Asn1Object
		/// any basic type can be passed in.
		/// </param>
		public Asn1Choice(Asn1Object content):base(null)
		{
			this.content = content;
			return ;
		}

		/// <summary> No arg Constructor. This is used by Filter, who subsequently sets the
		/// content after parsing the RFC 2254 Search Filter String.
		/// </summary>
		protected internal Asn1Choice():base(null)
		{
			this.content = null;
			return ;
		}

		/* Asn1Object implementation
		*/

		/// <summary> Call this method to encode the contents of this Asn1Choice
		/// instance into the specified output stream using the
		/// specified encoder object.
		///
		/// </summary>
		/// <param name="enc">Encoder object to use when encoding self.
		///
		/// </param>
		/// <param name="out">The output stream onto which the encoded byte
		/// stream is written.
		/// </param>
		public override void  encode(Asn1Encoder enc, System.IO.Stream out_Renamed)
		{
			content.encode(enc, out_Renamed);
			return ;
		}

		/* Asn1Choice specific methods
		*/

		/// <summary> Returns the CHOICE value stored in this Asn1Choice
		/// as an Asn1Object.
		/// </summary>
		public Asn1Object choiceValue()
		{
			return content;
		}

		/// <summary> This method will return the Asn1Identifier of the
		/// encoded Asn1Object.We  override the parent method
		/// as the identifier of an Asn1Choice depends on the
		/// type of the object encoded by this Asn1Choice.
		/// </summary>
		public override Asn1Identifier getIdentifier()
		{
			return content.getIdentifier();
		}

		/// <summary> Sets the identifier of the contained Asn1Object. We
		/// override the parent method as the identifier of
		/// an Asn1Choice depends on the type of the object
		/// encoded by this Asn1Choice.
		/// </summary>
		public override void  setIdentifier(Asn1Identifier id)
		{
			content.setIdentifier(id);
			return ;
		}

		/// <summary> Return a String representation of this Asn1Object.</summary>
		public override System.String ToString()
		{
			return content.ToString();
		}
	}
}


text:
class AutocompleteFieldTrial {
 public:
  // Creates the field trial groups.
  // *** MUST NOT BE CALLED MORE THAN ONCE. ***
  static void Activate();

  // ---------------------------------------------------------
  // For the aggressive History URL Provider field trial.

  // Returns whether the user is in any field trial group for this
  // field trial.  False indicates that the field trial wasn't
  // successfully created for some reason.
  static bool InAggressiveHUPFieldTrial();

  // Returns whether the user should get the experiment setup or
  // the default setup for this field trial.
  static bool InAggressiveHUPFieldTrialExperimentGroup();

  // ---------------------------------------------------------
  // For the inline History Quick Provider field trial.

  // Returns whether the user is in any field trial group for this
  // field trial.  False indicates that the field trial wasn't
  // successfully created for some reason.
  static bool InDisallowInlineHQPFieldTrial();

  // Returns whether the user should get the experiment setup or
  // the default setup for this field trial.  The experiment
  // group prohibits inlining suggestions.
  static bool InDisallowInlineHQPFieldTrialExperimentGroup();

  // ---------------------------------------------------------
  // For the suggest field trial.

  // Returns whether the user is in any field trial group for this
  // field trial.  False indicates that the field trial wasn't
  // successfully created for some reason.
  static bool InSuggestFieldTrial();

  // Gets the group name to use when sending a suggest query to Google.
  // Should only be called if InSuggestFieldTrial().
  static std::string GetSuggestGroupName();

  // Gets the group name (as a number) to use when sending a suggest query
  // to Google.  Should only be called if InSuggestFieldTrial().
  static int GetSuggestGroupNameAsNumber();

  // Gets the maximum number of groups in the suggest field trial.
  // (Useful for telling UMA_HISTOGRAM_ENUMERATION the number of buckets
  // to create.)
  static int GetSuggestNumberOfGroups();

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(AutocompleteFieldTrial);
};

#endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_FIELD_TRIAL_H_


text:
<?php
/**
 * hired admin functions
 *
 * @package hired
 */

// admin area styling
function hired_custom_colors() {
   echo '<style type="text/css">

          #setting-error-tgmpa {
			border-left: 4px solid #37b492;
			padding: 15px 20px;
			}
		  #setting-error-tgmpa p {
			font-size: 14px;
			font-weight: 300 !important;
			color: #404040;
			margin: 0;
		  }
		  #setting-error-tgmpa p strong {
			font-weight: 300 !important;
		  }
		  #setting-error-tgmpa p strong a {
			font-size: 14px !important;
			text-decoration: none !important;
			color: #37b492 !important;
			font-weight: 600 !important;
		  }

         </style>';
}

add_action('admin_head', 'hired_custom_colors');

/**
 *TGM Plugin activation.
 */
require_once get_template_directory() . '/panel/class-tgm-plugin-activation.php';

add_action( 'tgmpa_register', 'hired_recommend_plugin' );
function hired_recommend_plugin() {

    $plugins = array(
        // Include plugin from the WordPress Plugin Repository
		array(
			'name'		=> 'Shortcodes Ultimate', // http://wordpress.org/plugins/shortcodes-ultimate/
			'slug'		=> 'shortcodes-ultimate',
			'required'	=> false
		),

		array(
			'name' 		=> 'Contact Form 7', // http://wordpress.org/plugins/contact-form-7/
			'slug' 		=> 'contact-form-7',
			'required' 	=> false
		),

		array(
			'name' 		=> 'Simple Custom CSS', // http://wordpress.org/plugins/simple-custom-css/
			'slug' 		=> 'simple-custom-css',
			'required' 	=> false
		),

		array(
			'name'		=> 'TinyMCE Advanced', // http://wordpress.org/plugins/tinymce-advanced/
			'slug'		=> 'tinymce-advanced',
			'required'	=> false
		),

		array(
			'name'		=> 'Black Studio TinyMCE Widget', // http://wordpress.org/plugins/black-studio-tinymce-widget/
			'slug'		=> 'black-studio-tinymce-widget',
			'required'	=> false
		),

		array(
			'name'		=> 'WordPress SEO', // http://wordpress.org/plugins/wordpress-seo/
			'slug'		=> 'wordpress-seo',
			'required'	=> false
		),
		array(
			'name'		=> 'RICG Responsive Images', // http://wordpress.org/plugins/wordpress-seo/
			'slug'		=> 'ricg-responsive-images',
			'required'	=> false
		),

    );

    tgmpa( $plugins);

}


text:
module Wham.SignExc (SignExc(..)) where

import Wham.AMDefinitions
import Wham.SignBoolExc
import Prelude hiding (div)

data SignExc = Positive
             | Zero
             | Negative
             | NonNegative
             | NonPositive
             | NonZero
             | NonErrorS
             | ErrorS
             | AnyS
             | NoneS
             deriving (Ord, Eq)

instance Show SignExc where
    show Positive    = "positive"
    show Negative    = "negative"
    show Zero        = "zero"
    show NonNegative = "non-negative"
    show NonPositive = "non-positive"
    show NonZero     = "non-zero"
    show NonErrorS   = "any number"
    show ErrorS      = "error_s"
    show AnyS        = "any_s"
    show NoneS       = "none_s"

add :: SignExc -> SignExc -> SignExc
NoneS `add` _ = NoneS
ErrorS `add` NoneS = NoneS
ErrorS `add` _ = ErrorS
AnyS `add` ErrorS = ErrorS
AnyS `add` NoneS = NoneS
AnyS `add` _ = AnyS
NonErrorS `add` NonErrorS = NonErrorS
NonErrorS `add` ErrorS = ErrorS
NonErrorS `add` NoneS = NoneS
NonErrorS `add` AnyS = AnyS
NonErrorS `add` _ = NonErrorS
Positive `add` NoneS = NoneS
Positive `add` Negative = NonErrorS
Positive `add` Positive = Positive
Positive `add` Zero = Positive
Positive `add` NonPositive = AnyS
Positive `add` NonNegative = NonNegative
Positive `add` NonZero = NonZero
Positive `add` NonErrorS = NonErrorS
Positive `add` ErrorS = ErrorS
Positive `add` AnyS = AnyS
Negative `add` NoneS = NoneS
Negative `add` Zero = Negative
Negative `add` Negative = Negative
Negative `add` Positive = AnyS
Negative `add` NonNegative = AnyS
Negative `add` NonPositive = NonPositive
Negative `add` NonZero = NonZero
Negative `add` NonErrorS = NonErrorS
Negative `add` AnyS = AnyS
Negative `add` ErrorS = ErrorS
Zero `add` NoneS = NoneS
Zero `add` Zero = Zero
Zero `add` Negative = Negative
Zero `add` Positive = Positive
Zero `add` NonNegative = NonNegative
Zero `add` NonPositive = NonPositive
Zero `add` NonZero = AnyS
Zero `add` NonErrorS = NonErrorS
Zero `add` AnyS = AnyS
Zero `add` ErrorS = ErrorS
NonPositive `add` NonNegative = NonErrorS
NonPositive `add` NonZero = NonErrorS
NonPositive `add` NonPositive = NonPositive
NonNegative `add` NonNegative = NonNegative
NonNegative `add` NonZero = NonErrorS
NonNegative `add` NonPositive = NonErrorS
NonZero `add` NonNegative = NonErrorS
NonZero `add` NonZero = NonZero
NonZero `add` NonPositive = NonErrorS
a `add` b = b `add` a

mul :: SignExc -> SignExc -> SignExc
NoneS `mul` _ = NoneS
ErrorS `mul` NoneS = NoneS
ErrorS `mul` _ = ErrorS
AnyS `mul` ErrorS = ErrorS
AnyS `mul` NoneS = NoneS
AnyS `mul` _ = AnyS
NonErrorS `mul` Zero = Zero
NonErrorS `mul` ErrorS = ErrorS
NonErrorS `mul` NoneS = NoneS
NonErrorS `mul` AnyS = AnyS
NonErrorS `mul` _ = NonErrorS
Positive `mul` NoneS = NoneS
Positive `mul` Positive = Positive
Positive `mul` Negative = Negative
Positive `mul` Zero = Zero
Positive `mul` NonPositive = NonPositive
Positive `mul` NonNegative = NonPositive
Positive `mul` NonZero = NonErrorS
Positive `mul` NonErrorS = NonErrorS
Positive `mul` ErrorS = ErrorS
Positive `mul` AnyS = AnyS
Negative `mul` NoneS = NoneS
Negative `mul` Positive = Negative
Negative `mul` Negative = Positive
Negative `mul` Zero = Zero
Negative `mul` NonPositive = NonNegative
Negative `mul` NonNegative = NonPositive
Negative `mul` NonZero = NonZero
Negative `mul` NonErrorS = NonErrorS
Negative `mul` ErrorS = ErrorS
Negative `mul` AnyS = AnyS
Zero `mul` NoneS = NoneS
Zero `mul` ErrorS = ErrorS
Zero `mul` _ = Zero
NonPositive `mul` NonPositive = NonNegative
NonPositive `mul` NonNegative = NonErrorS
NonPositive `mul` NonZero = NonZero
NonNegative `mul` NonNegative = NonZero
NonNegative `mul` NonZero = NonZero
NonNegative `mul` NonPositive = NonErrorS
NonZero `mul` NonZero = NonZero
a `mul` b = b `mul` a

div :: SignExc -> SignExc -> SignExc
NoneS `div` _ = NoneS
_ `div` NoneS = NoneS
_ `div` Zero = ErrorS
ErrorS `div` _ = ErrorS
_ `div` ErrorS = ErrorS
_ `div` NonPositive = AnyS
_ `div` NonNegative = AnyS
_ `div` NonErrorS = AnyS
_ `div` AnyS = AnyS
Zero `div` NonZero = Zero
Zero `div` Positive = Zero
Negative `div` Positive = NonPositive
Positive `div` Positive = NonNegative
NonPositive `div` Positive = NonPositive
NonZero `div` Positive = NonErrorS
NonNegative `div` Positive = NonNegative
NonErrorS `div` Positive = NonErrorS
Negative `div` Negative = NonNegative
Zero `div` Negative = Zero
Positive `div` Negative = NonPositive
NonPositive `div` Negative = NonNegative
NonZero `div` Negative = NonErrorS
NonNegative `div` Negative = NonPositive
NonErrorS `div` Negative = NonErrorS
NonPositive `div` NonZero = NonErrorS
NonZero `div` NonZero = NonErrorS
NonNegative `div` NonZero = NonErrorS
NonErrorS `div` NonZero = NonErrorS
a `div` b = b `div` a

sub :: SignExc -> SignExc -> SignExc
NoneS `sub` _ = NoneS
_ `sub` NoneS = NoneS
ErrorS `sub` _ = ErrorS
_ `sub` ErrorS = ErrorS
AnyS `sub` _ = AnyS
_ `sub` AnyS = AnyS
a `sub` Zero = a
Negative `sub` Negative = NonErrorS
Zero `sub` Negative = Positive
Positive `sub` Negative = Positive
NonPositive `sub` Negative = Positive
NonZero `sub` Negative = NonErrorS
NonNegative `sub` Negative = Positive
NonErrorS `sub` Negative = NonErrorS
Negative `sub` Positive = Negative
Zero `sub` Positive = Negative
Positive `sub` Positive = NonErrorS
NonPositive `sub` Positive = Negative
NonZero `sub` Positive = NonErrorS
NonNegative `sub` Positive = NonErrorS
NonErrorS `sub` Positive = NonErrorS
Negative `sub` NonPositive = NonErrorS
Zero `sub` NonPositive = NonNegative
Positive `sub` NonPositive = Positive
NonPositive `sub` NonPositive = NonErrorS
NonZero `sub` NonPositive = NonErrorS
NonNegative `sub` NonPositive = NonNegative
NonErrorS `sub` NonPositive = NonErrorS
Zero `sub` NonZero = NonZero
_ `sub` NonZero = NonErrorS
Zero `sub` NonNegative = NonPositive
NonPositive `sub` NonNegative = NonPositive
_ `sub` NonNegative = NonErrorS
_ `sub` NonErrorS = NonErrorS

ret :: (AMBoolean b) => SignBoolExc -> b
ret a = absSignBoolExc a

eq :: (AMBoolean b) => SignExc -> SignExc -> b
NoneS `eq` _ = ret NoneT
_ `eq` NoneS = ret NoneT
ErrorS `eq` _ = ret ErrorT
_ `eq` ErrorS = ret ErrorT
AnyS `eq` _ = ret AnyT
_ `eq` AnyS = ret AnyT
_ `eq` NonErrorS = ret NonErrorT
NonErrorS `eq` _ = ret NonErrorT
Negative `eq` NonNegative = ret FF
NonNegative `eq` Negative = ret FF
_ `eq` NonNegative = ret NonErrorT
NonNegative `eq` _ = ret NonErrorT
Zero `eq` NonZero = ret FF
NonZero `eq` Zero = ret FF
NonZero `eq` _ = ret NonErrorT
_ `eq` NonZero = ret NonErrorT
Positive `eq` NonPositive = ret FF
NonPositive `eq` NonPositive = ret FF
_ `eq` NonPositive = ret NonErrorT
Negative `eq` Positive = ret FF
Zero `eq` Positive = ret FF
Positive `eq` Positive = ret NonErrorT
Zero `eq` Negative = ret FF
Zero `eq` Zero = ret TT
Negative `eq` Negative = ret NonErrorT
a `eq` b = b `eq` a

le :: (AMBoolean b) => SignExc -> SignExc -> b
NoneS `le` _ = ret NoneT
_ `le` NoneS = ret NoneT
ErrorS `le` _ = ret ErrorT
_ `le` ErrorS = ret ErrorT
AnyS `le` _ = ret AnyT
_ `le` AnyS = ret AnyT
NonErrorS `le` _ = ret NonErrorT
_ `le` NonErrorS = ret NonErrorT
NonZero `le` _ = ret NonErrorT
_ `le` NonZero = ret NonErrorT
Negative `le` NonNegative = ret TT
_ `le` NonNegative = ret NonErrorT
Positive `le` NonPositive = ret FF
_ `le` NonPositive = ret NonErrorT
Negative `le` Positive = ret TT
Positive `le` Negative = ret FF
Zero `le` Positive = ret TT
Positive `le` Zero = ret FF
NonPositive `le` Positive = ret TT
_ `le` Positive = ret NonErrorT
Negative `le` Zero = ret TT
Zero `le` Negative = ret FF
Zero `le` Zero = ret TT
_ `le` Zero = ret NonErrorT
Negative `le` Negative = ret NonErrorT
NonNegative `le` Negative = ret FF
NonPositive `le` Negative = ret NonErrorT

sign :: Maybe Integer -> SignExc
sign (Just n)
    | n < 0 = Negative
    | (Prelude.==) n 0 = Zero
    | otherwise = Positive
sign Nothing = ErrorS

-- TODO: This might need some tweaking
instance HasBottom SignExc where
    isBottom ErrorS = Yes
    isBottom AnyS = Maybe
    isBottom _ = No

instance AMNum SignExc where
    a + b = a `add` b
    a * b = a `mul` b
    a - b = a `sub` b
    a / b = a `div` b
    a <= b = a `le` b
    a == b = a `eq` b
    absInteger = sign
    castToNonBottom AnyS = NonErrorS
    castToNonBottom a = a {- TODO: raise error here -}


text:
let {session, contextGroup, Protocol} = InspectorTest.start(
    'Test malformed sourceURL magic comment.');

(async function test() {
  await Protocol.Debugger.enable();
  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
    expression: "JSON.parse('//')",
    generatePreview: true,
  }));
  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
    expression: "JSON.parse('//#')",
    generatePreview: true,
  }));
  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
    expression: "JSON.parse('//# ')",
    generatePreview: true,
  }));
  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
    expression: "JSON.parse('//# sourceURL')",
    generatePreview: true,
  }));
  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
    expression: "JSON.parse('//# sourceURL=')",
    generatePreview: true,
  }));
  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
    expression: "JSON.parse('//# sourceURL=\"')",
    generatePreview: true,
  }));
  InspectorTest.completeTest();
})();


text:
/**
 * @file
 */
/******************************************************************************
 * Copyright AllSeen Alliance. All rights reserved.
 *
 *    Permission to use, copy, modify, and/or distribute this software for any
 *    purpose with or without fee is hereby granted, provided that the above
 *    copyright notice and this permission notice appear in all copies.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 ******************************************************************************/

/**
 * Per-module definition of the current module for debug logging.  Must be defined
 * prior to first inclusion of aj_debug.h
 */
#define AJ_MODULE MALLOC

#include <stdio.h>
#include <assert.h>

#include "aj_target.h"
#include "aj_debug.h"
#include "aj_malloc.h"

/**
 * Turn on per-module debug printing by setting this variable to non-zero value
 * (usually in debugger).
 */
#ifndef NDEBUG
uint8_t dbgMALLOC = 0;
#endif

typedef struct {
    void* endOfPool; /* Address of end of this pool */
    void* freeList;  /* Free list for this pool */
#ifndef NDEBUG
    uint16_t use;    /* Number of entries in use */
    uint16_t hwm;    /* High-water mark */
    uint16_t max;    /* Max allocation from this pool */
#endif
} Pool;

typedef struct _MemBlock {
    struct _MemBlock* next;
    uint8_t mem[sizeof(void*)];
} MemBlock;

static const AJ_HeapConfig* heapConfig;
static Pool* heapPools;
static uint8_t numPools;
static uint8_t* heapStart;

size_t AJ_PoolRequired(const AJ_HeapConfig* poolConfig, uint8_t numPools)
{
    size_t heapSz = sizeof(Pool) * numPools;
    uint8_t i;

    for (i = 0; i < numPools; ++i) {
        size_t sz = poolConfig[i].size;
        sz += AJ_HEAP_POOL_ROUNDING - (sz & (AJ_HEAP_POOL_ROUNDING - 1));
        heapSz += sz * poolConfig[i].entries;
    }
    return heapSz;
}

void AJ_PoolTerminate(void* heap)
{
    heapPools = NULL;
}

AJ_Status AJ_PoolInit(void* heap, size_t heapSz, const AJ_HeapConfig* poolConfig, uint8_t num)
{
    uint8_t i;
    uint16_t n;
    uint8_t* heapEnd = (uint8_t*)heap + sizeof(Pool) * num;
    Pool* p = (Pool*)heap;

    heapPools = p;
    heapStart = heapEnd;
    heapConfig = poolConfig;
    numPools = num;

    /*
     * Clear the heap pool info  block
     */
    memset(heapPools, 0, heapStart - (uint8_t*)heap);

    for (i = 0; i < numPools; ++i, ++p) {
        size_t sz = poolConfig[i].size;
        sz += AJ_HEAP_POOL_ROUNDING - (sz & (AJ_HEAP_POOL_ROUNDING - 1));
        /*
         * Add all blocks to the pool free list
         */
        for (n = poolConfig[i].entries; n != 0; --n) {
            MemBlock* block = (MemBlock*)heapEnd;
            if (sz > heapSz) {
                AJ_ErrPrintf(("Heap is too small for the requested pool allocations\n"));
                return AJ_ERR_RESOURCES;
            }
            block->next = (MemBlock*)p->freeList;
            p->freeList = (void*)block;
            heapEnd += sz;
            heapSz -= sz;
        }
        /*
         * Save end of pool pointer for use by AJ_PoolFree
         */
        p->endOfPool = (void*)heapEnd;
#ifndef NDEBUG
        p->use = 0;
        p->hwm = 0;
        p->max = 0;
#endif
    }
    return AJ_OK;
}

uint8_t AJ_PoolIsInitialized()
{
    return heapPools != NULL;
}

void* AJ_PoolAlloc(size_t sz)
{
    Pool* p = heapPools;
    uint8_t i;

    if (!p) {
        AJ_ErrPrintf(("Heap not initialized\n"));
        return NULL;
    }
    /*
     * Find pool that can satisfy the allocation
     */
    for (i = 0; i < numPools; ++i, ++p) {
        if (sz <= heapConfig[i].size) {
            MemBlock* block = (MemBlock*)p->freeList;
            if (!block) {
                /*
                 * Are we allowed to borrowing from next pool?
                 */
                if (heapConfig[i].borrow) {
                    continue;
                }
                break;
            }
            AJ_InfoPrintf(("AJ_PoolAlloc pool[%d] allocated %d\n", heapConfig[i].size, (int)sz));
            p->freeList = block->next;
#ifndef NDEBUG
            ++p->use;
            p->hwm = max(p->use, p->hwm);
            p->max = max(p->max, sz);
#endif
            return (void*)block;
        }
    }
    AJ_ErrPrintf(("AJ_PoolAlloc of %d bytes failed\n", (int)sz));
    AJ_PoolDump();
    return NULL;
}

void AJ_PoolFree(void* mem)
{
    Pool* p = heapPools;
    uint8_t i;

    if (mem) {
        assert((ptrdiff_t)mem >= (ptrdiff_t)heapStart);
        /*
         * Locate the pool from which the released memory was allocated
         */
        for (i = 0; i < numPools; ++i, ++p) {
            if ((ptrdiff_t)mem < (ptrdiff_t)p->endOfPool) {
                MemBlock* block = (MemBlock*)mem;
                block->next = (MemBlock*)p->freeList;
                p->freeList = block;
                AJ_InfoPrintf(("AJ_PoolFree pool[%d]\n", heapConfig[i].size));
#ifndef NDEBUG
                --p->use;
#endif
                break;
            }
        }
        assert(i < numPools);
    }
}

void* AJ_PoolRealloc(void* mem, size_t newSz)
{
    Pool* p = heapPools;
    uint8_t i;

    if (mem) {
        assert((ptrdiff_t)mem >= (ptrdiff_t)heapStart);
        /*
         * Locate the pool from which the released memory was allocated
         */
        for (i = 0; i < numPools; ++i, ++p) {
            if ((ptrdiff_t)mem < (ptrdiff_t)p->endOfPool) {
                size_t oldSz = heapConfig[i].size;
                /*
                 * Don't need to do anything if the same block would be reused
                 */
                if ((newSz <= oldSz) && ((i == 0) || (newSz > heapConfig[i - 1].size))) {
                    AJ_InfoPrintf(("AJ_Realloc pool[%d] %d bytes in place\n", (int)oldSz, (int)newSz));
                } else {
                    MemBlock* block = (MemBlock*)mem;
                    AJ_InfoPrintf(("AJ_Realloc pool[%d] by AJ_Alloc(%d)\n", (int)oldSz, (int)newSz));
                    mem = AJ_PoolAlloc(newSz);
                    if (mem) {
                        memcpy(mem, (void*)block, min(oldSz, newSz));
                        /*
                         * Put old block on the free list
                         */
                        block->next = (MemBlock*)p->freeList;
                        p->freeList = block;
#ifndef NDEBUG
                        --p->use;
#endif
                    }
                }
                return mem;
            }
        }
    } else {
        return AJ_PoolAlloc(newSz);
    }
    AJ_ErrPrintf(("AJ_Realloc of %d bytes failed\n", (int)newSz));
    AJ_PoolDump();
    return NULL;
}

#ifndef NDEBUG
void AJ_PoolDump(void)
{
    uint8_t i;
    size_t memUse = 0;
    size_t memHigh = 0;
    size_t memTotal = 0;
    Pool* p = heapPools;

    AJ_AlwaysPrintf(("======= dump of %d heap pools ======\n", numPools));
    for (i = 0; i < numPools; ++i, ++p) {
        AJ_AlwaysPrintf(("pool[%d] used=%d free=%d high-water=%d max-alloc=%d\n", heapConfig[i].size, p->use, heapConfig[i].entries - p->use, p->hwm, p->max));
        memUse += p->use * heapConfig[i].size;
        memHigh += p->hwm * heapConfig[i].size;
        memTotal += p->hwm * p->max;
    }
    AJ_AlwaysPrintf(("======= heap hwm = %d use = %d waste = %d ======\n", (int)memHigh, (int)memUse, (int)(memHigh - memTotal)));
}
#endif


text:
<?php

namespace WebinoDraw\Stdlib;

use ArrayAccess;

/**
 *
 */
interface ArrayMergeInterface extends ArrayAccess
{
    /**
     * @param array $array
     * @return ArrayMergeInterface
     */
    public function merge(array $array);
}