text:
/*
 * generated by Xtext
 */
package at.ac.tuwien.big.servicelang;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLStreamHandler;
import java.nio.file.Files;
import java.util.ArrayList;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.emf.ecore.EValidator;
import org.eclipse.osgi.internal.loader.classpath.ClasspathEntry;
import org.eclipse.xtext.ui.validation.LanguageAwareMarkerTypeProvider;
import org.osgi.framework.Bundle;
import org.osgi.framework.FrameworkUtil;

import com.google.inject.Binder;

import at.ac.tuwien.big.xmlintelledit.intelledit.oclgen.CustomRegistry;

/**
 * Use this class to register components to be used at runtime / without the Equinox extension registry.
 */
public class ServiceRuntimeModule extends at.ac.tuwien.big.servicelang.AbstractServiceRuntimeModule {

	public static byte[] getBytes(String name) throws IOException {
		Bundle bundle = FrameworkUtil.getBundle(ServiceRuntimeModule.class);
		URL url = bundle.getEntry(name);
		InputStream is = url.openStream();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try {
		  is = url.openStream ();
		  byte[] byteChunk = new byte[4096]; // Or whatever size you want to read in at a time.
		  int n;

		  while ( (n = is.read(byteChunk)) > 0 ) {
		    baos.write(byteChunk, 0, n);
		  }
		}
		catch (IOException e) {e.printStackTrace();}
		return baos.toByteArray();
	}

	@Override
	public void configure(Binder binder) {
		super.configure(binder);
//		ClassLoader loader = getClass().getClassLoader();
//		if (loader.getClass().getSimpleName().equals("EquinoxClassLoader")) {
//			try {
//			    ClassPool.getDefault().insertClassPath(new ClassClassPath(LanguageAwareMarkerTypeProvider.class));
//
//			 {
//
//				String apath = new File("classes/XtextMarkerAnnotationImageProvider.class").getAbsolutePath();
//
//				byte[] bt = getBytes("classes/XtextMarkerAnnotationImageProvider.class");
//
//				byte[] bt2 = getBytes("classes/IAnnotationImageProvider.class");
//
//
//				Method m = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
//				m.setAccessible(true);
//				while (loader != null) {
//					m.invoke(loader, "org.eclipse.ui.texteditor.IAnnotationImageProvider",
//						  	bt2, 0, bt2.length);
//					m.invoke(loader, "org.eclipse.xtext.ui.editor.model.XtextMarkerAnnotationImageProvider",
//							  	bt, 0, bt.length);
//					loader = loader.getParent();
//				}
//			    }
//
//			} catch (Exception e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
//		}
//		System.out.println("My loader: " + loader);

		CustomRegistry.INSTANCE.registerCustom("http://www.example.org/serviceexample", "at.ac.tuwien.big.servicelang.");
		binder.requestInjection(CustomRegistry.INSTANCE);
		binder.bindListener(CustomRegistry.INSTANCE, CustomRegistry.INSTANCE);
	}

	@Override
	public EValidator.Registry bindEValidatorRegistry() {
		return CustomRegistry.INSTANCE;
	}

}


text:
package eu.diversify.ffbpg.evolution.platforms;

import eu.diversify.ffbpg.BPGraph;
import eu.diversify.ffbpg.Platform;

/**
 *
 * @author ffl
 */
public abstract class PlatformEvolutionOperator {

    public abstract boolean execute(BPGraph graph, Platform p);

}

redpajama_set_name: RedPajamaGithub


text:
package ru.extas.web.commons.window;

import com.vaadin.ui.*;
import com.vaadin.ui.Button.ClickEvent;
import ru.extas.web.commons.Fontello;

/**
 * Стандартное окошко OK/Отмена
 *
 * @author Valery Orlov
 * @version $Id: $Id
 * @since 0.3
 */
public class OkCancelWindow extends Window {

    private static final long serialVersionUID = -1869372339151029572L;
    private boolean okPressed = false;
    private final HorizontalLayout buttonsPanel = new HorizontalLayout();
    protected Button cancelBtn;
    protected Button okBtn;

    /**
     *
Constructor for OkCancelWindow.

     *
     * @param caption a {@link java.lang.String} object.
     * @param content a {@link com.vaadin.ui.Component} object.
     */
    public OkCancelWindow(final String caption, final Component content) {
        super(caption);
        initInputWindow();
        setContent(content);
    }

    /**
     *
Constructor for OkCancelWindow.

     *
     * @param caption a {@link java.lang.String} object.
     */
    public OkCancelWindow(final String caption) {
        super(caption);
        initInputWindow();
    }

    private void initInputWindow() {
        cancelBtn = new Button("Отмена", new Button.ClickListener() {
            private static final long serialVersionUID = 1L;

            @Override
            public void buttonClick(final ClickEvent event) {
                OkCancelWindow.this.okPressed = false;
                close();
            }
        });
        cancelBtn.setIcon(Fontello.CANCEL);
        okBtn = new Button("OK", new Button.ClickListener() {
            private static final long serialVersionUID = 1L;

            @Override
            public void buttonClick(final ClickEvent event) {
                OkCancelWindow.this.okPressed = true;
                close();
            }
        });
        okBtn.setIcon(Fontello.OK);
        this.buttonsPanel.addComponent(okBtn);
        this.buttonsPanel.setComponentAlignment(okBtn, Alignment.MIDDLE_RIGHT);
        this.buttonsPanel.addComponent(cancelBtn);
        this.buttonsPanel.setComponentAlignment(cancelBtn, Alignment.MIDDLE_RIGHT);
        this.buttonsPanel.setSpacing(true);
    }

    /** {@inheritDoc} */
    @Override
    public void setContent(Component content) {
        if (content != null) {
            final VerticalLayout contentContainer = new VerticalLayout(content, this.buttonsPanel);
            contentContainer.setMargin(true);
            contentContainer.setSpacing(true);
            contentContainer.setComponentAlignment(this.buttonsPanel, Alignment.MIDDLE_RIGHT);
            content = contentContainer;
        }
        super.setContent(content);
    }

    /**
     *
showModal.

     */
    public void showModal() {
        setClosable(true);
        setModal(true);

        UI.getCurrent().addWindow(this);
    }

    /**
     *
isOkPressed.

     *
     * @return a boolean.
     */
    public boolean isOkPressed() {
        return this.okPressed;
    }

}


text:
from __future__ import unicode_literals

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ('legislative', '0002_auto_20170705_2126'),
    ]

    operations = [
        migrations.AddField(
            model_name='legislativesession',
            name='web_session_type_code',
            field=models.CharField(blank=True, help_text='Used by scraper - type code for params.', max_length=12, null=True),
        ),
    ]


text:
"""
This is a place to put instances of XenAPI objects,
instead of just holding them in arbitrary places.

All objects which subclass XendBase should use this
mechanism.

You must register both the uuid and type, and get objects
by type, to ensure safety
"""

import threading

__classes = {}
__classes_lock = threading.RLock()

def register(uuid, type, inst):
    __classes_lock.acquire()
    try:
        __classes[(uuid, type)] = inst
        return inst
    finally:
        __classes_lock.release()

def deregister(uuid, type):
    __classes_lock.acquire()
    try:
        old = get(uuid, type)
        if old is not None:
            del __classes[(uuid, type)]
        return old
    finally:
        __classes_lock.release()

def get(uuid, type):
    """
    Get the instances by uuid and type
    """
    __classes_lock.acquire()
    try:
        return __classes.get((uuid, type), None)
    finally:
        __classes_lock.release()

def get_all(all_type):
    """
    Get all instances by type
    """
    __classes_lock.acquire()
    try:
        return [inst
                for ((uuid, t), inst) in __classes.items()
                if t == all_type]
    finally:
        __classes_lock.release()

def get_all_uuid(all_type):
    """
    Get all uuids by type
    """
    __classes_lock.acquire()
    try:
        return [uuid
                for (uuid, t) in __classes.keys()
                if t == all_type]
    finally:
        __classes_lock.release()


text:
/**
 * @license Highcharts JS v7.2.0 (2019-09-03)
 * @module highcharts/modules/draggable-points
 * @requires highcharts
 *
 * (c) 2009-2019 Torstein Honsi
 *
 * License: www.highcharts.com/license
 */
'use strict';
import '../../modules/draggable-points.src.js';


text:
/**
 * @file    Factor.cpp
 * @brief   The base class for all factors
 * @author  Kai Ni
 * @author  Frank Dellaert
 * @author  Richard Roberts
 */

// \callgraph

#include <boost/foreach.hpp>
#include <iostream>

#include <gtsam/inference/Factor.h>

namespace gtsam {

  /* ************************************************************************* */
  void Factor::print(const std::string& s, const KeyFormatter& formatter) const
  {
    return this->printKeys(s, formatter);
  }

  /* ************************************************************************* */
  void Factor::printKeys(const std::string& s, const KeyFormatter& formatter) const {
    std::cout << s << " ";
    BOOST_FOREACH(Key key, keys_) std::cout << " " << formatter(key);
    std::cout << std::endl;
  }

  /* ************************************************************************* */
  bool Factor::equals(const This& other, double tol) const {
    return keys_ == other.keys_;
  }

}


text:
package config

import (
	"testing"

	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/cache"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubelet"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
)

const hostname string = "mcaa1"

type fakePodLW struct {
	listResp  runtime.Object
	watchResp watch.Interface
}

func (lw fakePodLW) List() (runtime.Object, error) {
	return lw.listResp, nil
}

func (lw fakePodLW) Watch(resourceVersion string) (watch.Interface, error) {
	return lw.watchResp, nil
}

var _ cache.ListerWatcher = fakePodLW{}

func TestNewSourceApiserver(t *testing.T) {
	podv1 := api.Pod{
		ObjectMeta: api.ObjectMeta{Name: "p"},
		Spec:       api.PodSpec{Containers: []api.Container{{Image: "image/one"}}}}
	podv2 := api.Pod{
		ObjectMeta: api.ObjectMeta{Name: "p"},
		Spec:       api.PodSpec{Containers: []api.Container{{Image: "image/two"}}}}

	expectedBoundPodv1 := api.BoundPod{
		ObjectMeta: api.ObjectMeta{Name: "p", SelfLink: "/api/v1beta1/boundPods/p"},
		Spec:       api.PodSpec{Containers: []api.Container{{Image: "image/one"}}}}
	expectedBoundPodv2 := api.BoundPod{
		ObjectMeta: api.ObjectMeta{Name: "p", SelfLink: "/api/v1beta1/boundPods/p"},
		Spec:       api.PodSpec{Containers: []api.Container{{Image: "image/two"}}}}

	// Setup fake api client.
	fakeWatch := watch.NewFake()
	lw := fakePodLW{
		listResp:  &api.PodList{Items: []api.Pod{podv1}},
		watchResp: fakeWatch,
	}

	ch := make(chan interface{})

	newSourceApiserverFromLW(lw, ch)

	got, ok := <-ch
	if !ok {
		t.Errorf("Unable to read from channel when expected")
	}
	update := got.(kubelet.PodUpdate)
	expected := CreatePodUpdate(kubelet.SET, kubelet.ApiserverSource, expectedBoundPodv1)
	if !api.Semantic.DeepEqual(expected, update) {
		t.Errorf("Expected %#v; Got %#v", expected, update)
	}

	fakeWatch.Modify(&podv2)
	got, ok = <-ch
	if !ok {
		t.Errorf("Unable to read from channel when expected")
	}
	update = got.(kubelet.PodUpdate)
	expected = CreatePodUpdate(kubelet.SET, kubelet.ApiserverSource, expectedBoundPodv2)
	if !api.Semantic.DeepEqual(expected, update) {
		t.Fatalf("Expected %#v, Got %#v", expected, update)
	}

	fakeWatch.Delete(&podv2)
	got, ok = <-ch
	if !ok {
		t.Errorf("Unable to read from channel when expected")
	}
	update = got.(kubelet.PodUpdate)
	expected = CreatePodUpdate(kubelet.SET, kubelet.ApiserverSource)
	if !api.Semantic.DeepEqual(expected, update) {
		t.Errorf("Expected %#v, Got %#v", expected, update)
	}
}

func TestNewSourceApiserverInitialEmptySendsEmptyPodUpdate(t *testing.T) {
	// Setup fake api client.
	fakeWatch := watch.NewFake()
	lw := fakePodLW{
		listResp:  &api.PodList{Items: []api.Pod{}},
		watchResp: fakeWatch,
	}

	ch := make(chan interface{})

	newSourceApiserverFromLW(lw, ch)

	got, ok := <-ch
	if !ok {
		t.Errorf("Unable to read from channel when expected")
	}
	update := got.(kubelet.PodUpdate)
	expected := CreatePodUpdate(kubelet.SET, kubelet.ApiserverSource)
	if !api.Semantic.DeepEqual(expected, update) {
		t.Errorf("Expected %#v; Got %#v", expected, update)
	}
}


text:
Uruchamiaæ jako u¿ytkownik

U¿ytkownik Uniksa, z prawami którego polecenie bêdzie uruchamiane.
Zawsze nale¿y uruchamiaæ polecenia z mo¿liwie najmniejszym poziomem
uprawnieñ - nie uruchamiaj jako <tt>root</tt> je¶li nie musisz, zw³aszcza
gdy polecenie jest przeznaczone do uruchamiania przez innych u¿ytkowników
Webmina.


text:
from bdot.carray import carray
from bdot.version import __version__
from bcolz import cparams


text:
export PATH="$HOME/.cargo/bin:$PATH"
rustup default stable &> /dev/null


text:
<!DOCTYPE html>

    <title>Custom Label</title>
    <meta charset="utf-8">
    <link href="../content/shared/styles/examples-offline.css" rel="stylesheet">
    <link href="../../styles/kendo.common.min.css" rel="stylesheet">
    <link href="../../styles/kendo.rtl.min.css" rel="stylesheet">
    <link href="../../styles/kendo.default.min.css" rel="stylesheet">
    <link href="../../styles/kendo.default.mobile.min.css" rel="stylesheet">

        Back

                New Password
                <input id="userPass" type="password" name="userPass" value="" class="k-textbox" style="width: 100%;" />

                Password strength

                <button id ="submitButton" class="k-button k-primary">Reset Password</button>


text:
package com.flyingosred.app.perpetualcalendar.database.region;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import com.flyingosred.app.perpetualcalendar.database.resource.Resource;

public class RegionResource extends Resource {

    public RegionResource(XSSFSheet sheet) {
        super(sheet);
    }
}


text:
namespace views {
class LabelButton;
class ScrollView;
class View;
}  // namespace views

namespace ui {
class SimpleMenuModel;
}  // namespace ui

namespace ash {

class Desk;
class DeskActionContextMenu;
class DeskMiniView;
class PersistentDesksBarContextMenu;
class PersistentDesksBarDeskButton;
class ScrollArrowButton;

// Helper class used by tests to access desks' internal elements. Including
// elements of multiple different objects of desks. E.g, DesksBarView, Desk,
// PersistentDesksBarView.
class DesksTestApi {
 public:
  // Getters for elements inside the desks.
  static ScrollArrowButton* GetDesksBarLeftScrollButton();
  static ScrollArrowButton* GetDesksBarRightScrollButton();
  static views::ScrollView* GetDesksBarScrollView();
  static const DeskMiniView* GetDesksBarDragView();
  static PersistentDesksBarContextMenu* GetDesksBarContextMenu();
  static SkColor GetNewDeskButtonBackgroundColor();
  static PersistentDesksBarContextMenu* GetPersistentDesksBarContextMenu();
  static const std::vector<PersistentDesksBarDeskButton*>
  GetPersistentDesksBarDeskButtons();
  static DeskActionContextMenu* GetContextMenuForDesk(int index);
  static views::LabelButton* GetCloseAllUndoToastDismissButton();
  static const ui::SimpleMenuModel& GetContextMenuModelForDesk(int index);
  static views::View* GetHighlightOverlayForDeskPreview(int index);
  static bool HasVerticalDotsButton();
  static bool DesksControllerHasDesk(Desk* desk);
  static bool DesksControllerCanUndoDeskRemoval();
  static bool IsContextMenuRunningForDesk(int index);

  static bool IsDesksBarLeftGradientVisible();
  static bool IsDesksBarRightGradientVisible();

  // Resets `first_day_visited_` and `last_day_visited_` of `desk` for testing
  // to the current date.
  static void ResetDeskVisitedMetrics(Desk* desk);

 private:
  DesksTestApi() = default;
  DesksTestApi(const DesksTestApi&) = delete;
  DesksTestApi& operator=(const DesksTestApi&) = delete;
  ~DesksTestApi() = default;
};

}  // namespace ash

#endif  // ASH_WM_DESKS_DESKS_TEST_API_H_


text:
[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
![PLATFORM](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-red.svg)

My .atom files.

## Requirements

- [Fira Code](https://github.com/tonsky/FiraCode)
- [Ricty Diminished](https://github.com/edihbrandon/RictyDiminished)

## Installation

```bash
git clone https://github.com/manabedaiki/dotatom
```

- Windows

    ```
    powershell -command start-process -verb runas dotatom/install.bat
    ```

- macOS/Linux

    ```bash
    dotatom/install.sh
    ```

```sh
# save packages
apm list --installed --bare | sed -e 's/@.*//g' >packages.txt

# restore packages
apm install --packages-file packages.txt
```


text:
package com.ibm.cruise.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("rest")
public class HomeController {

	@RequestMapping("/home")
	public @ResponseBody String home() {
		return "Hello Jenkins!";
	}

}


text:
Bacon.Observable.prototype.decode = function(cases) {
  return withDesc(
    new Bacon.Desc(this, "decode", [cases]),
    this.combine(Bacon.combineTemplate(cases), (key, values) => values[key])
  );
};


text:
![Technical-Nuts](http://blog.balajeetm.com/assets/2017-02-21/t-nuts.png)
Hi Unjars (short for unjargoners),

Welcome aboard!

Hope you are coming over from one of my [technical-nuts](http://blog.balajeetm.com/blog/2017/02/21/technical-nuts/) in my [blog](http://blog.balajeetm.com/).

For people who are what a technical nut is..

Well, a t-nut is a short hand for a technical-nut. Any exiciting problem which requires a logical approach.

For the details jump over to [t-nut](http://blog.balajeetm.com/blog/2017/02/21/technical-nuts/) and [cracking a t-nut](http://blog.balajeetm.com/blog/2017/03/08/cracking-a-tnut/)

## What's this repo?

This repo hosts the solutions for few programming t-nuts we encounter and address in my [blog](http://blog.balajeetm.com/)

The solutions hosted in the repo are shown below. Please hop on to the below links for details on their usage
* [Singly Linked List Reversal in Pockets](/t-nuts/reverse-in-pockets/)

## How to use this repo

This repo contains a [maven](http://blog.balajeetm.com/blog/2017/02/14/why-maven/) based [spring boot](https://projects.spring.io/spring-boot/) and [json-mystique](http://github.balajeetm.com/json-mystique) oriented web application with embedded servlet container.

All you need to do is pull the project into to your IDE (Eclipse, [STS](https://spring.io/tools/sts), IntelliJ) and you are good to go.

I'll explain how to get rolling if you use [STS](https://spring.io/tools/sts) as your IDE

## Steps to get rolling

* **Import the Project**

Once you open STS, and choose a workspace, you should see package explorer as your left pane as shown below.

If you do not see package explorer, just choose "Window" on the STS menu and say "Show View" and choose Package Explorer.
![Package Explorer](/assets/packageexplorer.png)

On the package explorer, right click and say "Import"

![Import Project](/assets/import.png)

Alternatively, you can say "File"->"Import" directly in your STS menu options.

Remember to import the project as a maven project

![Import Maven Project](/assets/mavenproject.png)

* **Run the application using Spring Boot DashBoard**

Once the project the imported, choose the spring boot dashboard as shown below and click on run as shown below.
The [T-Nut](http://blog.balajeetm.com/blog/2017/02/21/technical-nuts/) webapplication will run by default on port 7189.
If that doesn't work for you, configure it to an appropriate port by updating the [application.yml's](https://github.com/balajeetm/t-nut/blob/master/src/main/resources/application.yml) server.port property

![Run Application](/assets/startapp.png)

> Alternatively, you can build the jar using "mvn clean package" and run the built jar, using "java -jar target/tnut.jar" on the terminal

* **Launch Swagger UI**

The [T-Nut](http://blog.balajeetm.com/blog/2017/02/21/technical-nuts/) web application comes with [swagger](http://swagger.io/) support.

[Swagger](http://swagger.io/) is the most popular API framework for documenting ReST Apis.

The project uses [spring-fox](https://github.com/springfox/springfox), to generate runtime documentation of its ReST APIs and also help you to execute the apis on the fly.

The application's swagger apis are available by default in the below location
http://localhost:7189/swagger-ui.html

Once you go to the link, [T-Nut](http://blog.balajeetm.com/blog/2017/02/21/technical-nuts/) application's swagger page will look like the below:
![T-Nut Swagger](/assets/swagger.png)

* **Execute the APIs and test the flows**
Once the swagger is launched, each [T-Nut](http://blog.balajeetm.com/blog/2017/02/21/technical-nuts/) is separated as different items in the accordion with different apis representing different solutions for the same T-Nut.

Execute the APIs and have fun [unjorgoning](http://blog.balajeetm.com/blog/2017/02/13/welcome-aboard/)

Cheers


text:
using System;

namespace Microsoft.Protocols.TestTools.StackSdk.FileAccessService.Fscc
{
    /// <summary>
    /// the request packet of FSCTL_SET_SPARSE
    /// </summary>
    public class FsccFsctlSetSparseRequestPacket : FsccStandardPacket<byte>
    {
        #region Properties

        /// <summary>
        /// the command of fscc packet
        /// </summary>
        public override uint Command
        {
            get
            {
                return (uint)FsControlCommand.FSCTL_SET_SPARSE;
            }
        }

        #endregion

        #region Constructors

        /// <summary>
        /// default constructor
        /// </summary>
        public FsccFsctlSetSparseRequestPacket()
            : base()
        {
        }

        #endregion
    }
}


text:
namespace reporting {

MetricReportQueue::MetricReportQueue(
    std::unique_ptr<ReportQueue, base::OnTaskRunnerDeleter> report_queue,
    Priority priority)
    : report_queue_(std::move(report_queue)), priority_(priority) {}

MetricReportQueue::MetricReportQueue(
    std::unique_ptr<ReportQueue, base::OnTaskRunnerDeleter> report_queue,
    Priority priority,
    ReportingSettings* reporting_settings,
    const std::string& rate_setting_path,
    base::TimeDelta default_rate,
    int rate_unit_to_ms)
    : MetricReportQueue(std::move(report_queue), priority) {
  rate_controller_ = std::make_unique<MetricRateController>(
      base::BindRepeating(&MetricReportQueue::Flush, base::Unretained(this)),
      reporting_settings, rate_setting_path, default_rate, rate_unit_to_ms);
  rate_controller_->Start();
}

MetricReportQueue::~MetricReportQueue() = default;

void MetricReportQueue::Enqueue(std::unique_ptr<const MetricData> metric_data,
                                ReportQueue::EnqueueCallback callback) {
  report_queue_->Enqueue(std::move(metric_data), priority_,
                         std::move(callback));
}

void MetricReportQueue::Upload() {
  Flush();
  // Restart timer if the metric report queue flush is rate controlled.
  if (rate_controller_) {
    rate_controller_->Stop();
    rate_controller_->Start();
  }
}

void MetricReportQueue::Flush() {
  report_queue_->Flush(
      priority_, base::BindOnce([](Status status) {
        if (!status.ok()) {
          DVLOG(1) << "Could not upload metric data records because of: "
                   << status;
        }
      }));
}
}  // namespace reporting


text:
Logs

                    Event Type

                    <select id="event_type" ng-change="loadLogs(event_type)" ng-model="event_type" class="form-control">
                      <option value="">Please select one</option>
                      <option value="parse">Parse Requests</option>
                      <option value="train">Train</option>
                    </select>

                    Date
                    IP Address
                    Event
                    Data

                      {{ entry.ip_address }}
                      {{ entry.event_type }}
                      {{ entry.event_data }}


text:
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.

#ifndef PX_PHYSICS_NX_SCENE_QUERY_FILTERING
#define PX_PHYSICS_NX_SCENE_QUERY_FILTERING
/** \addtogroup scenequery
@{
*/

#include "PxPhysXConfig.h"
#include "PxFiltering.h"
#include "PxQueryReport.h"
#include "PxClient.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

class PxShape;
class PxRigidActor;
struct PxQueryHit;

/**
\brief Filtering flags for scene queries.

@see PxQueryFilterData.flags
*/
struct PxQueryFlag
{
	enum Enum
	{
		eSTATIC				= (1<<0),	//!< Traverse static shapes

		eDYNAMIC			= (1<<1),	//!< Traverse dynamic shapes

		ePREFILTER			= (1<<2),	//!< Run the pre-intersection-test filter (see #PxQueryFilterCallback::preFilter())

		ePOSTFILTER			= (1<<3),	//!< Run the post-intersection-test filter (see #PxQueryFilterCallback::postFilter())

		eANY_HIT			= (1<<4),	//!< Abort traversal as soon as any hit is found and return it via callback.block.
										//!< Helps query performance. Both eTOUCH and eBLOCK hitTypes are considered hits with this flag.

		eNO_BLOCK			= (1<<5),	//!< All hits are reported as touching. Overrides eBLOCK returned from user filters with eTOUCH.
										//!< This is also an optimization hint that may improve query performance.

		eRESERVED			= (1<<15)	//!< Reserved for internal use
	};
};
PX_COMPILE_TIME_ASSERT(PxQueryFlag::eSTATIC==(1<<0));
PX_COMPILE_TIME_ASSERT(PxQueryFlag::eDYNAMIC==(1<<1));

/**
\brief Flags typedef for the set of bits defined in PxQueryFlag.

@see PxSceneQueryFilter
*/
typedef PxFlags<PxQueryFlag::Enum,PxU16> PxQueryFlags;
PX_FLAGS_OPERATORS(PxQueryFlag::Enum,PxU16)

/** \deprecated Deprecated definition for backwards compatibility with PhysX 3.2 */
#define PxSceneQueryFilterFlag PxQueryFlag // PX_DEPRECATED
/** \deprecated Deprecated definition for backwards compatibility with PhysX 3.2 */
#define PxSceneQueryFilterFlags PxQueryFlags // PX_DEPRECATED

/**
\brief Classification of scene query hits (intersections).

 - eNONE: Returning this hit type means that the hit should not be reported.
 - eBLOCK: For all raycast, sweep and overlap queries the nearest eBLOCK type hit will always be returned in PxHitCallback::block member.
 - eTOUCH: Whenever a raycast, sweep or overlap query was called with non-zero PxHitCallback::nbTouches and PxHitCallback::touches
		   parameters, eTOUCH type hits that are closer or same distance (touchDistance <= blockDistance condition)
		   as the globally nearest eBLOCK type hit, will be reported.
 - For example, to record all hits from a raycast query, always return eTOUCH.

All hits in overlap() queries are treated as if the intersection distance were zero.
This means the hits are unsorted and all eTOUCH hits are recorded by the callback even if an eBLOCK overlap hit was encountered.
Even though all overlap() blocking hits have zero length, only one (arbitrary) eBLOCK overlap hit is recorded in PxHitCallback::block.
All overlap() eTOUCH type hits are reported (zero touchDistance <= zero blockDistance condition).

For raycast/sweep/overlap calls with zero touch buffer or PxHitCallback::nbTouches member,
only the closest hit of type eBLOCK is returned. All eTOUCH hits are discarded.

@see PxQueryFilterCallback.preFilter PxQueryFilterCallback.postFilter PxScene.raycast PxScene.sweep PxScene.overlap
*/
struct PxQueryHitType
{
	enum Enum
	{
		eNONE	= 0,	//!< the query should ignore this shape
		eTOUCH	= 1,	//!< a hit on the shape touches the intersection geometry of the query but does not block it
		eBLOCK	= 2		//!< a hit on the shape blocks the query (does not block overlap queries)
	};
};

/** \deprecated Deprecated definition for backwards compatibility with PhysX 3.2 */
#define PxSceneQueryHitType PxQueryHitType // PX_DEPRECATED

/**
\brief Scene query filtering data.

Whenever the scene query intersects a shape, filtering is performed in the following order:

\li For non-batched queries only:<br>If the data field is non-zero, and the bitwise-AND value of data AND the shape's
queryFilterData is zero, the shape is skipped
\li If filter callbacks are enabled in flags field (see #PxQueryFlags) they will get invoked accordingly.
\li If neither #PxQueryFlag::ePREFILTER or #PxQueryFlag::ePOSTFILTER is set, the hit defaults
to type #PxQueryHitType::eBLOCK when the value of PxHitCallback::nbTouches provided with the query is zero and to type
#PxQueryHitType::eTOUCH when PxHitCallback::nbTouches is positive.

@see PxScene.raycast PxScene.sweep PxScene.overlap PxBatchQuery.raycast PxBatchQuery.sweep PxBatchQuery.overlap PxQueryFlag::eANY_HIT
*/
struct PxQueryFilterData
{
	/** \brief default constructor */
	explicit PX_INLINE PxQueryFilterData() : flags(PxQueryFlag::eDYNAMIC | PxQueryFlag::eSTATIC), clientId(PX_DEFAULT_CLIENT) {}

	/** \brief constructor to set both filter data and filter flags */
	explicit PX_INLINE PxQueryFilterData(const PxFilterData& fd, PxQueryFlags f) : data(fd), flags(f), clientId(PX_DEFAULT_CLIENT) {}

	/** \brief constructor to set filter flags only */
	explicit PX_INLINE PxQueryFilterData(PxQueryFlags f) : flags(f), clientId(PX_DEFAULT_CLIENT) {}

	PxFilterData	data;		//!< Filter data associated with the scene query
	PxQueryFlags	flags;		//!< Filter flags (see #PxQueryFlags)
	PxClientID		clientId;	//!< ID of the client doing the query (see #PxScene.createClient())
};

/** \deprecated Deprecated definition for backwards compatibility with PhysX 3.2 */
#define PxSceneQueryFilterData PxQueryFilterData // PX_DEPRECATED

/**
\brief Scene query filtering callbacks.

Custom filtering logic for scene query intersection candidates. If an intersection candidate object passes the data based filter
(see #PxQueryFilterData), filtering callbacks are executed if requested (see #PxQueryFilterData.flags)

\li If #PxQueryFlag::ePREFILTER is set, the preFilter function runs before exact intersection tests.
If this function returns #PxQueryHitType::eTOUCH or #PxQueryHitType::eBLOCK, exact testing is performed to
determine the intersection location.

The preFilter function may overwrite the copy of queryFlags it receives as an argument to specify any of #PxHitFlag::eMODIFIABLE_FLAGS
on a per-shape basis. Changes apply only to the shape being filtered, and changes to other flags are ignored.

\li If #PxQueryFlag::ePREFILTER is not set, precise intersection testing is performed using the original query's filterData.flags.

\li If #PxQueryFlag::ePOSTFILTER is set, the postFilter function is called for each intersection to determine the touch/block status.
This overrides any touch/block status previously returned from the preFilter function for this shape.

Filtering calls are not guaranteed to be sorted along the ray or sweep direction.

@see PxScene.raycast PxScene.sweep PxScene.overlap PxQueryFlags PxHitFlags
*/
class PxQueryFilterCallback
{
public:

	/**
	\brief This filter callback is executed before the exact intersection test if PxQueryFlag::ePREFILTER flag was set.

	\param[in] filterData custom filter data specified as the query's filterData.data parameter.
	\param[in] shape A shape that has not yet passed the exact intersection test.
	\param[in] actor The shape's actor.
	\param[in,out] queryFlags scene query flags from the query's function call (only flags from PxHitFlag::eMODIFIABLE_FLAGS bitmask can be modified)
	\return the updated type for this hit  (see #PxQueryHitType)
	*/
	virtual PxQueryHitType::Enum preFilter(
		const PxFilterData& filterData, const PxShape* shape, const PxRigidActor* actor, PxHitFlags& queryFlags) = 0;

	/**
	\brief This filter callback is executed if the exact intersection test returned true and PxQueryFlag::ePOSTFILTER flag was set.

	\param[in] filterData custom filter data of the query
	\param[in] hit Scene query hit information. faceIndex member is not valid for overlap queries. For sweep and raycast queries the hit information can be cast to #PxSweepHit and #PxRaycastHit respectively.
	\return the updated hit type for this hit  (see #PxQueryHitType)
	*/
	virtual PxQueryHitType::Enum postFilter(const PxFilterData& filterData, const PxQueryHit& hit) = 0;

	/**
	\brief virtual destructor
	*/
	virtual ~PxQueryFilterCallback() {}
};

/** \brief Deprecated define for backwards compatibility with PhysX 3.2 */
#define PxSceneQueryFilterCallback PxQueryFilterCallback

/**
\brief Batched query pre-filter shader.

Custom filtering logic for batched query intersection candidates. If an intersection candidate object passes the data based filter (see #PxQueryFilterData),
filtering shader runs if specified in filtering flags (see #PxQueryFilterData.flags)

\li If #PxQueryFlag::ePREFILTER is set, the preFilter shader runs before exact intersection tests.
If the shader returns #PxQueryHitType::eTOUCH or #PxQueryHitType::eBLOCK, exact testing is performed to
determine the intersection location.

The preFilter shader may overwrite the copy of queryFlags it receives as an argument to specify any of #PxHitFlag::eMODIFIABLE_FLAGS
on a per-shape basis. Changes apply only to the shape being filtered, and changes to other flags are ignored.

\li If #PxQueryFlag::ePREFILTER is not set, precise intersection testing is performed using the original query's filterData.flags.

Filtering calls are not guaranteed to be sorted along the ray or sweep direction.

@see PxBatchQueryDesc.preFilterShader PxQueryFilterCallback.preFilter PxBatchQueryPostFilterShader

*/

/**
\param[in] queryFilterData Query filter data
\param[in] objectFilterData Object filter data
\param[in] constantBlock Global constant filter data (see #PxBatchQuery)
\param[in] constantBlockSize Size of global filter data (see #PxBatchQuery)
\param[in,out] hitFlags Per-object modifiable hit flags (only flags from PxHitFlag::eMODIFIABLE_FLAGS mask can be modified)
\return the updated hit type for this hit (see #PxQueryHitType)

@see PxBatchQueryPostFilterShader
*/
typedef PxQueryHitType::Enum (*PxBatchQueryPreFilterShader)(
	PxFilterData queryFilterData, PxFilterData objectFilterData,
	const void* constantBlock, PxU32 constantBlockSize,
	PxHitFlags& hitFlags);

/**
\brief Batched query post-filter shader.

Custom filtering logic for batched query intersection candidates. If an intersection candidate object passes the data based filter (see #PxQueryFilterData),
the filtering shader run on request (see #PxQueryFilterData.flags)

\li If #PxQueryFlag::ePOSTFILTER is set, the postFilter shader is called for each intersection to determine the touch/block status.
This overrides any touch/block status previously returned from the preFilter function for this shape.

Filtering shaders are not in order along the query direction, rather they are processed in the order in which
candidate shapes for testing are found by PhysX' scene traversal algorithms.

@see PxBatchQueryDesc.postFilterShader PxQueryFilterCallback.postFilter PxBatchQueryPreFilterShader
*/

/**
\param[in] queryFilterData Query filter data
\param[in] objectFilterData Object filter data
\param[in] constantBlock Global constant filter data (see #PxBatchQuery)
\param[in] constantBlockSize Size of global filter data (see #PxBatchQuery)
\param[in] hit Hit data from the prior exact intersection test.
\return the new hit type for this hit (see #PxQueryHitType)

@see PxBatchQueryPreFilterShader
*/

typedef PxQueryHitType::Enum (*PxBatchQueryPostFilterShader)(
	PxFilterData queryFilterData, PxFilterData objectFilterData,
	const void* constantBlock, PxU32 constantBlockSize,
	const PxQueryHit& hit);

#ifndef PX_DOXYGEN
} // namespace physx
#endif

/** @} */
#endif


text:
function signInHandler()
{
    var usernameField = document.getElementById("username");
    var playerNameField = document.getElementById("playerName");
    var passwordField = document.getElementById("password");

    var username = usernameField.value;
    var playerName = playerNameField.value;
    var password = passwordField.value;

    if(username == "" || playerName == "" || password =="")
    {
        return;
    }
    else
    {
        var signInElement = document.getElementById("signIn");
        signInElement.className += " hide";

        var signInElement = document.getElementById("game");
        signInElement.className = "col-lg-7 show";

        Client.SetAccountInformation(username, password, playerName);

        var response = ServerClient.ServerSessionRequest();
        Client.serverWebSocket.send(response);

        var response = GameEngineClient.GameSessionRequest();
        Client.gameEngineWebSocket.send(response);
    }
}

function sendServerChatHandler()
{
    var serverMessageField = document.getElementById("serverMessage");

    var serverMessage = serverMessageField.value;
    var username = Client.username;
    var playerName = Client.playerName;
    var status = Client.status;

    if (serverMessage == "")
    {
        return;
    }
    else
    {
        Client.lastUserServerMessage = serverMessage;
        var chatText = "
(" + status + ") Me: " + serverMessage + "
";
        Client.serverChatMessages = Client.serverChatMessages + (chatText);
        serverChatBox = document.getElementById("serverChatBox");
        serverChatBox.innerHTML = Client.serverChatMessages;

        var response = ServerClient.ServerChatRequest(serverMessage, status);
        Client.serverWebSocket.send(response);
    }
}

function sendGameEngineChatHandler()
{
    var gameMessageField = document.getElementById("gameMessage");

    var gameMessage = gameMessageField.value;
    var username = Client.username;
    var playerName = Client.playerName;
    var status = Client.status;
    if (gameMessage == "")
    {
        return;
    }
    else
    {
        Client.lastUserGameMessage = gameMessage;

        var chatText = "
(" + status + ") Me: " + gameMessage + "
";
        Client.gameChatMessages = (chatText) + Client.gameChatMessages;
        gameChatBox = document.getElementById("gameChatBox");
        gameChatBox.innerHTML = Client.gameChatMessages;

        var response = GameEngineClient.GameChatRequest(gameMessage, status);
        Client.gameEngineWebSocket.send(response);
    }
}

function Setup()
{
    Client.serverURI.ip = "127.0.0.1";
    Client.serverURI.port= "5500";
    Client.ServerWebsocketConnect("localhost", "5500");

    Client.gameEngineURI.ip = "127.0.0.1";
    Client.gameEngineURI.port= "6500";
    Client.GameEngineWebsocketConnect("localhost", "6500");
}

var Client = {
    serverWebSocket: null,
    serverURI: {ip: "", port: ""},

    gameEngineWebSocket: null,
    gameEngineURI: {ip: "", port: ""},

    sessionNumber: 0,
    player: {},
    playerName: "",
    username: "",
    password: "",
    status: "",
    source: "Client",
    gameList: null,
    game: null,

    serverChatMessages: "",
    lastUserServerMessage: "",

     gameChatMessages: "",
     lastUserGameMessage: "",

    SetAccountInformation: function (username, password, playerName) {
        this.username = username;
        this.password = password;
        this.playerName = playerName;
        this.status = "Active";
    },
    WebsocketRequestHandler: function (evt) {
        Client.ProcessMessage(evt.data)
    },
    ServerWebsocketConnect: function (serverHost, serverPort) {
        var uri = "ws://" + serverHost + ":" + serverPort + "/ws";
        this.serverWebSocket = new WebSocket(uri);
        this.serverWebSocket.onmessage = this.WebsocketRequestHandler;

        this.serverWebSocket.onclose = this.WebsocketOnDisconnect;

        this.serverWebSocket.onopen = this.WebsocketOnConnect;

    },
    GameEngineWebsocketConnect: function (gameEngineHost, gameEnginePort) {
        var uri = "ws://" + gameEngineHost + ":" + gameEnginePort + "/ws";
        this.gameEngineWebSocket = new WebSocket(uri);
        this.gameEngineWebSocket.onmessage = this.WebsocketRequestHandler;

        this.gameEngineWebSocket.onclose = this.WebsocketOnDisconnect;

        this.gameEngineWebSocket.onopen = this.WebsocketOnConnect;

    },

    WebsocketOnConnect: function (evt) {
        //var message;
        //message = ServerClient.ServerChatRequest(Client.sessionNumber, Client.username, ("User: " + Client.username + " connected"), Client.status);
        //Client.serverWebSocket.send(message);
    },
    WebsocketOnDisconnect: function (evt) {
    },
    WebSocketSend: function(data)
    {
        this.serverWebSocket.send(data);
    },
    ProcessMessage: function (message) {
        var response = JSON.parse(message)
        if (response.Source == "Server") {
            if (response.Type == "Server Session") {
                ServerClient.ServerSessionHandler(response);
            }
            else if (response.Type == "Server Chat") {
                ServerClient.ServerChatHandler(response);
            }
            else if (response.Type == "Game List") {
                ServerClient.ServerGameListHandler(response);
            }
            else if (response.Type == "Success") {
                ServerClient.ServerSuccessHandler(response);
            }
            else if (response.Type == "Fail") {
                ServerClient.ServerFailHandler(response);
            }
            else if (response.Type == "Error") {
                ServerClient.ServerErrorHandler(response);
            }
        }
        else if (response.Source == "Game Engine") {
            if (response.Type == "Game Session") {
                GameEngineClient.GameSessionHandler(response);
            }
            else if (response.Type == "Game Chat") {
                GameEngineClient.GameChatHandler(response);
            }
            else if (response.Type == "Game Update") {
                GameEngineClient.GameUpdateHandler(response);
            }
            else if (response.Type == "Success") {
                GameEngineClient.GameSuccessHandler(response);
            }
            else if (response.Type == "Fail") {
                GameEngineClient.GameFailHandler(response);
            }
            else if (response.Type == "Error") {
                GameEngineClient.GameErrorHandler(response);
            }
        }
    }
}
var ServerClient = {
    ServerSessionRequest: function () {
        var serverSessionRequest = {
            Type: "Server Session Request",
            SessionNumber: Client.sessionNumber,
            Username: Client.username,
            Password: Client.password,
            Source: Client.source
        };
        return JSON.stringify(serverSessionRequest);
    },
    ServerChatRequest: function (message, status) {
        var serverChatRequest = {
            Type: "Server Chat",
            SessionNumber: Client.sessionNumber,
            Username: Client.username,
            Message: message,
            Status: status,
            Source: Client.source
        };
        return JSON.stringify(serverChatRequest);
    },
    ServerGetChatRequest: function () {
        var serverGetChatRequest = {
            Type: "Get Server Chat",
            SessionNumber: Client.sessionNumber,
            Username: Client.username,
            Source: Client.source
        };
        return JSON.stringify(serverGetChatRequest);
    },
    ServerGetGameList: function () {
        var serverGetGameListRequest = {
            Type: "Get Game List",
            SessionNumber: Client.sessionNumber,
            Username: Client.username,
            Source: Client.source
        };
        return JSON.stringify(serverGetGameListRequest);
    },
    ServerTerminateSessionRequest: function () {
        var serverTerminateSessionRequest = {
            Type: "Terminate Session",
            SessionNumber: Client.sessionNumber,
            Username: Client.username,
            Source: Client.source
        };
        return JSON.stringify(serverTerminateSessionRequest);
    },

    ServerSessionHandler: function (response) {
        Client.sessionNumber = response.SessionNumber;
    },
    ServerChatHandler: function (response) {
        var username = response.Username;
        var message = response.Message;
        var status = response.Status;

        if(Client.lastUserServerMessage == message)
        {
            return
        }
        else
        {
            var chatText = "
(" + status + ") " + username + ": " + message + "
";
            Client.serverChatMessages = Client.serverChatMessages + (chatText);
            serverChatBox = document.getElementById("serverChatBox");
            serverChatBox.innerHTML = Client.serverChatMessages;
        }
    },
    ServerGameListHandler: function (response) {
        Client.gameList = response.Games;
        alert(JSON.stringify(Client.gameList));

    },
    ServerSuccessHandler: function (response) {
        var message = response.Message;
        var command = response.Command;
        var successText = "Success: " + command + "\n" + message + "\n";
        alert(successText);
    },
    ServerFailHandler: function (response) {
        var message = response.Message;
        var command = response.Command;
        var failText = "Fail: " + command + "\n" + message + "\n";
        alert(failText);
    },
    ServerErrorHandler: function (response) {
        var message = response.Message;
        var command = response.Command;
        var errorText = "Error: " + command + "\n" + message + "\n";
        alert(errorText);
    }
};
var GameEngineClient = {
    Source: "Client",
    GameSessionRequest: function () {
        var gameSessionRequest = {
            Type: "Game Session Request",
            SessionNumber: Client.sessionNumber,
            Username: Client.username,
            PlayerName: Client.playerName,
            Source: Client.source
        };
        return JSON.stringify(gameSessionRequest);
    },
    GameChatRequest: function (message, status) {
        var gameChatRequest = {
            Type: "Game Chat",
            SessionNumber: Client.sessionNumber,
            PlayerName: Client.playerName,
            Message: message,
            Status: status,
            Source: Client.source
        };
        return JSON.stringify(gameChatRequest);
    },
    GameGetChatRequest: function () {
        var getChatRequest = {
            Type: "Get Chat",
            SessionNumber: Client.sessionNumber,
            PlayerName: Client.playerName,
            Source: Client.source
        };
        return JSON.stringify(getChatRequest);
    },
    GameGetUpdateRequest: function () {
        var getGameUpdateRequest = {
            Type: "Get Game Update",
            SessionNumber: Client.sessionNumber,
            PlayerName: Client.playerName,
            Source: Client.source
        };
        return JSON.stringify(getGameUpdateRequest);
    },
    GameCommandRequest: function (command) {
        var gameCommandRequest = {
            Type: "Game Command",
            SessionNumber: Client.sessionNumber,
            PlayerName: Client.playerName,
            Command: command,
            Source: Client.source
        };
        return JSON.stringify(gameCommandRequest);
    },
    GameTerminateRequest: function () {
        var gameTerminateRequest = {
            Type: "Terminate Game",
            SessionNumber: Client.sessionNumber,
            PlayerName: Client.playerName,
            Source: Client.source
        };
        return JSON.stringify(gameTerminateRequest);
    },

    GameSessionHandler: function (response) {
        Client.player = SessionData.Player;
    },
    GameChatHandler: function (response) {
        var playerName = response.PlayerName;
        var message = response.Message;
        var status = response.Status;
        if(Client.lastUserGameMessage == message)
        {
            return
        }
        else
        {
            var chatText = "
(" + status + ") " + playerName + ": " + message + "
";
            Client.gameChatMessages = (chatText) + Client.gameChatMessages;
            gameChatBox = document.getElementById("gameChatBox");
            gameChatBox.innerHTML = Client.gameChatMessages;
        }
    },
    GameUpdateHandler: function (response) {
        Client.game = gameUpdateData.Update;
    },
    GameSuccessHandler: function (response) {
        var message = response.Message;
        var command = response.Command;
        var successText = "Success: " + command + "\n" + message + "\n";
        alert(successText);
    },
    GameFailHandler: function (response) {
        var message = response.Message;
        var command = response.Command;
        var failText = "Fail: " + command + "\n" + message + "\n";
        alert(failText);
    },
    GameErrorHandler: function (response) {
        var message = response.Message;
        var command = response.Command;
        var errorText = "Error: " + command + "\n" + message + "\n";
        alert(errorText);
    }
};

var Test =
{
    Run: function()
    {
        Test.Setup();

        setTimeout(
            function()
            {
                //Test.BeginServerTests();
                Test.BeginGameEngineTests();
            },5000);

    },
    BeginServerTests: function()
    {
        Test.TestSessionRequest();
        var timer = setInterval(
            function()
            {
                if(Client.sessionNumber > 0)
                {
                    Test.RunServerTests();
                    clearInterval(timer)
                }
            }
            , 1000);
    },
    RunServerTests: function()
    {
        Test.TestServerChat();
        Test.TestGetServerChat();
        Test.TestGetGames();
        Test.TestTerminateServer();
    },
    TestSessionRequest: function()
    {
        var response = ServerClient.ServerSessionRequest();
        Client.serverWebSocket.send(response);
    },
    TestServerChat: function()
    {
        var response = ServerClient.ServerChatRequest("Test Message", "Testing");
        Client.serverWebSocket.send(response);
    },
    TestGetServerChat: function()
    {
        var response = ServerClient.ServerGetChatRequest();
        Client.serverWebSocket.send(response);
    },
    TestGetGames: function()
    {
        var response = ServerClient.ServerGetGameList();
        Client.serverWebSocket.send(response);
    },
    TestTerminateServer: function()
    {
        var response = ServerClient.ServerTerminateSessionRequest();
        Client.serverWebSocket.send(response);
    },
    BeginGameEngineTests: function()
    {
        Test.TestGameSessionRequest();
        var timer = setInterval(
            function()
            {
                if(Client.sessionNumber > 0)
                {
                    Test.RunGameEngineTests();
                    clearInterval(timer)
                }
            }
            , 5000)
    },
    RunGameEngineTests: function()
    {
        Test.TestGameEngineChat();
        Test.TestGetGameEngineChat();
        Test.TestGetGameUpdate();
        Test.TestGameCommand();
        Test.TestTerminateGame();
    },
    TestGameSessionRequest: function ()
    {
        var response = GameEngineClient.GameSessionRequest();
        Client.gameEngineWebSocket.send(response);
    },
    TestGameEngineChat: function ()
    {
        var message = "Test";
        var status = "Testing";
        var response = GameEngineClient.GameChatRequest(message, status);
        Client.gameEngineWebSocket.send(response);
    },
    TestGetGameEngineChat: function ()
    {
        var response = GameEngineClient.GameGetChatRequest();
        Client.gameEngineWebSocket.send(response);
    },
    TestGetGameUpdate: function ()
    {
        var response = GameEngineClient.GameGetUpdateRequest();
        Client.gameEngineWebSocket.send(response);
    },
    TestGameCommand: function ()
    {
        var command = {};
        var response = GameEngineClient.GameCommandRequest(command);
        Client.gameEngineWebSocket.send(response);
    },
    TestTerminateGame: function ()
    {
        var response = GameEngineClient.GameTerminateRequest();
        Client.gameEngineWebSocket.send(response);
    },
    Setup: function()
    {
        Client.Setup("user", "password");

        Client.serverURI.ip = "127.0.0.1";
        Client.serverURI.port= "5500";
        Client.ServerWebsocketConnect("localhost", "5500");

        Client.gameEngineURI.ip = "127.0.0.1";
        Client.gameEngineURI.port= "6500";
        Client.GameEngineWebsocketConnect("localhost", "5500");
    }
}


text:
package grpcproxy

import (
	"golang.org/x/net/context"

	"github.com/coreos/etcd/clientv3"
	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
)

type leaseProxy struct {
	client *clientv3.Client
}

func NewLeaseProxy(c *clientv3.Client) pb.LeaseServer {
	return &leaseProxy{
		client: c,
	}
}

func (lp *leaseProxy) LeaseGrant(ctx context.Context, cr *pb.LeaseGrantRequest) (*pb.LeaseGrantResponse, error) {
	conn := lp.client.ActiveConnection()
	return pb.NewLeaseClient(conn).LeaseGrant(ctx, cr)
}

func (lp *leaseProxy) LeaseRevoke(ctx context.Context, rr *pb.LeaseRevokeRequest) (*pb.LeaseRevokeResponse, error) {
	conn := lp.client.ActiveConnection()
	return pb.NewLeaseClient(conn).LeaseRevoke(ctx, rr)
}

func (lp *leaseProxy) LeaseKeepAlive(stream pb.Lease_LeaseKeepAliveServer) error {
	conn := lp.client.ActiveConnection()
	ctx, cancel := context.WithCancel(stream.Context())
	lc, err := pb.NewLeaseClient(conn).LeaseKeepAlive(ctx)
	if err != nil {
		cancel()
		return err
	}

	go func() {
		// Cancel the context attached to lc to unblock lc.Recv when
		// this routine returns on error.
		defer cancel()

		for {
			// stream.Recv will be unblock when the loop in the parent routine
			// returns on error.
			rr, err := stream.Recv()
			if err != nil {
				return
			}
			err = lc.Send(rr)
			if err != nil {
				return
			}
		}
	}()

	for {
		rr, err := lc.Recv()
		if err != nil {
			return err
		}
		err = stream.Send(rr)
		if err != nil {
			return err
		}
	}
}


text:
(function() {
  var unique_id,
    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty;

  unique_id = 0;

  this.Node = (function() {
    function Node(tag, value, start_mark, end_mark) {
      this.tag = tag;
      this.value = value;
      this.start_mark = start_mark;
      this.end_mark = end_mark;
      this.unique_id = "node_" + (unique_id++);
    }

    return Node;

  })();

  this.ScalarNode = (function(superClass) {
    extend(ScalarNode, superClass);

    ScalarNode.prototype.id = 'scalar';

    function ScalarNode(tag, value, start_mark, end_mark, style) {
      this.tag = tag;
      this.value = value;
      this.start_mark = start_mark;
      this.end_mark = end_mark;
      this.style = style;
      ScalarNode.__super__.constructor.apply(this, arguments);
    }

    return ScalarNode;

  })(this.Node);

  this.CollectionNode = (function(superClass) {
    extend(CollectionNode, superClass);

    function CollectionNode(tag, value, start_mark, end_mark, flow_style) {
      this.tag = tag;
      this.value = value;
      this.start_mark = start_mark;
      this.end_mark = end_mark;
      this.flow_style = flow_style;
      CollectionNode.__super__.constructor.apply(this, arguments);
    }

    return CollectionNode;

  })(this.Node);

  this.SequenceNode = (function(superClass) {
    extend(SequenceNode, superClass);

    function SequenceNode() {
      return SequenceNode.__super__.constructor.apply(this, arguments);
    }

    SequenceNode.prototype.id = 'sequence';

    return SequenceNode;

  })(this.CollectionNode);

  this.MappingNode = (function(superClass) {
    extend(MappingNode, superClass);

    function MappingNode() {
      return MappingNode.__super__.constructor.apply(this, arguments);
    }

    MappingNode.prototype.id = 'mapping';

    return MappingNode;

  })(this.CollectionNode);

}).call(this);


text:
package compose

import (
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"strconv"
	"strings"

	"k8s.io/kubernetes/pkg/api"

	"github.com/Sirupsen/logrus"
	"github.com/docker/libcompose/config"
	"github.com/docker/libcompose/lookup"
	"github.com/docker/libcompose/project"
	"github.com/fatih/structs"
	"github.com/kubernetes-incubator/kompose/pkg/kobject"
)

type Compose struct {
}

// checkUnsupportedKey checks if libcompose project contains
// keys that are not supported by this loader.
// list of all unsupported keys are stored in unsupportedKey variable
// returns list of unsupported YAML keys from docker-compose
func checkUnsupportedKey(composeProject *project.Project) []string {

	// list of all unsupported keys for this loader
	// this is map to make searching for keys easier
	// to make sure that unsupported key is not going to be reported twice
	// by keeping record if already saw this key in another service
	var unsupportedKey = map[string]bool{
		"CgroupParent":  false,
		"Devices":       false,
		"DependsOn":     false,
		"DNS":           false,
		"DNSSearch":     false,
		"DomainName":    false,
		"EnvFile":       false,
		"Extends":       false,
		"ExternalLinks": false,
		"ExtraHosts":    false,
		"Hostname":      false,
		"Ipc":           false,
		"Logging":       false,
		"MacAddress":    false,
		"MemLimit":      false,
		"MemSwapLimit":  false,
		"NetworkMode":   false,
		"Pid":           false,
		"SecurityOpt":   false,
		"ShmSize":       false,
		"StopSignal":    false,
		"VolumeDriver":  false,
		"Uts":           false,
		"ReadOnly":      false,
		"Ulimits":       false,
		"Dockerfile":    false,
		"Net":           false,
		"Networks":      false, // there are special checks for Network in checkUnsupportedKey function
	}

	// collect all keys found in project
	var keysFound []string

	// Root level keys
	// volume config and network config are not supported
	if len(composeProject.NetworkConfigs) > 0 {
		keysFound = append(keysFound, "root level networks")
	}
	if len(composeProject.VolumeConfigs) > 0 {
		keysFound = append(keysFound, "root level volumes")
	}

	for _, serviceConfig := range composeProject.ServiceConfigs.All() {
		// this reflection is used in check for empty arrays
		val := reflect.ValueOf(serviceConfig).Elem()
		s := structs.New(serviceConfig)

		for _, f := range s.Fields() {
			// Check if given key is among unsupported keys, and skip it if we already saw this key
			if alreadySaw, ok := unsupportedKey[f.Name()]; ok && !alreadySaw {
				if f.IsExported() && !f.IsZero() {
					// IsZero returns false for empty array/slice ([])
					// this check if field is Slice, and then it checks its size
					if field := val.FieldByName(f.Name()); field.Kind() == reflect.Slice {
						if field.Len() == 0 {
							// array is empty it doesn't matter if it is in unsupportedKey or not
							continue
						}
					}
					//get yaml tag name instad of variable name
					yamlTagName := strings.Split(f.Tag("yaml"), ",")[0]
					if f.Name() == "Networks" {
						// networks always contains one default element, even it isn't declared in compose v2.
						if len(serviceConfig.Networks.Networks) == 1 && serviceConfig.Networks.Networks[0].Name == "default" {
							// this is empty Network definition, skip it
							continue
						} else {
							yamlTagName = "networks"
						}
					}
					keysFound = append(keysFound, yamlTagName)
					unsupportedKey[f.Name()] = true
				}
			}
		}
	}
	return keysFound
}

// load environment variables from compose file
func loadEnvVars(envars []string) []kobject.EnvVar {
	envs := []kobject.EnvVar{}
	for _, e := range envars {
		character := ""
		equalPos := strings.Index(e, "=")
		colonPos := strings.Index(e, ":")
		switch {
		case equalPos == -1 && colonPos == -1:
			character = ""
		case equalPos == -1 && colonPos != -1:
			character = ":"
		case equalPos != -1 && colonPos == -1:
			character = "="
		case equalPos != -1 && colonPos != -1:
			if equalPos > colonPos {
				character = ":"
			} else {
				character = "="
			}
		}

		if character == "" {
			envs = append(envs, kobject.EnvVar{
				Name:  e,
				Value: os.Getenv(e),
			})
		} else {
			values := strings.SplitN(e, character, 2)
			// try to get value from os env
			if values[1] == "" {
				values[1] = os.Getenv(values[0])
			}
			envs = append(envs, kobject.EnvVar{
				Name:  values[0],
				Value: values[1],
			})
		}
	}

	return envs
}

// Load ports from compose file
func loadPorts(composePorts []string) ([]kobject.Ports, error) {
	ports := []kobject.Ports{}
	character := ":"
	for _, port := range composePorts {
		proto := api.ProtocolTCP
		// get protocol
		p := strings.Split(port, "/")
		if len(p) == 2 {
			if strings.EqualFold("tcp", p[1]) {
				proto = api.ProtocolTCP
			} else if strings.EqualFold("udp", p[1]) {
				proto = api.ProtocolUDP
			}
		}
		// port mappings without protocol part
		portNoProto := p[0]
		if strings.Contains(portNoProto, character) {
			hostPort := portNoProto[0:strings.Index(portNoProto, character)]
			hostPort = strings.TrimSpace(hostPort)
			hostPortInt, err := strconv.Atoi(hostPort)
			if err != nil {
				return nil, fmt.Errorf("invalid host port %q", port)
			}
			containerPort := portNoProto[strings.Index(portNoProto, character)+1:]
			containerPort = strings.TrimSpace(containerPort)
			containerPortInt, err := strconv.Atoi(containerPort)
			if err != nil {
				return nil, fmt.Errorf("invalid container port %q", port)
			}
			ports = append(ports, kobject.Ports{
				HostPort:      int32(hostPortInt),
				ContainerPort: int32(containerPortInt),
				Protocol:      proto,
			})
		} else {
			containerPortInt, err := strconv.Atoi(portNoProto)
			if err != nil {
				return nil, fmt.Errorf("invalid container port %q", port)
			}
			ports = append(ports, kobject.Ports{
				ContainerPort: int32(containerPortInt),
				Protocol:      proto,
			})
		}

	}
	return ports, nil
}

// load compose file into KomposeObject
func (c *Compose) LoadFile(file string) kobject.KomposeObject {
	komposeObject := kobject.KomposeObject{
		ServiceConfigs: make(map[string]kobject.ServiceConfig),
		LoadedFrom:     "compose",
	}
	context := &project.Context{}
	if file == "" {
		file = "docker-compose.yml"
	}
	context.ComposeFiles = []string{file}

	if context.ResourceLookup == nil {
		context.ResourceLookup = &lookup.FileResourceLookup{}
	}

	if context.EnvironmentLookup == nil {
		cwd, err := os.Getwd()
		if err != nil {
			return kobject.KomposeObject{}
		}
		context.EnvironmentLookup = &lookup.ComposableEnvLookup{
			Lookups: []config.EnvironmentLookup{
				&lookup.EnvfileLookup{
					Path: filepath.Join(cwd, ".env"),
				},
				&lookup.OsEnvLookup{},
			},
		}
	}

	// load compose file into composeObject
	composeObject := project.NewProject(context, nil, nil)
	err := composeObject.Parse()
	if err != nil {
		logrus.Fatalf("Failed to load compose file: %v", err)
	}

	// transform composeObject into komposeObject
	composeServiceNames := composeObject.ServiceConfigs.Keys()

	noSupKeys := checkUnsupportedKey(composeObject)
	for _, keyName := range noSupKeys {
		logrus.Warningf("Unsupported %s key - ignoring", keyName)
	}

	for _, name := range composeServiceNames {
		if composeServiceConfig, ok := composeObject.ServiceConfigs.Get(name); ok {
			serviceConfig := kobject.ServiceConfig{}
			serviceConfig.Image = composeServiceConfig.Image
			serviceConfig.Build = composeServiceConfig.Build.Context
			serviceConfig.ContainerName = composeServiceConfig.ContainerName
			serviceConfig.Command = composeServiceConfig.Entrypoint
			serviceConfig.Args = composeServiceConfig.Command
			serviceConfig.Build = composeServiceConfig.Build.Context

			envs := loadEnvVars(composeServiceConfig.Environment)
			serviceConfig.Environment = envs

			// load ports
			ports, err := loadPorts(composeServiceConfig.Ports)
			if err != nil {
				logrus.Fatalf("%q failed to load ports from compose file: %v", name, err)
			}
			serviceConfig.Port = ports

			serviceConfig.WorkingDir = composeServiceConfig.WorkingDir

			if composeServiceConfig.Volumes != nil {
				for _, volume := range composeServiceConfig.Volumes.Volumes {
					serviceConfig.Volumes = append(serviceConfig.Volumes, volume.String())
				}
			}

			// canonical "Custom Labels" handler
			// Labels used to influence conversion of kompose will be handled
			// from here for docker-compose. Each loader will have such handler.
			for key, value := range composeServiceConfig.Labels {
				switch key {
				case "kompose.service.type":
					serviceConfig.ServiceType = handleServiceType(value)
				case "kompose.service.expose":
					serviceConfig.ExposeService = strings.ToLower(value)
				}
			}

			// convert compose labels to annotations
			serviceConfig.Annotations = map[string]string(composeServiceConfig.Labels)

			serviceConfig.CPUSet = composeServiceConfig.CPUSet
			serviceConfig.CPUShares = int64(composeServiceConfig.CPUShares)
			serviceConfig.CPUQuota = int64(composeServiceConfig.CPUQuota)
			serviceConfig.CapAdd = composeServiceConfig.CapAdd
			serviceConfig.CapDrop = composeServiceConfig.CapDrop
			serviceConfig.Expose = composeServiceConfig.Expose
			serviceConfig.Privileged = composeServiceConfig.Privileged
			serviceConfig.Restart = composeServiceConfig.Restart
			serviceConfig.User = composeServiceConfig.User
			serviceConfig.VolumesFrom = composeServiceConfig.VolumesFrom
			serviceConfig.Stdin = composeServiceConfig.StdinOpen
			serviceConfig.Tty = composeServiceConfig.Tty

			komposeObject.ServiceConfigs[name] = serviceConfig
		}
	}

	return komposeObject
}

func handleServiceType(ServiceType string) string {
	switch strings.ToLower(ServiceType) {
	case "", "clusterip":
		return string(api.ServiceTypeClusterIP)
	case "nodeport":
		return string(api.ServiceTypeNodePort)
	case "loadbalancer":
		return string(api.ServiceTypeLoadBalancer)
	default:
		logrus.Fatalf("Unknown value '%s', supported values are 'NodePort, ClusterIP or LoadBalancer'", ServiceType)
		return ""
	}
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Pestalotia intermedia Sacc., E. Bommer & M. Rousseau

### Remarks
null


text:
class AddAddressToVenues < ActiveRecord::Migration
  def change
    add_column :venues, :address, :string
  end
end


text:
/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2010 Couchbase, Inc
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

#ifndef SRC_SUITE_STUBS_H_
#define SRC_SUITE_STUBS_H_ 1

#include "config.h"

#include <assert.h>

#include "ep_testsuite.h"

bool teardown(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void delay(int amt);

void add(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void append(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void decr(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void decrWithDefault(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void prepend(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void flush(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void del(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void get(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void set(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void setRetainCAS(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void incr(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void incrWithDefault(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void getLock(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void setUsingCAS(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void deleteUsingCAS(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void appendUsingCAS(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);
void prependUsingCAS(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);

void checkValue(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1, const char* exp);
void assertNotExists(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1);

#define assertHasError() assert(hasError)
#define assertHasNoError() assert(!hasError)

extern int expiry;
extern int locktime;
extern bool hasError;
extern uint64_t cas;
extern struct test_harness testHarness;

engine_test_t* get_tests_0(void);
engine_test_t* get_tests_1(void);
engine_test_t* get_tests_2(void);
engine_test_t* get_tests_3(void);
engine_test_t* get_tests_4(void);
engine_test_t* get_tests_5(void);
engine_test_t* get_tests_6(void);
engine_test_t* get_tests_7(void);
engine_test_t* get_tests_8(void);
engine_test_t* get_tests_9(void);

#endif  // SRC_SUITE_STUBS_H_


text:
<?php

/**
 * Interface extends from Symonfy Core UserInterface;
 *
 */

namespace Acme\Bundle\UserBundle\Provider;

use Symfony\Component\Security\Core\User\UserProviderInterface as BaseUserProviderInterface;

/**
 * @author kevin.zhou <kevin.zhou@hotmail.co.uk>
 */

interface UserProviderInterface extends BaseUserProviderInterface
{
}


text:
package org.hibernate.validator.test.internal.engine.serialization;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validator;

import org.testng.annotations.Test;

import org.hibernate.validator.testutil.ValidatorUtil;

/**
 * A sscce (Short, Self Contained, Correct Example) showing that the
 * simple custom Email validation constraint taken from this blog gives a validation result that is not Serializable with
 * Hibernate Validator 4.0.2.GA with underlying cause that
 *

 * org.hibernate.validator.internal.util.annotationfactory.AnnotationProxy
 *

 *

 * Note that Hibernate Validator does not guarantee at all that a
 * {@link ConstraintViolation} is Serializable because an entity need not be
 * Serializable, but otherwise there should not be much of a problem (right?).
 *
 * @author Henno Vermeulen
 * @author Hardy Ferentschik
 */
public class CustomConstraintSerializableTest {

	@Test
	public void testSerializeHibernateEmail() throws Exception {
		Validator validator = ValidatorUtil.getValidator();

		HibernateEmail invalidHibernateEmail = new HibernateEmail();
		invalidHibernateEmail.email = "test@";

		Set<ConstraintViolation<HibernateEmail>> constraintViolations = validator.validate( invalidHibernateEmail );
		doSerialize( constraintViolations.iterator().next() );
	}

	/**
	 * HV-291
	 *
	 * @throws Exception in case the test fails
	 */
	@Test
	public void testSerializeCustomEmail() throws Exception {
		Validator validator = ValidatorUtil.getValidator();

		CustomEmail invalidCustomEmail = new CustomEmail();
		invalidCustomEmail.email = "test@";
		Set<ConstraintViolation<CustomEmail>> constraintViolations = validator.validate( invalidCustomEmail );
		doSerialize( constraintViolations.iterator().next() );
	}

	public static byte[] doSerialize(Object obj) throws Exception {
		ByteArrayOutputStream baos = new ByteArrayOutputStream( 512 );
		ObjectOutputStream out = new ObjectOutputStream( baos );
		out.writeObject( obj );
		out.close();
		return baos.toByteArray();
	}

	static class CustomEmail implements Serializable {
		private static final long serialVersionUID = -9095271389455131159L;

		@Email
		String email;

	}

	static class HibernateEmail implements Serializable {
		private static final long serialVersionUID = 7206154160792549270L;

		@org.hibernate.validator.constraints.Email
		String email;
	}
}


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

namespace ZTImage.WeChat.Payments
{
    /// <summary>
    /// 交易类型
    /// </summary>
    public enum TradeType
    {
        JSAPI,//公众号支付
        NATIVE,//扫码支付
        APP //app支付
    }
}


text:
//
// Copyright (c)1998-2011 Pearson Education, Inc. or its affiliate(s).
// All rights reserved.
//

package openadk.library;

import java.io.IOException;
import java.io.Serializable;

/**
 *  The abstract base class for all element and attribute classes in the SIF
 *  Data Objects library.

 *
 *  Agent developers do not generally work with this class directly.

 *
 *  ElementDef

 *
 *  Each Element instance is associated with an ElementDef that both identifies
 *  and describes the element or attribute encapsulated by this class. ElementDef
 *  constants are defined by the SIFDTD class for each element and
 * 	attribute defined in the SIF Specification. These objects provide
 * 	information about how to render elements in a version-dependent way,
 *  including the tag name and sequence number (which may vary from one version
 *  of SIF to the next), the SDO implementation class name, the earliest version
 *  of SIF the element or attribute appeared in, and the latest version of SIF
 *  that supports the element or attribute.

 *
 *  An ElementDef must be provided to the constructor.
 *
 *  @author Eric Petersen
 *  @version ADK 1.0
 */
public abstract class Element implements Serializable, Cloneable
{
	/**
	 * The default java serialization version for ADK SDO classes
	 */
	public static final int CURRENT_SERIALIZE_VERSION = 2;

	/**
	 *  State flag indicating this Element has a dirty value. This state is
	 *  enabled at the time of constuction (i.e. all elements are dirty by
	 *  default) and must be explicitly disabled by an agent as necessary.
	 */
	private static final byte DIRTY = 0x01;

	/**
	 *  State flag indicating this Element has an empty value. This state is
	 *  disabled at the time of construction, but may be set or cleared by
	 *  methods that set this element's value.
	 */
	private static final byte EMPTY = 0x02;

//	/**
//	 * State flag indicating that this Element has a "Deleted='True'" attribute.
//	 * The "Deleted='True'" attribute is a flag that has a meaning only for repeatable
//	 * elements
//	 */
//	protected static final byte DELETED = 0x04;

	/**
	 *  Option flag indicating XML Encoding of character entities should not
	 * 	be performed on this Element's text content when rendered by the ADK.
	 */
	private static final byte OPT_DO_NOT_ENCODE = 0x04;

	/**
	 *  Identifies this field by its ElementDef constant defined in SIFDTD
	 */
	protected transient ElementDef fElementDef;

	/**
	 *  State flags keep track of whether this Element is changed or has an
	 *  empty value. By default the ADK does not track the state of an Element
	 *  when the #setTextValue method is called to change its value. The
	 * 	programmer must explicitly call the #setChanged and #setEmpty methods
	 * 	to mark an Element as changed or empty.
	 */
	protected byte fFlags;

	/**
	 * 	The parent Element, or null if there is no parent
	 */
	protected Element fParent;

	/**
	 *  Constructor
	 *  @param def The metadata that describes this Element
	 */
    public Element( ElementDef def )
	{
		if( def == null )
			throw new RuntimeException( "SIF " + ADK.getSIFVersion() + " does not support this element or attribute, or the required SDO library is not loaded (" + getClass().toString() + ")" );

		fElementDef = def;
		fFlags = DIRTY;
    }

	/**
	 *  Gets the metadata for this Element
	 *  @return an ElementDef that describes this Element
	 */
	public ElementDef getElementDef()
	{
		return fElementDef;
	}

	/**
	 * 	Sets the metadata for this Element.

	 *
	 * 	Note this method should not generally be called by agents because the
	 * 	ElementDef metadata is established in the constructor. It is provided
	 * 	in order to support the dynamic creation of Element instances by clients
	 * 	that do not (or cannot) use reflection to call the default constructor.
	 * 	These clients can call the Class.newInstance method followed
	 * 	by setElementDef to construct an Element dynamically.

	 *
	 * 	@param def An ElementDef instance that describes this Element
	 */
	public void setElementDef( ElementDef def )
	{
		fElementDef = def;
	}

	/**
	 *  Gets the text value of this element if applicable. The
	 *  default format of the text value is the SIF 1.x format

	 *  To change the format used for Text values on elements, set the
	 *  {@link ADK#setTextFormatter(SIFFormatter)} property
	 *  @return The text value of this element
	 */
	public abstract String getTextValue();

	/**
	 *  Sets the text value of this element if applicable. The
	 *  text value will be parsed into the native datatype of the
	 *  the element.

	 *  The formatter used for parsing by default is
	 *  the SIF 1.x formatter, which means this value must be able
	 *  to be parsed using SIF 1.x formatting rules.
	 *  To change the format used for Text values on elements, set the
	 *  {@link ADK#setTextFormatter(SIFFormatter)} property
	 *  @param value The text value of this element
	 */
	public abstract void setTextValue( String value );

	/**
	 * Sets the SIF strongly-typed value of this element
	 * @param value The SIF Value to set
	 */
	public abstract void setSIFValue( SIFSimpleType value );

	/**
	 * Gets the SIF strongly-typed value of this element
	 * @return The value of this element as a <c>SIFSimpleType</c>
	 */
	public abstract SIFSimpleType getSIFValue();

	/**
	 *  Sets this DataObject and each of its children to the dirty state. An
	 *  object in the dirty state will not be written to an XML stream when a
	 *  SIF message is rendered.
	 */
	public void setChanged()
	{
		setChanged(true);
	}

	/**
	 *  Sets this DataObject and each of its children to the specified dirty
	 *  state. An object in the dirty state will not be written to an XML stream
	 *  when a SIF message is rendered.
	 *
	 *  @param changed true to set the dirty state, false to clear it
	 */
	public void setChanged( boolean changed )
	{
		if( changed ) {
			fFlags |= DIRTY;
			if( fParent != null ){
				fParent.setChildChanged();
			}
		} else {
			fFlags &= ~DIRTY;
		}
	}

	/**
	 * Called by children when they are set to a "changed" state. The
	 * parent of any child element that is changed should also be marked as
	 * changed (but not any other children of the parent).
	 */
	protected void setChildChanged(){
		// don't want to recurse children. This just a call
		// to recurse up the chain
		if( !isChanged() ){
			fFlags |= DIRTY;
			if( fParent != null ){
				fParent.setChildChanged();
			}
		}

	}

	/**
	 *  Sets this DataObject and each of its children to the empty state. An
	 *  object in the empty state will be written to an XML stream as an empty
	 *  element with no attributes and no child elements.
	 */
	public void setEmpty()
	{
		setEmpty(true);
	}

	/**
	 *  Sets this DataObject and each of its children to the specified empty
	 *  state.  An object in the empty state will be written to an XML stream as
	 *  an empty element with no attributes and no child elements.
	 *
	 *  @param empty true to set the empty state, false to clear it
	 */
	public void setEmpty( boolean empty )
	{
		if( empty ) {
			fFlags |= EMPTY;
		} else {
			fFlags &= ~EMPTY;
		}
	}

	/**
	 *  Determines if this object is in the changed state.
	 *  @return true if this object has been marked changed. The return value
	 *      assumes all children are in the same state.
	 */
	public boolean isChanged() {
		return ( fFlags & DIRTY ) != 0;
	}

	/**
	 *  Determines if this object is in the empty state
	 *  @return true if this object has explicitly been marked empty. The return
	 *      value assumes all children are in the same state.
	 */
	public boolean isEmpty() {
		return ( fFlags & EMPTY ) != 0;
	}

	/**
	 * 	Determines if automatic XML Encoding of character entities should be
	 * 	performed on this element when rendered by the ADK. By default, all
	 * 	elements and attributes are encoded. Use the #setDoNotEncode method to
	 * 	turn off automatic encoding for an element if you will be assigning
	 * 	XML content to its text value (e.g. if you are using SIF_ExtendedElement
	 * 	to exchange raw XML content with another agent).
	 *
	 * 	@return true if automatic XML Encoding is disabled for this
	 * 		element; false if enabled (the default)
	 */
	public boolean isDoNotEncode()
	{
		if( ( fFlags & OPT_DO_NOT_ENCODE ) != 0 )
			return true;
		if( fElementDef != null ) {
			return fElementDef.isDoNotEncode();
		}

		return false;
	}

	/**
	 * 	Determines if automatic XML Encoding of character entities should be
	 * 	performed on this element when rendered by the ADK. By default, all
	 * 	elements and attributes are encoded. Use this method to turn off
	 * 	automatic encoding for an element if you will be assigning XML content
	 * 	to its text value (e.g. if you are using SIF_ExtendedElement
	 * 	to exchange raw XML content with another agent).
	 *
	 * 	@param option true if automatic XML Encoding is disabled
	 * 		for this element; false if enabled (the default)
	 */
	public void setDoNotEncode( boolean option )
	{
		if( option ) {
			fFlags |= OPT_DO_NOT_ENCODE;
		} else {
			fFlags &= ~OPT_DO_NOT_ENCODE;
		}
	}

	/**
	 *  Compare the text value of this Element to another Element

	 *
	 *  @param target The Element to be compared
	 *
	 *  @return the value 0 if the argument's text value is
	 *      lexicographically equal to this Element's text value; a value less
	 *      than 0 if the argument's value is lexicographically
	 *      greater than this Element's text value; and a value greater than
	 *      0 if the argument's text value is lexicographically
	 *      less than this Element's text value. If one Element's text value is
	 *      null and the others is not, a negative value is returned.
	 */
	public int compareTo( Element target )
	{
		String s1 = getTextValue();
		String s2 = target.getTextValue();

		if( s1 != null && s2 != null )
			return s1.compareTo(s2);
		if( s1 == null && s2 == null )
			return 0;

		return -1;
	}

	private void writeObject( java.io.ObjectOutputStream out )
		throws IOException
	{
		out.defaultWriteObject();

		//
		// Write serialize version
		//
		out.write( CURRENT_SERIALIZE_VERSION );

	}

	private void readObject( java.io.ObjectInputStream in )
		throws IOException, ClassNotFoundException
	{
		in.defaultReadObject();

		//
		// Read serialize version
		//
		int version = in.read();
		// NOTE: This type of version checking is also done by the Java serialization
		// infrastructure. We decided to keep our check as well because we may decide
		// to implement our own versioning strategy. For now, however, just throw an exception
		// if the versions don't match.
		if( version != Element.CURRENT_SERIALIZE_VERSION ){
			throw new IOException("Cannot deserialize Element with version signature ("+version+")");
		}
	}

	/**
	 *  Returns the value of getTextValue
	 *  @return The text value of this element if applicable
	 */
	public String toString()
	{
		String retval = "";
		if (getTextValue() != null)
			retval = getTextValue();
		else if (fElementDef != null)
			retval = fElementDef.tag(ADK.getSIFVersion());

		return retval;
//		return getTextValue();
	}

	/**
	 *  Gets the parent of this Element.

	 * 	@return this Element's parent or null if it has none
	 * 	@see #setParent
	 */
	public Element getParent()
	{
		return fParent;
	}

	/**
	 *  Sets the parent of this Element.

	 * 	@param parent the new parent Element
	 * 	@see #getParent
	 */
	public void setParent( Element parent )
	{
		fParent = parent;
	}

	/**
	 * Enumerating the ancestry of this object to return the root Element

	 * @return the root Element that is a parent of this Element
	 */
	public Element getRoot()
	{
		if( fParent == null )
			return this;

		Element p = fParent;
		while( p.fParent != null )
			p = p.fParent;

		return p;
	}

}


text:
class CreateSourceFiles < ActiveRecord::Migration
  def change
    create_table :source_files do |t|
      t.string :file_name
      t.string :file_content_type
      t.integer :file_size
      t.string :url
      t.string :key
      t.string :bucket

      t.timestamps
    end
  end
end


text:
<experiment>
	<name value="btlive" />
	<playbackSeconds value="30" />
	<runs value="1" />
	<serverUploadBandwidth value="1668000000000" />
	<messageHeaderSize value="64" />
	<seed value="12345678" />
	<descriptions value="6" />
	<cycleLength value="1000" />
	<framework value="PeerSimFramework" dropRate="0.0"  />
	<churnModel type="sessionLengthAddOnFailure">
		<sessionLengthDistribution>
			<distribution type="LogNormalDistribution" mean="5.29"
				variance="1.28" />
		</sessionLengthDistribution>
	</churnModel>
	<bitrate value="500000" /> <!-- 500 kbps -->

	<playerModule waitIfNoChunk="true" bufferFromFirstChunk="true"
		serverStartup="10000" startupBuffering="1000" streamWindowSize="120" />

	<uploadBandwidthDistribution>
		<distribution type="ConstantDistribution" value="556000000.0" />
	</uploadBandwidthDistribution>

	<streamingModule algorithm="PushMultipleSubstreamTree"
		sendMissingChunks="true" size="100">
		<overlayModule clubsForPeer="2"
			algorithm="BittorrentLiveOverlay" minInClubDownload="2"
			maxInClubDownload="3" parentDropTimeout="0" />
	</streamingModule>
</experiment>


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
Copyright 2020 The Chromium Authors
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
-->

<resources>
    <drawable name="ic_more_vert_24dp">@drawable/ic_more_vert_24dp_on_dark_bg</drawable>
</resources>


text:
/**
 * This is a comment!
 */

/** Another comment. */


text:
<?php

/**
 * For instructions on how to run the full sample:
 *
 * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/master/storage/README.md
 */

namespace Google\Cloud\Samples\Storage;

# [START storage_file_download_into_memory]
use Google\Cloud\Storage\StorageClient;

/**
 * Download an object from Cloud Storage and save into a buffer in memory.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 */
function download_object_into_memory(
    string $bucketName,
    string $objectName
): void {
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $contents = $object->downloadAsString();
    printf(
        'Downloaded %s from gs://%s/%s' . PHP_EOL,
        $contents,
        $bucketName,
        $objectName
    );
}
# [END storage_file_download_into_memory]

// The following 2 lines are only needed to run the samples
require_once __DIR__ . '/../../testing/sample_helpers.php';
\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);


text:
#ifndef statement_create_index_hpp
#define statement_create_index_hpp

#include <WCDB/statement.hpp>

namespace WCDB {

class StatementCreateIndex : public Statement {
public:
    StatementCreateIndex &create(const std::string &index,
                                 bool unique = false,
                                 bool ifNotExists = true);

    template <typename T>
    typename std::enable_if<std::is_base_of<ColumnIndex, T>::value,
                            StatementCreateIndex &>::type
    on(const std::string &table, const std::list<const T> &indexList)
    {
        m_description.append(" ON " + table + "(");
        joinDescribableList(indexList);
        m_description.append(")");
        return *this;
    }
    StatementCreateIndex &where(const Expr &expr);

    virtual Statement::Type getStatementType() const override;
};

} //namespace WCDB

#endif /* statement_create_index_hpp */


text:
/**
 * @class Oskari.mapframework.request.common.ChangeMapLayerOpacityRequest
 * Requests opacity change for maplayer with given id
 *
 * Requests are build and sent through Oskari.mapframework.sandbox.Sandbox.
 * Oskari.mapframework.request.Request superclass documents how to send one.
 */
Oskari.clazz.define('Oskari.mapframework.request.common.ChangeMapLayerOpacityRequest',

/**
 * @method create called automatically on construction
 * @static
 *
 * @param {String}
 *            mapLayerId id for maplayer to be modified (Oskari.mapframework.service.MapLayerService)
 * @param {Number}
 *            opacity (0-100)
 */
function(mapLayerId, opacity) {
    this._creator = null;
    this._mapLayerId = mapLayerId;

    this._opacity = opacity;

}, {
    /** @static @property __name request name */
    __name : "ChangeMapLayerOpacityRequest",
    /**
     * @method getName
     * @return {String} request name
     */
    getName : function() {
        return this.__name;
    },
    /**
     * @method getOpacity
     * @return {Number} from 0 to 100 (0 = invisible)
     */
    getOpacity : function() {
        return this._opacity;
    },
    /**
     * @method getMapLayerId
     * @return {String} id for map layer used in Oskari.mapframework.service.MapLayerService
     */
    getMapLayerId : function() {
        return this._mapLayerId;
    }
}, {
    /**
     * @property {String[]} protocol array of superclasses as {String}
     * @static
     */
    'protocol' : ['Oskari.mapframework.request.Request']
});


text:
---
layout: page
title: "Tristan Foureur - Blog"
cover: "https://dl.dropboxusercontent.com/s/3t9iwrmipq0ji13/2013-04-28%2017.20.06.jpg?token_hash=AAGWOLybBbAkNvJqiNyHKLSIqykyQfDcEQ2AWjcj7VpRpA"
---

    {% for post in site.posts %}

      {{ post.date | date: "%B %e, %Y" }} {{ post.title }}

{{ post.excerpt}}

      	Read more |

    {% endfor %}


text:
[![](https://vsmarketplacebadge.apphb.com/version-short/octref.vetur.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=octref.vetur)
[![](https://vsmarketplacebadge.apphb.com/installs-short/octref.vetur.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=octref.vetur)
[![](https://vsmarketplacebadge.apphb.com/rating-short/octref.vetur.svg?style=flat-square)](https://marketplace.visualstudio.com/items?itemName=octref.vetur)

Vue tooling for VS Code, powered by [vue-language-server](https://github.com/vuejs/vetur/tree/master/server).

Try it out with [Veturpack](https://github.com/octref/veturpack)!

🎉 VueConf 2017 [Slide](https://www.dropbox.com/sh/eb4w8k3orh0j391/AAB3HaJexbGLa2tCP14BI8oJa?dl=0) & [Video](https://www.youtube.com/watch?v=05tNXJ-Kric) 🎉

This extension is under heavy development.
You can [open an issue](https://github.com/vuejs/vetur/issues/new) for bugs or feature requests.

## Features

- [Syntax-highlighting](highlighting.md)
- [Snippet](snippet.md)
- [Emmet](emmet.md)
- [Linting / Error Checking](linting-error.md)
- [Formatting](formatting.md)
- [IntelliSense](intellisense.md)
- [Debugging](debugging.md)
- [Framework Support](framework.md) for [Element UI](http://element.eleme.io) and [Onsen UI](https://onsen.io)

## Quick Start

- Install [Vetur](https://marketplace.visualstudio.com/items?itemName=octref.vetur).
- Try it with [Veturpack](https://github.com/octref/veturpack), a pre-configured Vue boilerplate based on [Vuepack](https://github.com/egoist/vuepack).
- Refer to [setup](setup.md) page for setting up.
- Refer to each feature's own page for setting up specific features.

## Contributing

[Contribution Guide](https://github.com/vuejs/vetur/blob/master/.github/CONTRIBUTING.md).

## License

MIT © [Pine Wu](https://github.com/octref)


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

namespace FODT.Views.Person
{
    public class EditPersonViewModel
    {
        public static EditPersonViewModel Empty()
        {
            return new EditPersonViewModel() { Photos = new List<Photo>() };
        }

        public string POSTUrl { get; set; }

        public int? PersonId { get; set; }

        public string Honorific { get; set; }
        public string FirstName { get; set; }
        public string MiddleName { get; set; }
        public string LastName { get; set; }
        public string Suffix { get; set; }
        public string Nickname { get; set; }
        public string Biography { get; set; }

        public int? DefaultPhotoId { get; set; }

        public List<Photo> Photos { get; set; }

        public class Photo
        {
            public int PhotoItemId { get; set; }
            public string PhotoTinyURL { get; set; }
            public string PhotoThumbnailURL { get; set; }
        }
    }
}


text:
using System.Linq;
using FluentAssertions;
using MyCouch.Requests;
using MyCouch.Testing;
using MyCouch.Testing.Model;
using MyCouch.Testing.TestData;
using Xunit;
using System.Collections.Generic;
using MyCouch.Net;
using System.Xml.Linq;
using IntegrationTests.TestFixtures;
using MyCouch;

namespace IntegrationTests.CoreTests
{
    public class ShowTests : IntegrationTestsOf<IDocuments>,
        IPreserveStatePerFixture,
        IClassFixture<ShowsFixture>
    {
        protected Artist[] ArtistsById { get; set; }

        public ShowTests(ShowsFixture data)
        {
            ArtistsById = data.Init(Environment);
            SUT = DbClient.Documents;
        }

        [MyFact(TestScenarios.ShowsContext)]
        public void Can_query_show_that_can_work_without_doc_id()
        {
            var query = new QueryShowRequest(ClientTestData.Shows.ArtistsHelloShowId);

            var response = SUT.ShowAsync(query).Result;

            response.Should().BeGetOfHtml();
        }

        [MyFact(TestScenarios.ShowsContext)]
        public void When_querying_show_that_transforms_doc_to_json_It_should_return_json()
        {
            var artist = ArtistsById.First();
            var query = new QueryShowRequest(ClientTestData.Shows.ArtistsJsonShowId).Configure(c => c.DocId(artist.ArtistId));

            var response = SUT.ShowAsync(query).Result;

            response.Should().BeGetOfJson();
            var transformedArtist = DbClient.Entities.Serializer.Deserialize<dynamic>(response.Content);
            ((string)transformedArtist.name).Should().Be(artist.Name);
        }

        [MyFact(TestScenarios.ShowsContext)]
        public void Can_send_custom_query_parameters_to_show()
        {
            var artist = ArtistsById.First();
            var customQueryParams = new Dictionary<string, object>();
            customQueryParams.Add("foo", 42);
            var query = new QueryShowRequest(ClientTestData.Shows.ArtistsJsonShowWithCustomQueryParamId)
                .Configure(c => c.DocId(artist.ArtistId)
                .CustomQueryParameters(customQueryParams)
                );

            var response = SUT.ShowAsync(query).Result;

            response.Should().BeGetOfJson();
            var transformedArtist = DbClient.Entities.Serializer.Deserialize<dynamic>(response.Content);
            ((string)transformedArtist.name).Should().Be(artist.Name);
            ((string)transformedArtist.foo).Should().Be("42");
        }

        [MyFact(TestScenarios.ShowsContext)]
        public void When_querying_show_that_transforms_doc_to_xml_It_should_return_xml()
        {
            var artist = ArtistsById.First();
            var query = new QueryShowRequest(ClientTestData.Shows.ArtistsXmlShowId)
                .Configure(c => c.DocId(artist.ArtistId)
                .Accepts(HttpContentTypes.Xml)
                );

            var response = SUT.ShowAsync(query).Result;

            response.Should().BeGetOfXml();
            var transformedArtist = XElement.Parse(response.Content);
            transformedArtist.Value.Should().Be(artist.Name);
        }
    }
}


text:
"use strict";

define(['src/exposureFunctions'], function (exposureFunctions) {
	module("exposureFunctions");

	test("convert to thirds and back", function () {
		equal(exposureFunctions.thirdsToISO(exposureFunctions.ISOToThirds(100)), 100, "ISO");
		equal(exposureFunctions.thirdsToISO(exposureFunctions.ISOToThirds(200)), 200, "ISO");
		equal(exposureFunctions.thirdsToISO(exposureFunctions.ISOToThirds(400)), 400, "ISO");
		equal(exposureFunctions.thirdsToAperture(exposureFunctions.apertureToThirds(1)), 1, "Aperture");
		equal(exposureFunctions.thirdsToAperture(exposureFunctions.apertureToThirds(1.4)), 1.4, "Aperture");
		equal(exposureFunctions.thirdsToAperture(exposureFunctions.apertureToThirds(2)), 2, "Aperture");
		equal(exposureFunctions.thirdsToShutter(exposureFunctions.shutterToThirds(1/64)), 1/64, "Shutter");
	});
});


text:
import { loadPlugins, resetPlugins } from 'react-plugin';
import {
  pushUrlParams,
  popUrlParams,
  resetUrl,
} from '../../../testHelpers/url';
import { onRouter } from '../../../testHelpers/pluginMocks';

beforeEach(() => jest.isolateModules(() => require('..')));

afterEach(() => {
  resetPlugins();
  resetUrl();
});

const fixtureId = { path: 'zwei.js', name: null };

it('emits "fixtureChange" event on "fixtureId" URL param change', () => {
  const { fixtureChange } = onRouter();

  loadPlugins();
  popUrlParams({ fixtureId: JSON.stringify(fixtureId) });

  expect(fixtureChange).toBeCalledWith(expect.any(Object), fixtureId);
});

it('emits "fixtureChange" event on removed "fixtureId" URL param', async () => {
  const { fixtureChange } = onRouter();

  pushUrlParams({ fixtureId: JSON.stringify(fixtureId) });
  loadPlugins();

  // This simulation is akin to going back home after selecting a fixture
  popUrlParams({});

  expect(fixtureChange).toBeCalledWith(expect.any(Object), null);
});


text:
<title>Multiverse</title>

Get Multiverse

Download a free Multiverse Client

<form action="reg1.jsp" method="post">

<input type="submit" value="New User">

</form>

<form action="download.html" method="get">

<input type="submit" value="Upgrade">

last update: 2/24/05

</form>

What's new

System Req's

FAQ

Description of The Multiverse goes here...

with screen shot

technology  |
team   |
cool place

© Copyright Multiverse Network 2005. All rights reserved.