text:
layout: post
title: Building Xen-3.4 testing and linux-2.6.31.10 domain0 kernel on Debian-testing
categories:
- Kernel
- Linux
- Opensource
- Virtualization
- Xen
tags: []
status: publish
type: post
published: true
comments: true
meta:
  _edit_last: '1'
---
This is a howto on compiling and installing Xen 3.4 testing from the repository and linux kernel 2.6.31.10 for a Debian squeeze domain0.</

Note: Try and do everything as root. If you do a make and then make install with different users, it will completely recompile over again.
Now even though linux-2.6.18-xen is the proper kernel to be using for a Xen domain0, the new version of udev in all the usable distros do not support the older kernels (anything before 2.6.25 I believe). So I will be using the 2.6.31.10 kernel along with the gentoo Xen patches. Lets see how this goes.

Getting the source:

Install Mercurial
{% highlight sh %}
> aptitude install mercurial
{% endhighlight %}
Get the Xen Source
{% highlight sh %}
> hg clone http://xenbits.xensource.com/xen-3.4-testing.hg
{% endhighlight %}
Get the Xen domain0 Linux kernel source and the patches from here and here respectively:
{% highlight sh %}
> wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.31.10.tar.bz2
> wget http://gentoo-xen-kernel.googlecode.com/files/xen-patches-2.6.31-10.tar.bz2
{% endhighlight %}
Now unpack them with
{% highlight sh %}
> tar -jxvf linux-2.6.31.10.tar.bz2
> mkdir xen-patches
> cd xen-patches
> tar -jxvf ../xen-patches-2.6.31-10.tar.bz2
> cd ~/
{% endhighlight %}

Apply the patches

{% highlight sh %}
>cd linux-2.6.31.10
>cat ../xen-patches/* | patch -p1
{% endhighlight %}
Now you probably want to rename your kernel to indicate is has been patched. You can also modify the "Extra version" variable in make menuconfig later on if you want the kernel to have a different name to show up with 'uname'.
{% highlight sh %}
> cd ~/
> mv linux-2.6.31.10 linux-2.6.31.10-xen
{% endhighlight %}

Get Dependencies:

There are quite a lot of dependencies. Too many to list individually, but here's how to install them all:
{% highlight sh %}
> aptitude install gawk bzip2 mercurial transfig bzip2 screen ssh debootstrap iproute bridge-utils python-twisted binutils zlib1g-dev python-dev python python-central libssl-dev install libcurl3-dev libncurses5-dev x-dev build-essential gettext libx11-dev make bin86 bcc gcc ncurses-dev patch xorg-dev transfig libsdl1.2-dev libvncserver-dev udev pciutils-dev graphviz texlive-latex-base git-core texinfo texlive-latex-extra texlive-font-utils texlive-fonts-extra texlive-fonts-recommended
{% endhighlight %}
Grab a coffee...

Compiling:

Enter the Xen source directory
{% highlight sh %}
> cd xen-3.4-testing.hg
{% endhighlight %}

Cross your fingers and start compiling
{% highlight sh %}
> make
{% endhighlight %}

Or if you have a fast machine with lots of cores, use the -j switch. Usually you use the number of cores you have plus 2.
{% highlight sh %}
> make -j 4
{% endhighlight %}

This will take a long time...grab another coffee, If the build fails anywhere I may have missed a dependency. Its usually pretty obvious what the dependency is by the build error message. Just go install it and try again.
Xen is hopefully compiled so we can take care of the kernel. Onward with our linux-2.6.31.10-xen kernel.
{% highlight sh %}
cd linux-2.6.31.10-xen
> make menuconfig
{% endhighlight %}

You need to enable Xen Support (under processor type and features) as well as Priviledged Domain (under device drivers->Xen) and I also set Xen compatibility to 3.3.0 and above (under device drivers->Xen->Xen Version compatibility). Once you've enabled everything you think you'll need, start compiling.
{% highlight sh %}
> make
{% endhighlight %}

Once its done without errors, go ahead and install it, but do not use the -j option for the install.
{% highlight sh %}
> make install
{% endhighlight %}

Also you need to install the modules
{% highlight sh %}
> make modules_install
{% endhighlight %}

Once that is done, look in the /boot directory
{% highlight sh %}
> cd /boot && ls
{% endhighlight %}

You should see some files: xen-3.4.3-rc3-pre.gz and vmlinuz-2.6.31.10. If not, you need to go back and deal with the problem because nothing will work past this point.
Also check the /lib/modules directory for a directory called 2.6.31.10

Generate an initrd image:

So you've got Xen and the linux kernel compiled, now you need an initrd image to go along with the kernel. Enter the /boot directory:
{% highlight sh %}
> cd /boot
{% endhighlight %}

Setup the dependencies for the initrd image:
{% highlight sh %}
> depmod -a 2.6.31.10
{% endhighlight %}

Now generate an initrd image using the mkinitramfs command
{% highlight sh %}
> mkinitramfs -o initrd.img-xen 2.6.31.10
{% endhighlight %}
There should now be a file called initrd.img-xen in /boot

Grub2:

This can be a bit of a pain because of grub2 being rather....Beta, but we cant let that stop us. (If you have grub legacy, look here)
Make sure you have a livecd available in case you make a mistake with the config file formatting and grub fails. Now open the grub config file using your favorite editor (which is probably vim because otherwise your insane) like this
{% highlight sh %}
> vim /boot/grub/grub.cfg
{% endhighlight %}
Scoll down to where you see the menuentries. Add your own entry with something like this.
{% highlight sh %}
menuentry "Xen, with Linux 2.6.31.10" {
        echo    Loading Linux 2.6.18.8-xen ...
        multiboot       /boot/xen-3.4.3-rc3-pre.gz
        module  /boot/vmlinuz-2.6.31.10 dummy=dummy root=/dev/sda1 ro
        module  /boot/initrd.img-xen
}
{% endhighlight %}
You may notice a few things different. You need to use multiboot and modules to pass Xen, the kernel and your initrd img into grub2. Also you may notice the parameter dummy=dummy going into the kernel, this is because at the time of writing this, there is a bug in grub2 which causes the first parameter not to be passed into the kernel. So we can create a useless one as the first parameter. That way when they fix the bug nothing horrible will happen to our bootup. Also you may not want to put your new entry at the top until you are sure everything works because grub defaults to the top entry.

Booting:

Cross your fingers and reboot! Hold shift to get grub to show you a list if it doesnt by default. If it boots congratulations.

Testing a guest domain:

Now you probably want to setup a Virtual Machine to test your setup. http://stacklet.com/ has some pre-build appliance images you can grab and test with. Check out this post for more info on starting a virtual machine.


text:
package io.kubernetes.client.extended.kubectl;

import io.kubernetes.client.common.KubernetesObject;
import io.kubernetes.client.custom.V1Patch;
import io.kubernetes.client.extended.kubectl.exception.KubectlException;
import io.kubernetes.client.openapi.ApiException;
import io.kubernetes.client.openapi.apis.AppsV1Api;
import io.kubernetes.client.openapi.models.V1Deployment;
import io.kubernetes.client.openapi.models.V1ReplicaSet;
import io.kubernetes.client.openapi.models.V1StatefulSet;
import io.kubernetes.client.util.PatchUtils;

public class KubectlScale<ApiType extends KubernetesObject>
    extends Kubectl.ResourceBuilder<ApiType, KubectlScale<ApiType>>
    implements Kubectl.Executable<ApiType> {
  private int replicas;

  KubectlScale(Class<ApiType> apiTypeClass) {
    super(apiTypeClass);
    this.replicas = -1;
  }

  public KubectlScale<ApiType> replicas(int replicas) {
    this.replicas = replicas;
    return this;
  }

  @Override
  public ApiType execute() throws KubectlException {
    validate();

    String jsonPatchStr =
        String.format("[{\"op\":\"replace\",\"path\":\"/spec/replicas\",\"value\":%d}]", replicas);

    AppsV1Api api = new AppsV1Api(this.apiClient);
    try {
      if (apiTypeClass.equals(V1Deployment.class)) {
        return PatchUtils.patch(
            apiTypeClass,
            () ->
                api.patchNamespacedDeploymentCall(
                    name,
                    namespace,
                    new V1Patch(jsonPatchStr),
                    null,
                    null,
                    null,
                    null, // field-manager is optional
                    null,
                    null),
            V1Patch.PATCH_FORMAT_JSON_PATCH,
            this.apiClient);
      } else if (apiTypeClass.equals(V1ReplicaSet.class)) {
        return PatchUtils.patch(
            apiTypeClass,
            () ->
                api.patchNamespacedReplicaSetCall(
                    name, namespace, new V1Patch(jsonPatchStr), null, null, null, null, null, null),
            V1Patch.PATCH_FORMAT_JSON_PATCH,
            this.apiClient);
      } else if (apiTypeClass.equals(V1StatefulSet.class)) {
        return PatchUtils.patch(
            apiTypeClass,
            () ->
                api.patchNamespacedStatefulSetCall(
                    name, namespace, new V1Patch(jsonPatchStr), null, null, null, null, null, null),
            V1Patch.PATCH_FORMAT_JSON_PATCH,
            this.apiClient);
      } else {
        throw new KubectlException("Unsupported class for scale: " + apiTypeClass);
      }
    } catch (ApiException ex) {
      throw new KubectlException(ex);
    }
  }

  private void validate() throws KubectlException {
    StringBuilder msg = new StringBuilder();
    if (name == null) {
      msg.append("Missing name, ");
    }
    if (namespace == null) {
      msg.append("Missing namespace, ");
    }
    if (replicas < 0) {
      msg.append("Invalid replicas");
    }
    if (msg.length() > 0) {
      throw new KubectlException(msg.toString());
    }
  }
}

redpajama_set_name: RedPajamaGithub


text:
gui::Horizontal_slider::Horizontal_slider(long long max, long long min) : _left{"<"}, _right{">"}, _max{ max }, _min{ min }
{
	sf::Color gray{ 171, 171, 171, 255 };

	_left.getBackground().setColor(gray);
	_left.getFunction().set([this]() {this->subtract(); });
	_right.getBackground().setColor(gray);
	_right.getFunction().set([this]() {this->add(); });

	_middle.getBackground().setColor(gray);
	_middle.getFrame().setThickness(1);
	_middle.getFrame().setColor(sf::Color::Black);

	setValue(_min);
}

void gui::Horizontal_slider::setSize(const sf::Vector2f & size)
{
	_size = size;

	resize();
}

void gui::Horizontal_slider::setPosition(const sf::Vector2f & position)
{
	_position = position;
	float frame_thickness = _frame.getThickness();

	_left.setPosition({ _position.x + frame_thickness, _position.y + frame_thickness });
	_right.setPosition({ _position.x + _size.x - frame_thickness - _button_min_size.x, _position.y + frame_thickness });

	auto current_step = getCurrentStep();

	_middle.setPosition({ _position.x + frame_thickness + _left.getSize().x + current_step * _middle_button_min_size.x, _position.y + frame_thickness });

	sf::Rect<float> to_fit{ { _position.x + frame_thickness,  _position.y + frame_thickness }, { _size.x - 2 * frame_thickness, _size.y - 2 * frame_thickness } };
	_background.fitTo(to_fit);
	_frame.fitTo(to_fit);
}

const sf::Vector2f & gui::Horizontal_slider::getSize() const
{
	return _size;
}

const sf::Vector2f & gui::Horizontal_slider::getPosition() const
{
	return _position;
}

const sf::Rect<float> gui::Horizontal_slider::getGlobalBounds() const
{
	return _frame.getGlobalBounds();
}

void gui::Horizontal_slider::up_date(gui::duration time_elapsed, const Mouse_info & mouse_info)
{
	setMiddleButtonPosition(mouse_info);

	_function(mouse_info, time_elapsed, this);
}

void gui::Horizontal_slider::draw(sf::RenderTarget & render_target) const
{
	_background.draw(render_target);
	_left.draw(render_target);
	_right.draw(render_target);
	_middle.draw(render_target);
	_frame.draw(render_target);
}

void gui::Horizontal_slider::setOwner(owner & owner)
{
	owner.addObject(_left);
	owner.addObject(_right);
	owner.addObject(_middle);

	setValue(_value);
}

void gui::Horizontal_slider::removeFromOwner(owner & owner)
{
	owner.remove(&_left);
	owner.remove(&_right);
	owner.remove(&_middle);
}

bool gui::Horizontal_slider::isActive() const
{
	return _active;
}

bool gui::Horizontal_slider::isHover() const
{
	return _hover;
}

bool gui::Horizontal_slider::isClicked() const
{
	return _clicked;
}

bool gui::Horizontal_slider::isFocused() const
{
	return _focus;
}

bool gui::Horizontal_slider::isHoverChange() const
{
	return _hover_change;
}

bool gui::Horizontal_slider::isClickedChange() const
{
	return _clicked_change;
}

bool gui::Horizontal_slider::isNeedResize() const
{
	return _need_resize;
}

void gui::Horizontal_slider::setActive(bool active)
{
	_active = active;
}

void gui::Horizontal_slider::setFocus(bool focus)
{
	_focus = focus;
}

void gui::Horizontal_slider::setValue(long long value)
{
	if (value > _max)
	{
		_value = _max;
	}
	else if (value < _min)
	{
		_value = _min;
	}
	else
	{
		_value = value;
	}

	if (_value == _min)
	{
		auto color = _left.getLabel().getColor();
		color.a = 95;
		_left.getLabel().setColor(color);

		color = _right.getLabel().getColor();
		color.a = 255;
		_right.getLabel().setColor(color);
	}
	else if (_value == _max)
	{
		auto color = _right.getLabel().getColor();
		color.a = 95;
		_right.getLabel().setColor(color);

		color = _left.getLabel().getColor();
		color.a = 255;
		_left.getLabel().setColor(color);
	}
	else
	{
		auto color = _left.getLabel().getColor();
		color.a = 255;
		_left.getLabel().setColor(color);

		color = _right.getLabel().getColor();
		color.a = 255;
		_right.getLabel().setColor(color);
	}

	if (_value == _min && _value == _max)
	{
		auto color = _right.getLabel().getColor();
		color.a = 95;
		_right.getLabel().setColor(color);

		color = _left.getLabel().getColor();
		color.a = 95;
		_left.getLabel().setColor(color);
	}

	setPosition(_position);
}

void gui::Horizontal_slider::setMinMax(long long min, long long max)
{
	_min = min;
	_max = max;

	setValue(_value);

	resize();
}

long long gui::Horizontal_slider::getMaxSteps() const
{
	float middle_size_x = _size.x - 2 * _frame.getThickness() - 2 * _button_min_size.x;
	long long max_steps = static_cast<long long>(std::floor(middle_size_x / _middle_button_min_size.x)) - 1;

	return max_steps;
}

float gui::Horizontal_slider::getMinButtonSize() const
{
	return _button_min_size.y;
}

long long gui::Horizontal_slider::getValue() const
{
	return _value;
}

std::pair<long long, long long> gui::Horizontal_slider::getMinMax() const
{
	return std::pair<long long, long long>{ _min, _max };
}

void gui::Horizontal_slider::resize()
{
	_need_resize = false;

	bool fit_x = _size.x >= 2 * _button_min_size.x;
	bool fit_y = _size.y >= _button_min_size.y;

	float frame_thickness = _frame.getThickness();

	if (fit_x && fit_y)
	{
		sf::Vector2f button_size{ _button_min_size.x, _size.y - 2 * frame_thickness };
		_left.setSize(button_size);
		_right.setSize(button_size);

		long long steps = _max - _min;

		float middle_size_x = _size.x - 2 * frame_thickness - 2 * button_size.x;

		if (steps < 1)
		{
			_middle.setSize({ middle_size_x, _size.y - 2 * frame_thickness });
		}
		else
		{
			long long max_steps = static_cast<long long>(std::floor(middle_size_x / _middle_button_min_size.x)) - 1;

			if (max_steps < steps)
			{
				steps = max_steps;

				_max = _min + max_steps;

				setValue(_value);
			}

			if (max_steps < 2)
			{
				_middle.setSize({ middle_size_x, _size.y - 2 * frame_thickness });
			}
			else
			{
				_middle.setSize({ middle_size_x - steps * _middle_button_min_size.x , _size.y - 2 * frame_thickness });
			}
		}
	}
	else
	{
		if (!fit_x)
		{
			_size.x = 2 * _button_min_size.x + 2 * frame_thickness;
		}

		if (!fit_y)
		{
			_size.y = _button_min_size.y + 2 * frame_thickness;
		}

		resize();
	}

	setPosition(_position);
}

gui::modifier::Frame_modifier & gui::Horizontal_slider::getFrame()
{
	_need_resize = true;
	return _frame;
}

const gui::modifier::Frame_modifier & gui::Horizontal_slider::getFrame() const
{
	return _frame;
}

gui::modifier::Background_modifier & gui::Horizontal_slider::getBackground()
{
	_need_resize = true;
	return _background;
}

const gui::modifier::Background_modifier & gui::Horizontal_slider::getBackground() const
{
	return _background;
}

gui::modifier::Function_modifier & gui::Horizontal_slider::getFunction()
{
	return _function;
}

const gui::modifier::Function_modifier & gui::Horizontal_slider::getFunction() const
{
	return _function;
}

gui::modifier::Button_modifier & gui::Horizontal_slider::getLeft()
{
	_need_resize = true;
	return _left;
}

const gui::modifier::Button_modifier & gui::Horizontal_slider::getLeft() const
{
	return _left;
}

gui::modifier::Button_modifier & gui::Horizontal_slider::getRight()
{
	_need_resize = true;
	return _right;
}

const gui::modifier::Button_modifier & gui::Horizontal_slider::getRight() const
{
	return _right;
}

gui::modifier::Button_modifier & gui::Horizontal_slider::getMiddle()
{
	_need_resize = true;
	return _middle;
}

const gui::modifier::Button_modifier & gui::Horizontal_slider::getMiddle() const
{
	return _middle;
}

void gui::Horizontal_slider::setHover(bool hover)
{
	_hover = hover;
}

void gui::Horizontal_slider::setClicked(bool clicked)
{
	_clicked = clicked;
}

void gui::Horizontal_slider::setHoverChange(bool hover_change)
{
	_hover_change = hover_change;
}

void gui::Horizontal_slider::setClickedChange(bool clicked_change)
{
	_clicked_change = clicked_change;
}

unsigned long long gui::Horizontal_slider::getCurrentStep()
{
	return _value - _min;
}

void gui::Horizontal_slider::add()
{
	if (_right.isClickedChange() && _right.isClicked())
	{
		setValue(_value + 1);
	}
}

void gui::Horizontal_slider::subtract()
{
	if (_left.isClickedChange() && _left.isClicked())
	{
		setValue(_value - 1);
	}
}

void gui::Horizontal_slider::setMiddleButtonPosition(const Mouse_info & mouse_info)
{
	if (_middle.isClicked() && _middle.isClickedChange())
	{
		_mouse_move = { 0, 0 };
	}

	if (!isClicked() && isClickedChange())
	{
		_follow_mouse = false;
	}

	if ((_middle.isClicked() || _middle.isClickedChange()) || (_follow_mouse && isClicked()))
	{
		_mouse_move += mouse_info.getMouseMove();

		_follow_mouse = true;
	}

	if (_mouse_move.x > _middle_button_min_size.x)
	{
		setValue(_value + 1);
		_mouse_move.x -= _middle_button_min_size.x;
	}
	else if (_mouse_move.x < -_middle_button_min_size.x)
	{
		setValue(_value - 1);
		_mouse_move.x += _middle_button_min_size.x;
	}

	if (isHover())
	{
		auto wheel_move = mouse_info.getMouseWheelMove();

		if (wheel_move > 0)
		{
			setValue(_value + 1);
		}
		else if (wheel_move < 0)
		{
			setValue(_value - 1);
		}
	}
}


text:
package store.vxdesign.apps.cryptography.algorithms.mh;

/**
 * Merkle-Hellman knapsack cryptosystem enumeration class of results.
 *
 * @author Roman Mashenkin
 * @since 20.10.2017
 */
public enum MerkleHellmanResultType {

    TEXT_INPUT, BINARY_INPUT, HEX_INPUT, PRIVATE_KEY, PUBLIC_KEY, OUTPUT_SUMS, INPUT_SUMS, TEXT_OUTPUT, BINARY_OUTPUT,
    HEX_OUTPUT
}


text:
FOUNDATION_EXPORT double MTouchIDVersionNumber;

//! Project version string for MTouchID.
FOUNDATION_EXPORT const unsigned char MTouchIDVersionString[];

// In this header, you should import all the public headers of your framework using statements like #import <MTouchID/PublicHeader.h>


text:
\section{Beweiserschnittstelle}%

Die Beweiserschnittstelle lässt Worthwhile-""Programm"-spezifikationen
und prädikatenlogische Formeln mit Kontext von einem Beweiser
überprüfen. Der Formelkontext kann zum Beispiel einem
Ausführungszustand entsprechen, sodass eine Programm"-spezifikation
auch nur für konkrete statt für alle Programmdurchläufe geprüft werden
kann. Das dem Aufrufer zurückgelieferte Überprüfungsergebnis besteht
unter anderem aus der Programm"-spezifikations-"" bzw.\
Formelvalidität.

In den folgenden Abschnitten wird zunächst das Format der Eingaben,
anschließend deren Vorbereitung für einen Beweiseraufruf und zuletzt
die Ergebniserstellung aus der Beweiserausgabe beschrieben.%

\subsection{Eingabedaten}%

\subsubsection{Worthwhile-""Programm"-spezifikation}%

Die Programm"-spezifikation wird dem Abstract-""Syntax-""Tree~(AST)
entnommen, welcher aus einem Worthwhile-""Text erstellt wurde. Sie
setzt sich aus dem WHILE-""Programmtext und den Annotationen
zusammen.%

Siehe \type{AST::Program}%

Siehe \texttt{SpecificationChecker::checkProgram}%

\subsubsection{Prädikatenlogische Formel mit Kontext}%

Die Formel wird einem AST entnommen, dessen Wurzelknoten ein
Worthwhile-""Ausdruck ist. Insbesondere ist unbekannt, wo die Formel
in einem Programmtext steht oder wie ihre Validität verwendet wird.
Den Kontext geben eine Abbildung von Variablen auf Bedeutungen
und eine Axiomliste an.%

Siehe \type{AST::Expression}%

Siehe \texttt{SpecificationChecker::checkAnnotation}%

\subsection{Vorbereitungen für einen Beweiseraufruf}%

In den folgenden Unterabschnitten werden die Vorbereitungen der
Beweiserschnittstelle an den Eingabedaten, bevor diese an den
Beweiser übergeben werden, beschrieben. Die Vorbereitungen
betreffen Worthwhile-spezifische Syntax und Semantik.%

\subsubsection{Axiome}%

Axiome werden als Annahmen behandelt, die für die gesamte
Spezifikation bzw.\ Formel gelten.%

\subsubsection{Funktionsdefinition}%

Funktionen werden modular spezifiziert und überprüft. Ihre
Spezifikation besteht sowohl aus Annahmen über die Aktualparameter
eines Funktionsaufrufs als auch aus Zusicherungen, welche für den
Rückgabewert gelten müssen. Die Annahmen werden Vorbedingungen
genannt und gelten als solche für den gesamten Funktionskörper. Die
Zusicherungen heißen auch Nachbedingungen und bilden zusammen mit den
Vorbedingungen den Funktionsvertrag.%

Siehe \texttt{FP020}%

\subsubsection{Funktionsaufruf}%

Für jeden Funktionsaufruf in der Spezifikation bzw.\ Formel gilt die
Validität des jeweiligen Funktionsvertrags als Annahme. Insbesondere
wird der Funktionskörper nicht betrachet.%

\subsubsection{Arrayzugriff}%

Für jeden Arrayzugriff in der Spezifikation bzw.\ Formel gelten die
drei Axiome (A1), (A2) und (A3) als Annahmen \footnote{Die Axiome sind
der Theorie
\url{http://goedel.cs.uiowa.edu/smtlib/theories/ArraysEx.smt2}
entnommen}. Hierbei ist $\mathbb{A}$ eine Indexmenge, $\mathbb{B}$
eine Basismenge sowie $\mathbb{B}^\mathbb{A}$ die Menge aller Arrays
mit der Indexmenge $\mathbb{A}$ und der Basismenge $\mathbb{B}$. %

\begin{description}%
    \item[(A1)] \begin{math}\forall i \in \mathbb{A}, e \in \mathbb{B} : \{\texttt{true}\} a[i] := e \{a[i] = e\}\end{math}%
    \item[(A2)] \begin{math}\forall i, j \in \mathbb{A}, e, f \in \mathbb{B} : \{i \neq j \wedge a[i] = e\} a[j] := f \{a[i] = e\}\end{math}%
    \item[(A3)] \begin{math}\forall a, b \in \mathbb{B}^\mathbb{A} : (\forall i, j \in \mathbb{A} : a[i] = b[j]) \Rightarrow a = b\end{math}%
\end{description}%

Außerdem muss vor jedem Arrayzugriff in der Spezifikation bzw.\ Formel
als Zusicherung gelten, dass der Feldindex des Zugriffs nicht negativ
und echt kleiner als die Deklarationsgröße des Arrays ist. Damit wird
erstens erreicht, dass ein Programmdurchlauf, der einen ungültigen
Arrayzugriff enthält und deswegen entweder gar nicht oder mit
undefiniertem Ergebnis terminiert, für eine valide Spezifikation
ausgeschlossen ist, und zweitens, dass die Validität der Spezifikation
bzw.\ Formel bei ungültigem Feldzugriff unabhängig vom Beweiser
festgelegt ist.%

\subsubsection{Division}%

Vor jeder Division in der Spezifikation bzw.\ Formel muss als
Zusicherung gelten, dass der Dividend ungleich Null ist. Damit wird
erstens erreicht, dass ein Programmdurchlauf, der eine Division durch
Null enthält und deswegen entweder gar nicht oder mit undefiniertem
Ergebnis terminiert, für eine valide Spezifikation ausgeschlossen ist,
und zweitens, dass die Validität der Spezifikation bzw.\ Formel bei
Division durch Null unabhängig vom Beweiser festgelegt ist.%

\subsubsection{Variablendeklarierung}%

Wird eine Variable ohne Initialisierung deklariert, gilt für den
nachfolgenden Spezifikationsteil eine Initialisierung der Variablen
mit dem Standardwert Null für \int- und \texttt{false} für
\bool-""Variablen sowie dem jeweiligen Standardwert des
Basistyps für Array-""Variablen als Annahme.%

\subsubsection{Typprüfung}%

Die in Worthwhile vorhandenen Datentypen \int{} und
\bool{} werden beide vom Beweiser ohne Typkonvertierung
unterstützt. Die Typen von Sprachelementen werden bei Parameterangabe,
Variablenreferenz und Variablendefinition in der Eingabe vom Beweiser
geprüft. Treten in einem dieser Fälle nicht übereinstimmende Typen
auf, liefert der Beweiser einen Typfehler in der Ausgabe und diese ist
im zurückgelieferten Überprüfungsergebnis enthalten.%

\subsubsection{Prädikatenlogische Formel}%

Die prädikatenlogische Formel wird so behandelt, dass sie als
Zusicherung gelten muss.%

\subsubsection{Abbildung von Variablen auf Bedeutungen}%

Die Abbildung wird so behandelt, dass in der gesamten Formel die
Annahme gilt, dass die Variablen die angegebenen Bedeutungen haben.%

\subsection{Ausgabedaten}%

\subsubsection{Validität}%

Die Validität der Spezifikation bzw.\ Formel ist entweder
bewiesenermaßen gegeben, verifizierbar nicht gegeben oder unbekannt.
Ist der Beweiser zu einem Ergebnis gekommen, ist die Spezifikation
genau dann valide, wenn bewiesen wurde, dass jeder mögliche
Programmdurchlauf niemals den Annahmen widerspricht und die
Zusicherungen an ihrer Position in der Spezifikation erfüllt. Die
Formel ist genau dann valide, wenn bewiesen wurde, dass es keine
Belegung der Variabeln in der Formel gibt, sodass die Formel nicht
gültig ist, d.~h.\ zu \texttt{false} ausgewertet wird. Wenn der
Beweiser zu keinem Ergebnis gekommen ist, wird die Validität der
Spezifikation bzw.\ Formel im Überprüfungsergebnis als unbekannt
angegeben.%

\subsubsection{Beweiserausgabe}%

Die komplette Ausgabe des Beweisers wird zur Fehleruntersuchung in das
Überprüfungsergebnis aufgenommen. Sie kann zur Ergebnisverifikation
neben Typfehlern ein Modell für Variablen in der von der
Beweiserschnittstelle erstellten Formel enthalten, wenn die
Spezifikation bzw.\ die Formel nicht valide ist, d.~h.\ ein
Programmdurchlauf bzw.\ eine Variablenbelegung existiert, sodass einer
Annahme widersprochen wird oder eine Zusicherung nicht erfüllt ist
bzw.\ die Formel zu \texttt{false} ausgewertet wird. Es findet
insbesondere keine Interpretation der Beweiserausgabe durch die
Beweiserschnittstelle, welche zum Beispiel aufgrund eines Modell eine
Abbildung von Variablen auf Belegungen festlegen könnte, statt.%

% TODO Klassenentwurf

\begin{figure}[ph]%

    \caption{Klassendiagramm der Komponente Beweiserschnittstelle mit
    der Schnittstellenklasse \type{SpecificationChecker}}%

    \hspace{-33mm}%
    \includegraphics[width=1.4\textwidth]{diagrams/prover_component.pdf}%
    \label{prover_classdiagram}%
\end{figure}%

\subsection{package Prover}%

In Abbildung~\ref{prover_classdiagram} ist der Klassenentwurf der
Beweiserschnittstelle, wie er im Folgenden ausformuliert ist, zur
Übersicht als UML-""Klassendiagramm mit Vererbungs-"" und
Assoziations"-beziehungen dargestellt.%

\subsubsection{enumeration Validity}%

Gibt an, ob die überprüfte Spezifikation bzw.\ Formel valide ist oder
dass die Validität nicht bestimmt werden konnte. Aufgrund der
Komplexität von Spezifikation und Beweis"-findung können Überprüfungen
in allen drei Zuständen enden und reichen die beiden Zustände
\texttt{VALID} und \texttt{INVALID} nicht aus.%

\begin{description}%
    \literal{VALID}%

    Bedeutet, dass für alle Programm"-durchläufe die Spezifikation
    bzw.\ für alle Belegungen die Formel erfüllt ist.%

    \literal{INVALID}%

    Bedeutet, dass es Programm"-durchläufe bzw.\ Belegungen gibt,
    sodass die Spezifikation bzw.\ Formel nicht erfüllt ist.%

    \literal{UNKNOWN}%

    Bedeutet, dass unbekannt ist, ob nicht erfüllende
    Programm"-durchläufe bzw.\ Belegungen existieren.%

\end{description}%

\subsubsection{class SpecificationChecker}%

Ist Fassaden"-klasse für die Komponente Beweiserschnittstelle. Zur
Überprüfung einer Spezifikation bzw.\ Formel arbeitet sie dreistufig
und benutzt dazu die allgemeineren Funktionsklassen der Komponente.
Sowohl in der ersten als auch in der letzten Stufe fungiert die Klasse
außerdem als Adapter, da für Worthwhile-""Programme spezifische Syntax
und Semantik existiert und sich das Beweiserergebnis nicht unmittelbar
auf das übergebene Worthwhile-""Programm, sondern auf die daraus
erstellte Formel, bezieht.%

\begin{enumerate}%

    \item Übersetzung Worthwhile-""spezifischer
    Syntax~(Funktions"-verträge, Axiome) und Ergänzung spezifischer
    Semantik~(Array"-zugriff, Division, Standard"-werte) in der
    Spezifikation~(\texttt{program}) bzw.\
    Formel~(\texttt{annotation})%

    \item Anwendung der Transformationen eines Kalküls zur
    Programm"-verifikation, das die Spezifikation bzw.\ Formel in eine
    prädikatenlogische Formel vom Typ \type{AST::Expression}
    überführt. Diese Stufe ist in einem Aufruf des
    \texttt{transformer}s gekapselt.%

    \item Übersetzung der prädikatenlogischen Formel aus der zweiten
    Stufe in eine Zeichenkette, mit welcher als Eingabe der Beweiser
    ausgeführt wird. Diese Stufe ist in einem Aufruf des
    \texttt{prover}s gekapselt, dessen Rückgabe die zurückgelieferte
    \type{Validity} entnommen wird.%

\end{enumerate}%

In der Implementierungs"-phase sollen typische Aufruf"-szenarien wie
die Verifikation von Schleifeninvarianten identifiziert und
Bequemlichkeitsmethoden dafür erstellt werden, welche der
Beweiserschnittstelle zur Vereinfachung der Benutzung hinzugefügt
werden.%

\begin{description}%
    \attr{private timeout : Integer = 0}%

    Zeit in Sekunden, die ein Beweiser"-aufruf höchstens dauern darf.%

    Siehe \texttt{setTimeout()}%

    \attr{private prover : Theorem"-Prover::Prover"-Caller = Theorem"-Prover::Z3"-Prover()}%

    Beweiser, der zur Prüfung der Validität prädikatenlogischer
    Formeln aufgerufen wird.%

    \attr{private transformer : Program"-Transformer::Formula"-Generator}%

    Programm"-transformator, der zur Erstellung einer zu beweisenden
    prädikatenlogischen Formel aus einer Programm"-spezifikation,
    welche bei Validität die Korrektheit des Programms verifiziert,
    aufgerufen wird.%

    Siehe \texttt{Specification"-Checker()}%

    Siehe \texttt{Specification"-Checker(: Program"-Transformer::Formula"-Generator)}%

    \attr{private check"-Result : Theorem"-Prover::Prover"-Result = null}%

    Ergebnis der letzten Spezifikations-"" bzw.\ Formel"-überprüfung.%

\end{description}%

\begin{description}%
    \method{public Specification"-Checker()}%

    Erstellt einen \type{Specification"-Checker} mit der
    \type{Program"-Transformer::WP"-Strategy} als \texttt{transformer}
    und dem \type{Theorem"-Prover::Z3"-Prover} als \texttt{prover}.%

    \method{public Specification"-Checker(transformer : Program"-Transformer::Formula"-Generator)}%

    Erstellt einen \type{Specification"-Checker}, der
    \texttt{transformer} zur Programm"-transformation und den
    \type{Theorem"-Prover::Z3"-Prover} als \texttt{prover} verwendet.%

    \method{public check"-Program(program : AST::Program) : Validity}

    Überprüft mit Hilfe des \texttt{prover}s die Validität der Spezifikation
    \texttt{program}. Es wird nur dann \texttt{VALID} zurückgeliefert,
    wenn \texttt{program} beweisbar valide ist, \texttt{INVALID} nur
    dann, wenn ein nicht erfüllendes Modell existiert und
    \texttt{UNKNOWN} sonst~(z.~B.\, wenn \texttt{timeout}
    überschritten wurde oder der Beweiser ohne Ergebnis zurückgekehrt
    ist).%

    %Siehe \texttt{getCheckResult()}%

    Siehe \texttt{FP005}%

    \mlmethod{public check"-Annotation(annotation : AST::Annotation,\\
    environment : String"-To"-Value"-Map) : Validity}

    Überprüft mit Hilfe des \texttt{prover}s die Validität der Annotation
    \texttt{annotation}. Es wird nur dann \texttt{VALID}
    zurückgeliefert, wenn \texttt{annotation} im Kontext
    \texttt{environment} beweisbar valide ist, \texttt{INVALID} nur
    dann, wenn ein nicht erfüllendes Modell existiert und
    \texttt{UNKNOWN} sonst~(z.~B.\, wenn \texttt{timeout}
    überschritten wurde oder der Beweiser ohne Ergebnis zurückgekehrt
    ist).%

    %Siehe \texttt{get"-Check"-Result()}%

    Siehe \texttt{FP005}%

    %\method{public get"-Check"-Result() : Theorem"-Prover::Prover"-Result}
    %
    %Liefert für den vorhergehenden Aufruf von %\texttt{check"-Program()}
    %oder \texttt{check"-Annotation()} das Ergebnis des Beweiseraufrufs und
    %\texttt{null}, wenn zuvor weder ein Programm noch eine Annotation
    %überprüft wurde.%

    \method{public set"-Timeout(seconds : Integer)}

    Setzt den Timeout für Aufrufe von \texttt{check"-Program()} und
    \texttt{check"-Annotation()} auf den Wert von \texttt{seconds}.
    Nach Überschreiten des Timeouts wird der Beweiseraufruf
    abgebrochen. Ist der angegebene Wert negativ, wird er als Null
    interpretiert.%

\end{description}%

\subsection{package Prover::TheoremProver}%

\subsubsection{enumeration FormulaSatisfiability}%

Gibt den Ausgang einer Beweiser"-überpüfung, ob eine
prädikatenlogische Formel erfüllbar ist, an oder dass die
Erfüllbarkeit unbekannt ist. Aufgrund der Komplexität von
Beweis"-findungen treten alle drei Zustände auf und genügt kein
\bool-Typ.%

\begin{description}%
    \literal{SATISFIABLE}%

    Es wurde bewiesen, dass eine erfüllende Belegung existiert.%

    \literal{UNSATISFIABLE}%

    Es wurde bewiesen, dass es keine erfüllende Belegung gibt.%

    \literal{UNKNOWN}%

    Es ist unbekannt, ob ein Modell für die prädikatenlogische Formel
    existiert.%

\end{description}%

\subsubsection{class ProverResult}%

Fasst das Überprüfungs"-ergebnis eines Beweiser"-aufrufs zusammen.
Diese Klasse könnte auch die Fehler-"" und Modell"-extraktion aus der
Beweiser"-ausgabe kapseln und über ihre Schnittstelle wie Attribute
verfügbar machen. Dann würde der Konstruktor nur noch mit der
Beweiser"-ausgabe aufgerufen. Zunächst wird aber das
Erfüllbarkeits"-ergebnis von der erstellenden Klasse gesetzt und die
Ausgabe nur der Vollständigkeit halber sowie zur Fehleranalyse
mitangegeben.%

\begin{description}%
    \attr{private output : String}%

    Die vom Beweiser während seiner Ausführung generierte Ausgabe.%

    \attr{private satisfiability : Formula"-Satisfiability}%

    Das der Beweiser"-ausgabe \texttt{output} entnommene
    Erfüllbarkeits"-ergebnis.%

\end{description}%

\begin{description}%
    \method{protected Prover"-Result(satisfiability : Formula"-Satisfiability, output : String)}%

    Erstellt eine einfache Datenstruktur, die das
    Erfüllbarkeits"-ergebnis \texttt{satisfiability} und die
    Beweiserausgabe \texttt{output} bündelt.%

\end{description}%

\subsubsection{interface Formula"-Compiler}%

Implementierungen dieser Schnittstelle übersetzen eine
prädikatenlogische Formel \texttt{formula} vom Typ
\type{AST::Expression} in die Eingabe"-sprache eines Beweisers, sodass
dieser mit der von \texttt{compile"-Formula()} zurückgelieferten
Zeichenkette die Erfüllbarkeit von \texttt{formula} prüfen kann. Die
Abhängigkeit nur von dieser Schnittstelle und nicht von
Implementierungen ermöglicht die Austauschbarkeit von Compilern und
Beweiser"-sprachen~("`Strategien"').%

\begin{description}%
    \method{public compileFormula(formula : AST::Expression) : String}%

    Liefert eine Übersetzung von \texttt{formula} in eine
    Beweiser"-sprache, sodass sich ein erfüllendes Modell eines Beweisers, der
    diese Sprache interpretiert, genau auf ein erfüllendes Modell von
    \texttt{formula} abbilden lässt~(Bedeutungs"-erhalt).%

    %\method{protected Formula uncompileFormula(String formula)}%

\end{description}%

\subsubsection{class SMTLIB"-Strategy}%

\texttt{implements AST::AST"-Node"-Visitor, Formula"-Compiler}%

Ist eine Implementierung der Schnittstelle \type{Formula"-Compiler},
die prädikatenlogische Formeln nach \texttt{SMTLIB} übersetzt.%

Außerdem implementiert die Klasse die Schnittstelle
\type{AST::AST"-Node"-Visitor}, um sich selbst als "`Besucher"' dem
AST-""Teilbaum, dessen Wurzel \texttt{formula} ist, zu übergeben. Der
Zustand des "`Besuchers"' ist die Ausgabe"-zeichenkette und die
Implementierungen der \texttt{visit()}-""Methoden hängen an diese den
dem jeweiligen Knoten entsprechenden \texttt{SMTLIB}-""Funktionsaufruf
an und übergeben den "`Besucher"' an die Kinderknoten, damit diese die
Funktionsparameter belegen. Hierbei wird ausgenutzt, dass die
\texttt{SMTLIB}-""Syntax mit ihrem heftigen Klammergebrauch und der
Präfixschreibweise auch für alle Operatoren Texte baumartig aufbauen
lässt.%

\begin{description}%
    \attr{private compilation : String = ''''}%

    Repräsentiert stets den aktuellen Kompilier"-stand und nach dem
    Rückkehren das fertige Kompilat.%

\end{description}%

\subsubsection{interface Prover"-Caller}%

Implementierungen dieser Schnittstelle kapseln Beweiser"-aufrufe für
gegebene prädikatenlogische Formeln \texttt{formula}. Das Ergebnis
eines Aufrufs wird als \type{Prover"-Result} zurückgegeben. Wie bei
\type{Formula"-Compiler} ermöglicht die Abhängigkeit von nur dieser
Schnittstelle sowohl die Austauschbarkeit des tatsächlich verwendeten
Beweisers als auch des Aufruf"-protokolls~(Bibliotheks"-funktionen,
Programm"-ausführung).%

\begin{description}%
    \method{public check"-Formula(formula : AST::Expression) : Prover"-Result}%

    Ruft den von der Implementierung unterstützten Beweiser zur Überprüfung der
    prädikatenlogischen Formel \texttt{formula} auf. Es wird nur dann
    \texttt{SATISFIABLE} in \texttt{Prover"-Result\#satisfiability}
    zurückgeliefert, wenn die Formel bewiesen erfüllbar ist,
    \texttt{UNSATISFIABLE} nur dann, wenn bewiesen keine erfüllende
    Belegung existiert und \texttt{UNKNOWN} sonst.

\end{description}%

\subsubsection{abstract class Std"-Prover}%

\texttt{extends Prover"-Caller}%

Instanzen von dieser Abstraktion abgeleiteter Klassen rufen Beweiser
auf, denen die zu überprüfende Formel auf der Standardeingabe
übergeben wird. Spezialisierungen dieser Klasse implementieren die
Extrahierung des Beweiser"-ergebnisses aus der Standardausgabe in der
Fabrikmethode \texttt{get"-Result()}.%

\begin{description}%
    \attr{private prover"-Path : String}%

    Aufgerufener Pfad, wenn in \texttt{check"-Formula()} der Beweiser
    ausgeführt wird.%

    \attr{private compiler : Formula"-Compiler}%

    Aufgerufener \texttt{Formula"-Compiler}, wenn die übergebene
    \texttt{formula} in die Eingabe"-sprache des Beweisers übersetzt
    wird.%

\end{description}%

\begin{description}%
    \method{protected StdProver(path : String, compiler : Formula"-Compiler)}%

    Konfiguriert Instanzen so, dass der Beweiser"-pfad \texttt{path} mit dem
    Formelkompilat vom \texttt{compiler} auf der Standardeingabe für zu überprüfende
    prädikatenlogische Formeln \texttt{formula} aufgerufen wird.%

    \method{public check"-Formula(formula : AST::Expression) : Prover"-Result}%

    Ruft den bei Objekt"-erstellung angegebenen Beweiser"-pfad \texttt{prover"-Path} auf und
    füllt die Standardeingabe mit dem vom angegebenen \texttt{compiler} aus
    \texttt{formula} erstellten Kompilat auf.
    \texttt{Prover"-Result\#satisfiability} wird auf \texttt{UNKNOWN}
    gesetzt, falls bei der Beweiser"-ausführung ein Systemfehler
    aufgetreten ist, und sonst wird der Rückgabewert von
    \texttt{getResult()} zurückgeliefert, welche den Inhalt der
    Standardausgabe nach Beweiseraufruf erhalten hat.%

    \method{abstract public get"-Result(output : String) : Prover"-Result}%

    Extrahiert aus der Beweiserausgabe \texttt{output} das Überprüfungs"-ergebnis
    des Beweiseraufrufs und liefert diese Information in einer
    Instanz von \type{Prover"-Result} zurück. Kann der Inhalt von
    \texttt{output} nicht interpretiert werden, wird
    \texttt{Prover"-Result\#satisfiability} auf \texttt{UNKNOWN} gesetzt.%

\end{description}%

\subsubsection{class Z3Prover}%

\texttt{extends Std"-Prover}%

Überprüft die Erfüllbarkeit prädikatenlogischer Formeln mit Hilfe des
Beweisers Z3 von Microsoft~Research. Als Eingabeformat wird
\texttt{SMTLIB} verwendet und zur Übersetzung wird der Compiler
\type{SMTLIB"-Strategy} eingesetzt. \type{Z3Prover} konfiguriert dazu
\type{Std"-Prover} mit den entsprechenden Parametern und implementiert
\texttt{get"-Result()} so, dass es die Erfüllbarkeit der
Beweiser"-ausgabe entnimmt.%

\subsection{package Prover::Program"-Transformer}%

\subsubsection{interface Formula"-Generator}%

Implementierungen dieser Schnittstelle erstellen aus einem
Worthwhile-""Programmtext eine prädikatenlogische Formel. Diese Formel
soll nur dann beweisbar sein, wenn das Programm seine Spezifikation
erfüllt. Diese Korrektheit bezieht sich immer auf ein Kalkül, weshalb
Implementierungen dieser Schnittstelle meistens die Produktionsregeln
eines solchen formalen Systems kapseln. Wegen der Relativität der
Programmkorrektheit ist erneut die durch das Entwurfsmuster
"`Strategie"' ermöglichte Austauschbarkeit dieser Implementierungen
sinnvoll.%

\begin{description}%
    \method{public transform"-Program(program : AST::Program) : AST::Expression} %

    Liefert die aus \texttt{program} transformierte \type{AST::Expression}
    zurück. Die Semantik der Formel ist unbestimmt, falls der
    Programmtext kein semantisch korrektes Programm beschreibt, also
    nicht ausgeführt werden kann. Ansonsten ist die zurückgelieferte
    Formel nur dann beweisbar, wenn im angewendeten Kalkül das
    WHILE-""Programm für alle Ausführungen seinen Annotationen
    entspricht.%

\end{description}%

\subsubsection{class WP"-Strategy}%

\texttt{implements AST::AST"-Node"-Visitor, Formula"-Generator}%

Ist eine Implementierung der Schnittstelle \type{Formula"-Generator},
die im WP-""Kalkül Programmspezifikationen in verifizierende
prädikatenlogische Formeln transformiert.%

Wie auch \type{SMTLIB"-Strategy} implementiert \type{WP"-Strategy} die
"`Besucher"-klasse"' \type{AST"-Node"-Visitor}, um die
\type{AST::Program}-""Bäume in einer selbst definierten Reihenfolge
abzulaufen. Der innere Zustand einer \type{WP"-Strategy}-""Instanz
enthält stets die schwächste Vorbedingung für den bereits besuchten
\type{Program}-""Teil und bei jedem Besuch wird aus dieser und dem
aktuellen \type{AST::Statement} die neue schwächste Vorbedingung
berechnet. Nach Abarbeitung des gesamten Baums enthält der Zustand die
schwächste Vorbedingung für die Korrektheit des \type{Program}s.%

\begin{description}%
    \attr{private weakestPrecondition : AST::Expression}%

    Repräsentiert stets die schwächste Vorbedingung für den bereits
    besuchten \type{Program}-Teil, welcher nach Rückkehren von
    \texttt{transform"-Program} das komplette \type{Program} umfasst.%

\end{description}%

\subsection{Interaktionsentwurf}%

Das Sequenzdiagramm in Abbildung~\ref{programchecking_sequencediagram}
zeigt beispielhaft die Verwendung der einzelnen Komponentenklassen
durch einen \type{Specification"-Checker}, um die
Programmspezifikation \texttt{program} zu überprüfen. Nicht enthalten
sind die Worthwhile-""spezifischen Vorbereitungen an \texttt{program}
und der Systemaufruf für den Beweiser. Des Weiteren ist das
"`Besuchen"' in \type{SMTLIBStrategy} und \type{WPStrategy} nur für
den Wurzelknoten skizziert und \type{caller} eine beliebige aufrufende
Klasseninstanz, z.~B.\ der GUI-""Controller.%

\begin{landscape}%
    \begin{figure}[p]%
        \vspace{-2cm}%
        \hspace{-2mm}%
        \includegraphics[height=1.2\textheight]{diagrams/programchecking_sequence.pdf}%

        \caption{Sequenzdiagramm zum Aufruf der Beweiserschnittstelle,
        um eine Programmspezifikation zu überprüfen.}%

        \label{programchecking_sequencediagram}%
    \end{figure}%
\end{landscape}%


text:
package indexer

import (
	"github.com/couchbase/indexing/secondary/common"
	"hash/crc32"
	"log"
)

//SliceContainer contains all slices for an index partition
//and provides methods to determine how data
//is distributed in multiple slices for a single partition
type SliceContainer interface {
	//Add Slice to container
	AddSlice(SliceId, Slice)

	//Update existing slice
	UpdateSlice(SliceId, Slice)

	//Remove existing slice
	RemoveSlice(SliceId)

	//Return Slice for the given IndexKey
	GetSliceByIndexKey(common.IndexKey) Slice

	//Return SliceId for the given IndexKey
	GetSliceIdByIndexKey(common.IndexKey) SliceId

	//Return Slice for the given SliceId
	GetSliceById(SliceId) Slice

	//Return all Slices
	GetAllSlices() []Slice
}

//hashedSliceContainer provides a hash based implementation
//for SliceContainer. Each IndexKey is hashed to determine
//which slice it belongs to.
type HashedSliceContainer struct {
	SliceMap  map[SliceId]Slice
	NumSlices int
}

//NewHashedSliceContainer initializes a new HashedSliceContainer and returns
func NewHashedSliceContainer() *HashedSliceContainer {

	hsc := &HashedSliceContainer{SliceMap: make(map[SliceId]Slice),
		NumSlices: 0}
	return hsc

}

//AddSlice adds a slice to the container
func (sc *HashedSliceContainer) AddSlice(id SliceId, s Slice) {
	sc.SliceMap[id] = s
	sc.NumSlices++
}

//UpdateSlice updates an existing slice to the container
func (sc *HashedSliceContainer) UpdateSlice(id SliceId, s Slice) {
	sc.SliceMap[id] = s
}

//RemoveSlice removes a slice from the container
func (sc *HashedSliceContainer) RemoveSlice(id SliceId) {
	delete(sc.SliceMap, id)
	sc.NumSlices--
}

//GetSliceByIndexKey returns Slice for the given IndexKey
//This is a convenience method which calls other interface methods
//to first determine the sliceId from IndexKey and then the slice from
//sliceId
func (sc *HashedSliceContainer) GetSliceByIndexKey(key common.IndexKey) Slice {

	id := sc.GetSliceIdByIndexKey(key)
	return sc.GetSliceById(id)

}

//GetSliceIdByIndexKey returns SliceId for the given IndexKey
func (sc *HashedSliceContainer) GetSliceIdByIndexKey(key common.IndexKey) SliceId {

	//run hash function on index key and return slice id
	hash := crc32.ChecksumIEEE([]byte(key[0]))
	sliceId := int(hash) % sc.NumSlices
	return SliceId(sliceId)
}

//GetSliceById returns Slice for the given SliceId
func (sc *HashedSliceContainer) GetSliceById(id SliceId) Slice {

	if s, ok := sc.SliceMap[id]; ok {
		return s
	} else {
		log.Printf("HashedSliceContainer: Invalid Slice Id %v", id)
		return nil
	}
}

//GetAllSlices returns all slices from the container
func (sc *HashedSliceContainer) GetAllSlices() []Slice {

	var sliceList []Slice

	for _, slice := range sc.SliceMap {
		sliceList = append(sliceList, slice)
	}

	return sliceList

}


text:
#pragma once

#include <atomic>
#include <functional>

namespace proxygen {

/**
 * A helper class to schedule N async jobs in (possibly) different threads
 * and invoke a final callback in a given thread once all are done.
 */
class CobHelper {
 public:
  CobHelper(size_t itemsLeft,
            const std::function<void()>& cob,
            const std::function<void(const std::exception&)>& ecob)
  : itemsLeft_(itemsLeft)
, cob_(cob)
, ecob_(ecob) {}

  void setError(const std::string& emsg) {
    CHECK(!emsg.empty());
    emsg_ = emsg;
  }

  void workerDone() {
    uint32_t oldValue = itemsLeft_.fetch_sub(1);
    if (oldValue != 1) {
      return;
    }

    allDone();
  }
 private:
  void allDone() {
    if (!emsg_.empty()) {
      ecob_(std::runtime_error(emsg_));
    } else {
      cob_();
    }

    delete this;
  }

  std::atomic<uint32_t> itemsLeft_;
  std::string emsg_;
  std::function<void()> cob_;
  std::function<void(const std::exception&)> ecob_;
};

}


text:
\hypertarget{dir_228f67ee02339952bfefff130230fd32}{}\section{Sources/\+Core Directory Reference}
\label{dir_228f67ee02339952bfefff130230fd32}\index{Sources/\+Core Directory Reference@{Sources/\+Core Directory Reference}}
\subsection*{Files}
\begin{DoxyCompactItemize}
\item
file \hyperlink{_event_handler_8cpp}{Event\+Handler.\+cpp}
\item
file \hyperlink{_input_state_8cpp}{Input\+State.\+cpp}
\item
file \hyperlink{_keyboard_state_8cpp}{Keyboard\+State.\+cpp}
\item
file \hyperlink{_mouse_state_8cpp}{Mouse\+State.\+cpp}
\item
file \hyperlink{_signal_8cpp}{Signal.\+cpp}
\end{DoxyCompactItemize}


text: export { QBarrier32 as default } from "../../../";


text:
class CreateFatFreeCRMEmails < ActiveRecord::Migration
  def self.up
    create_table :fat_free_crm_emails, force: true do |t|
      t.string :imap_message_id, null: false  # IMAP internal message identifier.
      t.references :user                             # User who created th email.
      t.references :mediator, polymorphic: true   # Identifies where the email is attached to.
      t.string :sent_from, null: false        # From:
      t.string :sent_to, null: false          # To:
      t.string :cc                               # Cc:
      t.string :bcc                              # Bcc:
      t.string :subject                          # Subject:
      t.text :body                             # Body:
      t.text :header                           # Raw header as received from IMAP server.
      t.datetime :sent_at                          # Time the message was sent.
      t.datetime :received_at                      # Time the message was received.
      t.datetime :deleted_at
      t.timestamps
    end

    add_index :fat_free_crm_emails, [:mediator_id, :mediator_type]
  end

  def self.down
    drop_table :fat_free_crm_emails
  end
end


text:
CREATE TABLE JRXML_RESOURCE_FILES
  (	JRR_ID      NUMBER NOT NULL,
	JRR_NAME    VARCHAR2(80) NOT NULL,
    JRR_LOCALE  VARCHAR2(10),
	JRR_VALID   VARCHAR2(1)  NOT NULL,
	JRR_CONTENT CLOB         NOT NULL
  );

--------------------------------------------------------
--  Constraints for Table JRXML_RESOURCE_FILES
--------------------------------------------------------

ALTER TABLE JRXML_RESOURCE_FILES ADD CONSTRAINT JRR_VALID_CK CHECK (JRR_VALID IN ('Y', 'N')) ENABLE;

ALTER TABLE JRXML_RESOURCE_FILES ADD CONSTRAINT JRR_UK UNIQUE (JRR_NAME, JRR_LOCALE);

ALTER TABLE JRXML_RESOURCE_FILES ADD CONSTRAINT JRR_PK PRIMARY KEY (JRR_ID);

CREATE OR REPLACE TRIGGER TRG_JRR_BRUI
BEFORE INSERT OR UPDATE ON JRXML_RESOURCE_FILES
FOR EACH ROW
BEGIN
  IF INSERTING THEN
    :NEW.JRR_VALID:='N';
  ELSE
    IF     :OLD.JRR_VALID='Y'
       AND :NEW.JRR_VALID='Y' THEN
      :NEW.JRR_VALID:='N';
    END IF;
  END IF;
END;
/


text:
namespace cylvionpp {

namespace {

class DesertionsImpl: public Desertions {
public:
    bool Empty() const override;
    unsigned Size() const override;

    Index Peek() const override;
    Index Peek(Index idx) const override;
    void Push(Index) override;
    Index Pop() override;
    void Shuffle() override;

private:
    std::vector<Index> c;
};

bool
DesertionsImpl::Empty() const
{
    return c.empty();
}

unsigned
DesertionsImpl::Size() const
{
    return c.size();
}

Index
DesertionsImpl::Peek() const
{
    return c.back();
}

Index
DesertionsImpl::Peek(Index idx) const
{
    return c[idx];
}

void
DesertionsImpl::Push(Index value)
{
    c.push_back(value);
}

Index
DesertionsImpl::Pop()
{
    Index value = c.back();
    c.pop_back();
    return value;
}

void
DesertionsImpl::Shuffle()
{
    const unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    std::shuffle(c.begin(), c.end(), std::default_random_engine(seed));
}

} // namespace

Desertions::~Desertions() = default;

std::unique_ptr<Desertions>
Desertions::New()
{
    return std::make_unique<DesertionsImpl>();
}

} // namespace cylvionpp


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

namespace BitArray
{
    public class BitArrayMain
    {
        static void Main(string[] args)
        {
            var first = new BitArray64(5555555555555);
            var second = new BitArray64(2);

            Console.WriteLine("Test: .ToString() ");
            Console.WriteLine(first.ToString());
            Console.WriteLine(second.ToString());
            Console.WriteLine();

            Console.WriteLine("Test: Indexer:");
            Console.WriteLine(first[62]);
            Console.WriteLine(first[63]);
            Console.WriteLine();

            Console.WriteLine("Test: .GetHashCode():");
            Console.WriteLine(first.GetHashCode());
            Console.WriteLine(second.GetHashCode());
            Console.WriteLine();

            Console.WriteLine("Test .Equals():");
            Console.WriteLine(first.Equals(second));
            Console.WriteLine();

            Console.WriteLine("Test == operator:");
            Console.WriteLine(first == second);
            Console.WriteLine();

            Console.WriteLine("Test != operator:");
            Console.WriteLine(first != second);
            Console.WriteLine();

            Console.WriteLine("Test: IEnumeble<int>");

            foreach (var bit in first)
            {
                Console.Write(bit + " ");
            }
            Console.WriteLine();
        }
    }
}


text:
<?php

namespace source\modules\menu\home\controllers;

use yii\web\Controller;

class DefaultController extends Controller
{
    public function actionIndex() {
        return $this->render('index');
    }
}


text:
class CourseSelectController < ApplicationController
  before_action :logged_in_user, only: [:search]

  def search
    if params[:query]
      query_str = params[:query][:query_str]
      query_year = params[:query][:query_str].to_i
      @courses = Course
                     .where("title LIKE ? OR instructor LIKE ? OR description LIKE ? OR year = ?", "%#{query_str}%", "%#{query_str}%", "%#{query_str}%", "#{query_year}")
                     .paginate(page: params[:page], per_page: 8)
    else
      @courses = Course.paginate(page: params[:page], per_page: 8)
    end
  end

  private
    def logged_in_user
      unless logged_in?
        flash[:danger] = "Please log in."
        redirect_to login_url
      end
    end
end


text:
from . import config

'''
info.py -  vFeed - Open Source Cross-linked and Aggregated Local Vulnerability Database

Class vFeedInfo : supplying the vFeed information
'''

class vFeedInfo(object):
    def __init__(self):
        self.vFeedInfo = {}

    def get_version(self):
        self.vFeedInfo['title'] = config.product['__title__']
        self.vFeedInfo['build'] = config.product['__build__']
        return self.vFeedInfo

    def get_owner(self):

        self.vFeedInfo['author'] = config.author['__name__']
        self.vFeedInfo['email'] = config.author['__email__']
        self.vFeedInfo['website'] = config.author['__website__']
        return self.vFeedInfo

    def get_config(self):

        self.vFeedInfo['primary'] = config.database['primary']
        self.vFeedInfo['secondary'] = config.database['secondary']
        return self.vFeedInfo


text:
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE PartialTypeSignatures #-}
module NSHaskell where

import Prelude hiding (lookup)
import Control.Applicative
import Control.Monad.State.Strict
import Control.Monad.Trans.Maybe
import Control.Monad.IO.Class
import Bindings.Objc
import Foreign.C.String
import Foreign.C.Types
import Foreign.Ptr
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array
import Foreign.Storable
import Data.List (sort, intercalate)
import Data.Map.Strict (Map, fromList, lookup, keys)
import qualified Data.Map.Strict as Map

class Nil a where
    nil   :: a
    isNil :: Eq a => a -> Bool
    isNil = (nil ==)

class HasName a where
    getName :: a -> IO String

class HasClass a where
    getClass      :: a -> IO Class
    getSuperClass :: a -> IO Class

type Sel = CSEL
type Id = CId
type Method = CMethod
type Class = CClass

instance Nil (Ptr a) where
    nil = c'nil

instance HasName String where
    getName = return . id

instance HasName Class where
    getName = (peekCString =<<) . c'class_getName

instance HasName Id where
    getName = (peekCString =<<) . c'object_getClassName

instance HasName Sel where
    getName = (peekCString =<<) . c'sel_getName

instance HasName Method where
    getName = (getName =<<) . c'method_getName

instance HasClass Class where
    getClass = return . id
    getSuperClass = c'class_getSuperclass

instance HasClass Id where
    getClass = (getClass =<<) . c'object_getClass
    getSuperClass = (getSuperClass =<<) . getClass

instance HasClass String where
    getClass s = withCString s c'objc_getClass
    getSuperClass = (getSuperClass =<<) . getClass

getMetaClass :: Class -> IO Class
getMetaClass c = do
    isMeta <- c'class_isMetaClass c
    if (c'YES == isMeta)
    then return c
    else liftIO $ c'object_getClass $ castPtr c

withSelector :: String -> (Sel -> IO a) -> IO a
withSelector s f = withCString s $ \p -> c'sel_getUid p >>= f

getMethods :: Class -> IO [Method]
getMethods c = do
    def <- getClass c
    alloca $ \ptr -> do
        ptrMs <- c'class_copyMethodList def ptr
        n     <- peek ptr
        peekArray (fromIntegral n) ptrMs

getClassMethods :: HasClass a => a -> IO [Method]
getClassMethods a = getClass a >>= getMetaClass >>= getMethods

getSelectors :: HasClass a => a -> IO [Sel]
getSelectors a = getClass a >>= getMethods >>= mapM c'method_getName

getClassSelectors :: HasClass a => a -> IO [Sel]
getClassSelectors a = getClassMethods a >>= mapM c'method_getName

printClass :: Class -> IO ()
printClass c = do
    name      <- getName c
    iSels     <- getSelectors c
    iSelNames <- mapM getName iSels
    cSels     <- getClassSelectors c
    cSelNames <- mapM getName cSels

    putStrLn name
    putStrLn "  Class\n  "
    putStrLn $ intercalate "\n    " $ sort cSelNames
    putStrLn "\n  Instance\n  "
    putStrLn $ intercalate "\n    " $ sort iSelNames

printAvailableClasses :: IO ()
printAvailableClasses = do
    num <- c'objc_getClassList nullPtr 0
    let num' = fromIntegral num
    classes <- allocaArray num' $ \ptr -> do
        _ <- c'objc_getClassList ptr num
        peekArray num' ptr
    names <- mapM getName classes
    putStrLn $ intercalate "\n  " $ "Available classes:": sort names

foreign import ccall safe "objc/objc.h objc_msgSend" c'objc_msgSend_CInt_CString :: CId -> CSEL -> CInt -> IO CString

description :: Id -> IO String
description c = do
    desc <- withSelector "description" $ c'objc_msgSend c
    cstr <- withSelector "cStringUsingEncoding:" $ \s -> c'objc_msgSend_CInt_CString desc s 4
    peekCString cstr


text:
package com.dabay6.libraries.androidshared.util;

/**
 * ValidationUtils
 *
 * @author Remel Pugh
 * @version 1.1
 */
@SuppressWarnings("unused")
public final class ValidationUtils {
    /**
     * Regular expression for validating email addresses.
     */
    public final static String EMAIL_EXPRESSION = "\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";

    /**
     * Hidden constructor.
     */
    private ValidationUtils() {
    }
}


text:
id: ecmascript-modules
title: ECMAScript Modules
---

:::caution

Jest ships with **experimental** support for ECMAScript Modules (ESM).

The implementation may have bugs and lack features. For the latest status check out the [issue](https://github.com/facebook/jest/issues/9430) and the [label](https://github.com/facebook/jest/labels/ES%20Modules) on the issue tracker.

Also note that the APIs Jest uses to implement ESM support are still [considered experimental by Node](https://nodejs.org/api/vm.html#vm_class_vm_module) (as of version `18.8.0`).

:::

With the warnings out of the way, this is how you activate ESM support in your tests.

1. Ensure you either disable [code transforms](Configuration.md#transform-objectstring-pathtotransformer--pathtotransformer-object) by passing `transform: {}` or otherwise configure your transformer to emit ESM rather than the default CommonJS (CJS).
1. Execute `node` with `--experimental-vm-modules`, e.g. `node --experimental-vm-modules node_modules/jest/bin/jest.js` or `NODE_OPTIONS=--experimental-vm-modules npx jest` etc..

   On Windows, you can use [`cross-env`](https://github.com/kentcdodds/cross-env) to be able to set environment variables.

   If you use Yarn, you can use `yarn node --experimental-vm-modules $(yarn bin jest)`. This command will also work if you use [Yarn Plug'n'Play](https://yarnpkg.com/features/pnp).

   If your codebase includes ESM imports from `*.wasm` files, you do _not_ need to pass `--experimental-wasm-modules` to `node`. Current implementation of WebAssembly imports in Jest relies on experimental VM modules, however, this may change in the future.

1. Beyond that, we attempt to follow `node`'s logic for activating "ESM mode" (such as looking at `type` in `package.json` or `.mjs` files), see [their docs](https://nodejs.org/api/esm.html#esm_enabling) for details.
1. If you want to treat other file extensions (such as `.jsx` or `.ts`) as ESM, please use the [`extensionsToTreatAsEsm` option](Configuration.md#extensionstotreatasesm-arraystring).

## Differences between ESM and CommonJS

Most of the differences are explained in [Node's documentation](https://nodejs.org/api/esm.html#esm_differences_between_es_modules_and_commonjs), but in addition to the things mentioned there, Jest injects a special variable into all executed files - the [`jest` object](JestObjectAPI.md). To access this object in ESM, you need to import it from the `@jest/globals` module or use `import.meta`.

```js
import {jest} from '@jest/globals';

jest.useFakeTimers();

// etc.

// alternatively
import.meta.jest.useFakeTimers();

// jest === import.meta.jest => true
```

## Module mocking in ESM

Since ESM evaluates static `import` statements before looking at the code, the hoisting of `jest.mock` calls that happens in CJS won't work for ESM. To mock modules in ESM, you need to use `require` or dynamic `import()` after `jest.mock` calls to load the mocked modules - the same applies to modules which load the mocked modules.

ESM mocking is supported through `jest.unstable_mockModule`. As the name suggests, this API is still work in progress, please follow [this issue](https://github.com/facebook/jest/issues/10025) for updates.

The usage of `jest.unstable_mockModule` is essentially the same as `jest.mock` with two differences: the factory function is required and it can be sync or async:

```js
import {jest} from '@jest/globals';

jest.unstable_mockModule('node:child_process', () => ({
  execSync: jest.fn(),
  // etc.
}));

const {execSync} = await import('node:child_process');

// etc.
```

For mocking CJS modules, you should continue to use `jest.mock`. See the example below:

```js title="main.cjs"
const {BrowserWindow, app} = require('electron');

// etc.

module.exports = {example};
```

```js title="main.test.cjs"
import {createRequire} from 'node:module';
import {jest} from '@jest/globals';

const require = createRequire(import.meta.url);

jest.mock('electron', () => ({
  app: {
    on: jest.fn(),
    whenReady: jest.fn(() => Promise.resolve()),
  },
  BrowserWindow: jest.fn().mockImplementation(() => ({
    // partial mocks.
  })),
}));

const {BrowserWindow} = require('electron');
const exported = require('./main.cjs');

// alternatively
const {BrowserWindow} = (await import('electron')).default;
const exported = await import('./main.cjs');

// etc.
```


text:
"""Testing early attach behavior with LoadBalanced view

Test setup:

Start the ipcontroller and 1 ipengine, and run this script.
The time to finish the 10 apps should be ~10s.

In the second run, start the parsl script, and as soon as the run starts,
start additional ipengines. The time to finish the 10 apps should still be ~10s.

This shows that the LoadBalanced View simply routes tasks to the available engines
at the time the apps were submitted to it. It is not capable of rebalancing the apps
among the engine once it has been sent to the the engine's queue.

"""
from parsl import *
import time

from parsl.tests.configs.local_ipp import config
dfk = DataFlowKernel(config=config)

@App('python', dfk)
def sleep_double(x):
    import time
    time.sleep(1)
    return x * 2

def test_z_cleanup():
    dfk.cleanup()

if __name__ == "__main__":

    print("Starting launch")

    jobs = {}
    for i in range(0, 20):
        jobs[i] = sleep_double(i)

    start = time.time()
    for i in range(0, 10):
        print(jobs[i].result())
    print("Time to finish : ", time.time() - start)


text:
afViewActionHandler::afViewActionHandler(QWidget* pControlledWidget, QAction* pAction) : _pControlledWidget(pControlledWidget), _pAction(pAction)
{

}

// ---------------------------------------------------------------------------
// Name:        afViewAction::~afViewAction
// Description: Destructor
// Author:      Gilad Yarnitzky
// Date:        20/7/2011
// ---------------------------------------------------------------------------
afViewActionHandler::~afViewActionHandler(void)
{

}

// ---------------------------------------------------------------------------
// Name:        afViewActionHandler::onViewClicked
// Description: Handle the toggle state
// Author:      Gilad Yarnitzky
// Date:        20/7/2011
// ---------------------------------------------------------------------------
void afViewActionHandler::onViewClicked()
{
    // Sanity check
    GT_IF_WITH_ASSERT(_pAction != nullptr)
    {
        // Toggle the visibility of this view:
        bool shouldShow = _pAction->isChecked();
        controlledWidget()->setVisible(shouldShow);

        if (shouldShow)
        {
            controlledWidget()->setFocus();
            controlledWidget()->raise();
            controlledWidget()->activateWindow();
        }
    }
}

// ---------------------------------------------------------------------------
// Name:        afViewActionHandler::onWindowActionClicked
// Description: Handle the window menu item
// Author:      Sigal Algranaty
// Date:        25/8/2011
// ---------------------------------------------------------------------------
void afViewActionHandler::onWindowActionClicked()
{
    // Down cast to sub window:
    afQMdiSubWindow* pSubWindow = qobject_cast<afQMdiSubWindow*>(controlledWidget());

    // Sanity check:
    GT_IF_WITH_ASSERT(pSubWindow != nullptr)
    {
        // Get the instance for the main window:
        afMainAppWindow* pMainWindow = afMainAppWindow::instance();
        GT_IF_WITH_ASSERT(pMainWindow != nullptr)
        {
            // Activate this window:
            pMainWindow->activateSubWindow(pSubWindow);
        }
    }
}

// ---------------------------------------------------------------------------
// Name:        afViewActionHandler::onUpdateUI
// Description: Update the enable / checked state of the action
// Return Val:  void
// Author:      Sigal Algranaty
// Date:        27/9/2011
// ---------------------------------------------------------------------------
void afViewActionHandler::onUpdateUI()
{
    // Sanity check:
    GT_IF_WITH_ASSERT((_pAction != nullptr) && (_pControlledWidget != nullptr))
    {
        _pAction->setChecked(_pControlledWidget->isVisible());
    }
}


text:
package com.marklogic.mapreduce.functions;

/**
 * Wrapper class for the cts:element-attribute-value-co-occurrences
 * lexicon function. Subclass this class to generate map input based
 * on a lexicon.
 *
 *

 *   Use this class with {@link com.marklogic.mapreduce.KeyValueInputFormat}
 *   or {@link com.marklogic.mapreduce.ValueInputFormat}.
 *

 *

 *   To generate map input using the lexicon function,
 *   create a subclass of this class and provide implementations
 *   of the methods that correspond to the function parameters you
 *   want to include in the call.
 *

 *

 *   For details, see "Using a Lexicon to Generate Key-Value Pairs"
 *   in the MarkLogic Connector for Hadoop Developer's Guide.
 *   For an example, see
 *   {@link com.marklogic.mapreduce.examples.LinkCountCooccurrences}.
 *

 *
 *

 *   All co-occurrences functions using this API do NOT preserve
 *   frequency order even if "frequency-order" option is specified.
 *

 *
 * @author jchen
 */
public abstract class ElemAttrValueCooccurrences
extends CooccurrencesFunction {

    /**
     * Get the value for the $element-name-1 parameter to the
     * lexicon function call, as a string. The returned string
     * must evaluate to an xs:QName when evaluated as XQuery.
     * For example: "xs:QName(\"wp:a\")".
     *
     * @return first element QName.
     */
    public abstract String getElementName1();

    /**
     * Get the value for the $attribute-name-1 parameter to the
     * lexicon function call, as a string.
     *

     *   The returned string must evaluate to an xs:QName when evaluated
     *   as XQuery. For example: "xs:QName(\"wp:a\")". Returning
     *   the empty sequence ("()") specifies an element sequence.
     *

     *
     * @return second attribute QName.
     */
    public String getAttributeName1() {
        return "()";
    }

    /**
     * Get the value for the $element-name-2 parameter to the
     * lexicon function call, as a string. The returned string
     * must evaluate to an xs:QName when evaluated as XQuery
     * For example: "xs:QName(\"wp:a\")".
     *
     * @return second element QName.
     */
    public abstract String getElementName2();

    /**
     * Get the value for the $attribute-name-2 parameter to the
     * lexicon function call, as a string.
     *

     *   The returned string must evaluate to an xs:QName when evaluated as
     *   XQuery. For example: "xs:QName(\"wp:a\")". Returning
     *   the empty sequence ("()") specifies an element sequence.
     *

     *
     * @return second attribute QName.
     */
    public String getAttributeName2() {
        return "()";
    }

    @Override
    void appendFunctionName(StringBuilder buf) {
        buf.append("cts:element-attribute-value-co-occurrences");
    }

    @Override
    void appendNamesParams(StringBuilder buf) {
        // first element name
        buf.append(getElementName1()).append(",\n");
        // first attribute name
        buf.append(getAttributeName1()).append(",\n");
        // second element name
        buf.append(getElementName2()).append(",\n");
        // second attribute name
        buf.append(getAttributeName2()).append(",\n");
    }
}


text:
function createDatasetBatch(filelist, filename, downsamplingRate, outdir)

% ***Note: This is a new version of createDatasetBatch which SEPARATES
% features and labels before saving the matrices. The resulting feature
% matrices will have the dimension of 121 x number of samples and the
% resulting labels 1 x number of samples. These matrices can be read by
% python code that is not marked (old).***

% Call pitchProfilePartial to compute energy of each pitch class for
% each track in filelist. This is for test files, because training is done
% only on songs without pitch shifts.

fid = fopen(filelist);
curfile = fgetl(fid);
trainingSet = [];
testSet = [];
label = 0;

while ischar(curfile)
	disp(['-- Generating data matrix on file ', int2str(label)]);
    [pathstr,name,ext] = fileparts(curfile);
    cqt_file = strcat(outdir,name,'.mat');
    Qfile = load(cqt_file); % loads Q (struct)
    QMat = abs(Qfile.Q.c);

    [trainVec, testVec] = createDataset(QMat, label);
    trainingSet = cat(1, trainingSet, trainVec);
    testSet = cat(1, testSet, testVec);

    curfile = fgetl(fid);
    label = label + 1;
end

% Note: Downsampling is done before shuffling data to ensure that we sample
% from every track.
disp(['==> Downsampling Data'])
trainingSet = trainingSet(1:downsamplingRate:size(trainingSet,1),:);
testSet = testSet(1:downsamplingRate:size(testSet,1),:);

disp(['==> Shuffling data...'])
trainingSet = trainingSet(randperm(size(trainingSet, 1)), :)';
testSet = testSet(randperm(size(testSet, 1)), :)';

disp(['==> Separate coefficients and labels'])
trainingLabels = trainingSet(size(trainingSet,1), :);
validationLabels = testSet(size(testSet,1), :);
trainingFeatures = trainingSet(1:size(trainingSet,1)-1, :);
validationFeatures = testSet(1:size(testSet,1)-1, :);

save(filename, 'trainingFeatures', 'validationFeatures', 'trainingLabels', 'validationLabels', '-v7.3');


text:
namespace Microsoft.Azure.Management.WebSites
{
    using Microsoft.Azure;
    using Microsoft.Azure.Management;
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// Extension methods for TopLevelDomainsOperations.
    /// </summary>
    public static partial class TopLevelDomainsOperationsExtensions
    {
            /// <summary>
            /// Get all top-level domains supported for registration.
            /// </summary>
            /// <remarks>
            /// Get all top-level domains supported for registration.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static IPage<TopLevelDomain> List(this ITopLevelDomainsOperations operations)
            {
                return operations.ListAsync().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all top-level domains supported for registration.
            /// </summary>
            /// <remarks>
            /// Get all top-level domains supported for registration.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<TopLevelDomain>> ListAsync(this ITopLevelDomainsOperations operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get details of a top-level domain.
            /// </summary>
            /// <remarks>
            /// Get details of a top-level domain.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='name'>
            /// Name of the top-level domain.
            /// </param>
            public static TopLevelDomain Get(this ITopLevelDomainsOperations operations, string name)
            {
                return operations.GetAsync(name).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get details of a top-level domain.
            /// </summary>
            /// <remarks>
            /// Get details of a top-level domain.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='name'>
            /// Name of the top-level domain.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<TopLevelDomain> GetAsync(this ITopLevelDomainsOperations operations, string name, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.GetWithHttpMessagesAsync(name, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </summary>
            /// <remarks>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='name'>
            /// Name of the top-level domain.
            /// </param>
            /// <param name='agreementOption'>
            /// Domain agreement options.
            /// </param>
            public static IPage<TldLegalAgreement> ListAgreements(this ITopLevelDomainsOperations operations, string name, TopLevelDomainAgreementOption agreementOption)
            {
                return operations.ListAgreementsAsync(name, agreementOption).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </summary>
            /// <remarks>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='name'>
            /// Name of the top-level domain.
            /// </param>
            /// <param name='agreementOption'>
            /// Domain agreement options.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<TldLegalAgreement>> ListAgreementsAsync(this ITopLevelDomainsOperations operations, string name, TopLevelDomainAgreementOption agreementOption, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListAgreementsWithHttpMessagesAsync(name, agreementOption, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get all top-level domains supported for registration.
            /// </summary>
            /// <remarks>
            /// Get all top-level domains supported for registration.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<TopLevelDomain> ListNext(this ITopLevelDomainsOperations operations, string nextPageLink)
            {
                return operations.ListNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all top-level domains supported for registration.
            /// </summary>
            /// <remarks>
            /// Get all top-level domains supported for registration.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<TopLevelDomain>> ListNextAsync(this ITopLevelDomainsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </summary>
            /// <remarks>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<TldLegalAgreement> ListAgreementsNext(this ITopLevelDomainsOperations operations, string nextPageLink)
            {
                return operations.ListAgreementsNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </summary>
            /// <remarks>
            /// Gets all legal agreements that user needs to accept before purchasing a
            /// domain.
            /// </remarks>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<TldLegalAgreement>> ListAgreementsNextAsync(this ITopLevelDomainsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListAgreementsNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

    }
}


text:
using NBitcoin;

namespace Stratis.Features.SQLiteWalletRepository.External
{
    public interface IWalletAddressReadOnlyLookup
    {
        /// <summary>
        /// Determines if the address has been added to this collection.
        /// </summary>
        /// <param name="scriptPubKey">The public key hash script of the address.</param>
        /// <param name="address">An address identifier.</param>
        /// <returns><c>True</c> if the address exists or has been added tentatively.</returns>
        bool Contains(Script scriptPubKey, out AddressIdentifier address);
    }
}


text:
(function() {

  theoricus.mvc.Controller = (function() {
    var Fetcher, Model, View, _ref;

    function Controller() {}

    Fetcher = theoricus.mvc.lib.Fetcher;

    _ref = theoricus.mvc, Model = _ref.Model, View = _ref.View;

    /*
      @param [theoricus.Theoricus] @the   Shortcut for app's instance
    */

    Controller.prototype._boot = function(the) {
      this.the = the;
      return this;
    };

    /*
      Renders view

      @param [String] path  path to view on the app tree
      @param [String] data  data to be rendered on the template
      @param [Object] element element where it will be rendered, defaults to @process.route.el
    */

    Controller.prototype.render = function(path, data, el, view) {
      var shout, view_didnt_shout,
        _this = this;
      if (el == null) {
        el = this.process.route.el;
      }
      view = view || this.the.factory.view(path, this.process);
      if (data instanceof Fetcher) {
        if (data.loaded) {
          view.render(data.records, el);
        } else {
          data.onload = function(records) {
            return _this.render(path, records, el, view);
          };
        }
      } else {
        view.render(data, el);
        view_didnt_shout = true;
        shout = function(type) {
          if (view_didnt_shout === false) {
            return;
          }
          view_didnt_shout = false;
          return view.process.after_run;
        };
        view["in"](shout);
        if (view_didnt_shout) {
          shout()('automaticaly');
        }
      }
      return view;
    };

    return Controller;

  })();

}).call(this);


text:
process.env.TZ = 'UTC'
var expect = require('chai').expect
var ini_set = require('../../../../src/php/info/ini_set') // eslint-disable-line no-unused-vars,camelcase
var ini_get = require('../../../../src/php/info/ini_get') // eslint-disable-line no-unused-vars,camelcase
var atan = require('../../../../src/php/math/atan.js') // eslint-disable-line no-unused-vars,camelcase

describe('src/php/math/atan.js (tested in test/languages/php/math/test-atan.js)', function () {
  it('should pass example 1', function (done) {
    var expected = 1.5707962121596615
    var result = atan(8723321.4)
    expect(result).to.deep.equal(expected)
    done()
  })
})


text:
"use strict";

var http = require("http"),
    erroz = require("../lib/index.js");

var NotFoundError = erroz({
    name: "NotFound",
    code: "not-found",
    status: "fail",
    statusCode: 404,
    template: "<%= resource %> (<%= id %>) not found"
});

http.createServer(function (req, res) {

    var err = new NotFoundError({ resource: "User", id: 1 });

    res.writeHead(err.statusCode, {"Content-Type": "application/json"});

    res.end(JSON.stringify(err.toJSend()));
    //returns jsend-style JSON
    /*
     {
        status: "fail",
        code: "not-found",
        message: "User (1) not found",
        data: {
            resource: "User",
            id: 1,
            stack: "NotFound: User (1) not found at Server.<anonymous>
                    (/erroz/examples/httpError.js:16:15)
                    at Server.EventEmitter.emit (events.js:98:17)
                    at HTTPParser.parser.onIncoming (http.js:2108:12)
                    at HTTPParser.parserOnHeadersComplete [as onHeadersComplete] (http.js:121:23)
                    at Socket.socket.ondata (http.js:1966:22)
                    at TCP.onread (net.js:527:27)"
            }
     }
     */

}).listen(1337, "127.0.0.1");
console.log("Server running at http://127.0.0.1:1337/");