text:
In modern operating systems, accessibility can be thought of as the set of
features which allow for alternative interactions with the system. In practice,
it is all about letting users work in the best way they can, regardless of
ability or disability. Since users have almost an unbounded set of needs,
accessibility has to constantly keep up and adapt to include increasing numbers
of alternate interactions. It is this very challenge which gives accessibility
at the level of an operating system such complexity, depth, and interest.

For Chrome OS, this document will provide the reader with a technical survey of
the major system components to give a good foundation for additional
exploration.

At a glance, Chrome OS accessibility roughly decomposes into three major
entities, separated by large abstractions like process boundaries or api layers.

Through a slightly different lens, the three entities can also be thought of as the three major stakeholders in any accessibility interaction:
- accessibility feature: an assitive technology (AT) developer can produce services targeting a specific audience. For example, screen readers such as ChromeVox. The extension system serves as a rich runtime with apis to transform the user interface into something a user can use.
- frameworks: an operating system developer abstracts away low-level details to provide for a clean AT developer experience. In Chrome OS, this framework mainly comes by way of extension apis, though other internal api surfaces exist in C++ for Chromium developers as well. The apis are backed by libraries and executables run in native or sandboxed contexts.
- renderers: app developers and web page authors have their content executed and drawn on-screen. This is where all user interactions such as key events end up. The developers and authors here also expose accessibility information for an accessibility tree.

### Renderers
A renderer as used by this document, is any component that draws to the
screen. Some examples include Blink (for web content), ARC++ (for Android apps).

Each of these renderers store an in-memory representation of their user
interfaces. For Blink, this is the DOM or the render tree. For Android, this is
the application view tree.

In almost all modern renderers, there is an equivalent parallel structure, built
off of the source of truth UI tree, called the accessibility tree. It is here
where Chrome OS accessibility extracts all it needs.

The accessibility tree is constructed and updated as the user interface changes
in any way. Every single text change, scroll, load, and more gets
represented. Likewise, every type of data provided by either a developer or the
underlying framework is consumed and stored. This includes things like the
rendered text, styling information, bounding boxes, tree relationships, and much
more.

When this construction finishes or updates with new content, the renderer will
serialize the tree and prepare it for export out of process if needed. That
moves the data to the framework entity below.

For the web, PDF, and Android, renderers exist out of process. For the Aura
windowing system, along with its Views toolkit, the accessible tree lives in the
Ash process.

#### Deep dives
- [Chrome web accessibility](../browser/how_a11y_works.md)

### Frameworks
Here are a few key api surfaces on which accessibility depends.

#### Public apis
- [chrome.automation](https://developer.chrome.com/docs/extensions/reference/automation/)
- [chrome.tts](https://developer.chrome.com/docs/extensions/reference/tts/)
- [chrome.ttsEngine](https://developer.chrome.com/docs/extensions/reference/ttsEngine/)

#### Private apis (only available in component accessibility extensions)
- [chrome.accessibilityPrivate](https://source.chromium.org/chromium/chromium/src/+/main:chrome/common/extensions/api/accessibility_private.json)
- [chrome.brailleDisplayPrivate](https://source.chromium.org/chromium/chromium/src/+/main:chrome/common/extensions/api/braille_display_private.idl)
- [chrome.speechRecognitionPrivate](https://source.chromium.org/chromium/chromium/src/+/main:chrome/common/extensions/api/speech_recognition_private.idl)

#### Libraries and system executables
- [BRLTTY](https://chromium.googlesource.com/chromiumos/overlays/chromiumos-overlay/+/main/app-accessibility/brltty/)
- [Chrome OS text-to-speeech](https://chromium.googlesource.com/chromiumos/overlays/chromiumos-overlay/+/main/app-accessibility/googletts/)
- [Espeak text-to-speech](https://chromium.googlesource.com/chromiumos/overlays/chromiumos-overlay/+/main/app-accessibility/espeak-ng/)

#### Deep dives
- [How text-to-speech works on Chrome OS (coming soon)](how_tts_works.md).

### Accessibility features
See [How accessibility features work (coming soon)](how_a11y_features_work.md) for more details.


text:
<!DOCTYPE html>

	<title>WebPage Card</title>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">

WebPage Card

The WebPage Card allows to embed HTML page in the content area, which will be isolated in iframe.

Properties

						Property
						Type
						Required
						Description
						Schema Version
						Since

						src
						string
						Yes
						The URL of the web page to be embedded.
						1.33.0
						1.90

						sandbox
						string
						No

							Determines what restrictions are applied to the content of the embedded page.
							By default full restrictions are applied. This is the preferred value if the page origin is not trusted.
							Set this to space-separated tokens to lift particular restrictions.
							For more detailed documentation and possible tokens read the iframe sandbox attribute documentation.

						1.33.0
						1.90

						minHeight
						sap.ui.core.CSSSize
						No
						Defines the minimum height of the content. Default value is "150px".
						1.33.0
						1.90

Example

Define the manifest.json of the card:

{
	"sap.app": {
		"id": "card.explorer.webpage.card",
		"type": "card",
		"title": "Sample of a WebPage Card",
		"subTitle" :"Sample of a WebPage Card",
		"applicationVersion": {
			"version": "1.0.0"
		},
		"shortTitle": "A short title for this Card",
		"info": "Additional information about this Card",
		"description": "A long description for this Card",
		"tags": {
			"keywords": [
				"WebPage",
				"Card",
				"Sample"
			]
		}
	},
	"sap.ui": {
		"technology": "UI5"
	},
	"sap.card": {
		"type": "WebPage",
		"configuration": {
			"parameters": {
				"minHeight": {
					"description": "Minimum height of the content",
					"type": "string",
					"value": "25rem"
				}
			}
		},
		"header": {
			"title": "OpenUI5 Events",
			"icon": {
				"src": "sap-icon://desktop-mobile"
			}
		},
		"content": {
			"src": "https://openui5.org/events",
			"minHeight": "{parameters>/minHeight/value}"
		}
	}
}

Create the view to display the card:

<mvc:View xmlns:w="sap.ui.integration.widgets">
	<w:Card manifest="./manifest.json" width="400px" height="auto" />
</mvc:View>

			Try it Out

Table of Contents

WebPage Card

Properties

Example

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="UTF-8"?>
<gresources>
</gresources>


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>Dashboard</title>

    <link href="{{ url_for('static', filename='bootstrap/css/bootstrap.min.css')}}" rel="stylesheet">

    <link href="{{ url_for('static', filename='main.css')}}" rel="stylesheet">

          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
            Toggle navigation

          </button>
          Dashboard

Home

Topics

Settings

Dashboard

Eventually something will be here


text:
/** \file Equals.h
    \brief This file defines the equality testing template
  */

#ifndef ASLAM_CALIBRATION_TPL_EQUALS_H
#define ASLAM_CALIBRATION_TPL_EQUALS_H

#include "aslam/calibration/tpl/Boolean.h"

namespace aslam {
  namespace calibration {

    /** The Equals structure defines the equality testing template
        \brief Equality testing template
      */
    template <typename A, typename B> struct Equals {
    public:
      /// Defines the not equal
      typedef False Result;
    };

    /** The Equals structure defines the equality testing template
        \brief Equality testing template
      */
    template <typename A> struct Equals<A, A> {
    public:
      /// Defines the equal
      typedef True Result;
    };

  }
}

#endif // ASLAM_CALIBRATION_TPL_EQUALS_H


text:
You have to edit the file [example.inc.php](example.inc.php "example.inc.php") ; it contains variables that you **MUST** set to your own configuration needs before running the examples :

- **$host** : Host name or IP address of your remote server.
- **port** : Port number of the sshd server on your remote system (usually, 22).
- **$user** : the user you want to connect to on your remote system.
- **$password** : User password (set this variable if you want to run the *example.password.php* script, which uses password-based authentication)
- **$private\_key\_file**, **$public\_key\_file** : Paths to the files containing your private and public ssh keys (set these variables if you want to run the *example.key.php* script, which uses ssh key-based authentication)

# PREREQUISITES #

- Your remote system **MUST** be a Unix system for the examples to run as is
- If you used puttygen to generate your public and private keys, you have to know that the key that is labelled :

			Public key for pasting into OpenSSH authorized_keys file

will not have the correct format for using it as a public key on Unix systems. You will have to go to the Conversions menu and chose the "Export OpenSSH key" option.

- On your remote Unix system, you must add your public key in the *.ssh/authorized_keys* file of your remote user
- And, of course, you must have an *sshd* server up and running on your remote system !


text:
#ifndef _X86_ARCH_GPIO_H_
#define _X86_ARCH_GPIO_H_

/* Where in config space is the register that points to the GPIO registers? */
#define PCI_CFG_GPIOBASE 0x48

#endif /* _X86_ARCH_GPIO_H_ */


text:
require 'rails_helper'

describe 'cases/case_status.html.slim', type: :view do

  it 'displays the all 4 key information ' do
    unassigned_case = double Case::BaseDecorator,
      status: "Needs reassigning",
      ico?: false,
      internal_deadline: DateTime.now.strftime(Settings.default_date_format),
      external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
      current_state: 'drafting',
      type_abbreviation: 'FOI',
      who_its_with: 'DACU',
      type_of_offender_sar?: false,
      offender_sar?: false

    render partial: 'cases/case_status',
           locals:{ case_details: unassigned_case}

    partial = case_status_section(rendered)

    expect(partial.details.copy_label.text).to eq "Status"
    expect(partial.details.copy.text).to eq unassigned_case.status
    expect(partial.details.who_its_with_label.text).to eq "With"
    expect(partial.details.who_its_with.text)
        .to eq unassigned_case.who_its_with

    expect(partial.deadlines.draft_label.text).to eq 'Draft deadline'
    expect(partial.deadlines.draft.text)
        .to eq unassigned_case.internal_deadline
    expect(partial.deadlines.final_label.text).to eq 'Final deadline'
    expect(partial.deadlines.final.text)
        .to eq unassigned_case.external_deadline
  end

  it 'does not display "Who its with" for closed cases' do
    closed_case = double Case::BaseDecorator,
      status: "Closed",
      ico?: false,
      internal_deadline: DateTime.now.strftime(Settings.default_date_format) ,
      external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
      current_state: 'closed',
      type_abbreviation: 'FOI',
      who_its_with: '',
      type_of_offender_sar?: false,
      offender_sar?: false

    render partial: 'cases/case_status',
           locals:{ case_details: closed_case}

    partial = case_status_section(rendered)

    expect(partial.details.copy.text).to eq closed_case.status
    expect(partial.details).to have_no_who_its_with

    expect(partial.deadlines.draft.text)
        .to eq closed_case.internal_deadline
    expect(partial.deadlines.final.text)
        .to eq closed_case.external_deadline
  end

  it 'does not display Draft deadline for non-trigger cases' do
    non_trigger_case = double Case::BaseDecorator,
      status: "Needs reassigning",
      external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
      ico?: false,
      internal_deadline: nil,
      current_state: 'drafting',
      type_abbreviation: 'FOI',
      who_its_with: 'DACU',
      type_of_offender_sar?: false,
      offender_sar?: false

    render partial: 'cases/case_status',
           locals:{ case_details: non_trigger_case}

    partial = case_status_section(rendered)

    expect(partial.details.copy.text).to eq non_trigger_case.status
    expect(partial.details.who_its_with.text)
        .to eq non_trigger_case.who_its_with

    expect(partial.deadlines).to have_no_draft
    expect(partial.deadlines.final.text)
        .to eq non_trigger_case.external_deadline
  end

  context 'ICO case reference number' do
    it 'does not show ICO case reference number for foi cases' do
      non_trigger_case = double Case::BaseDecorator,
        status: "Needs reassigning",
        external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
        ico?: false,
        internal_deadline: nil,
        current_state: 'drafting',
        type_abbreviation: 'FOI',
        who_its_with: 'DACU',
        type_of_offender_sar?: false,
        offender_sar?: false

      render partial: 'cases/case_status',
             locals:{ case_details: non_trigger_case}

      partial = case_status_section(rendered)

      expect(partial.details.copy.text).to eq non_trigger_case.status
      expect(partial.details.who_its_with.text)
          .to eq non_trigger_case.who_its_with

      expect(partial.deadlines).to have_no_draft
      expect(partial.deadlines.final.text)
          .to eq non_trigger_case.external_deadline

      expect(partial.details).to have_no_ico_ref_number_label
      expect(partial.details).to have_no_ico_ref_number
    end

    it 'displays ICO case reference number for ico appeal cases' do
      ico_case = double Case::ICO::BaseDecorator,
        status: "Needs reassigning",
        external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
        ico_reference_number: '123456789ABC',
        ico?: true,
        internal_deadline: nil,
        current_state: 'drafting',
        type_abbreviation: 'ICO',
        who_its_with: 'DACU',
        type_of_offender_sar?: false,
        offender_sar?: false

      render partial: 'cases/case_status',
             locals:{ case_details: ico_case}

      partial = case_status_section(rendered)

      expect(partial.details.copy.text).to eq ico_case.status
      expect(partial.details.who_its_with.text)
          .to eq ico_case.who_its_with

      expect(partial.deadlines).to have_no_draft
      expect(partial.deadlines.final.text)
          .to eq ico_case.external_deadline

      expect(partial.details.ico_ref_number_label.text).to eq 'ICO case reference number'
      expect(partial.details.ico_ref_number.text).to eq ico_case.ico_reference_number

    end

    it 'displays the page counts for Offender Sar cases' do
      params = {
        status: "Needs reassigning",
        external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
        ico?: false,
        internal_deadline: nil,
        current_state: 'drafting',
        type_abbreviation: 'ICO',
        who_its_with: 'Branston Registry',
        type_of_offender_sar?: false,
        offender_sar_complaint?: false,
        offender_sar?: false,
        page_count: '500',
        number_exempt_pages: '200',
        number_final_pages: '250'
      }
      offender_sar_case = double Case::SAR::OffenderDecorator,
                            params.merge({ type_of_offender_sar?: true })
      offender_sar_complaint = double Case::SAR::OffenderComplaintDecorator,
                            params.merge({ offender_sar_complaint?: true })

      [offender_sar_case, offender_sar_complaint].each do |kase|
        render partial: 'cases/case_status',
               locals:{ case_details: kase}
        partial = case_status_section(rendered)

        expect(partial.details.page_counts.received_label.text).to eq 'Pages received'
        expect(partial.details.page_counts.received_number.text).to eq '500'
        expect(partial.details.page_counts.exempt_label.text).to eq 'Exempt pages'
        expect(partial.details.page_counts.exempt_number.text).to eq '200'
        expect(partial.details.page_counts.dispatched_label.text).to eq 'Final page count'
        expect(partial.details.page_counts.dispatched_number.text).to eq '250'
      end
    end

    it 'does not display Page counts for non-offender SAR case' do
      ico_case = double Case::ICO::BaseDecorator,
        status: "Needs reassigning",
        external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
        ico_reference_number: '123456789ABC',
        ico?: true,
        internal_deadline: nil,
        current_state: 'drafting',
        type_abbreviation: 'ICO',
        who_its_with: 'DACU',
        type_of_offender_sar?: false,
        offender_sar?: false

      render partial: 'cases/case_status',
             locals:{ case_details: ico_case}

      partial = case_status_section(rendered)

      expect(partial.details).to have_no_page_counts
    end

    let(:ico_overturned_sar) {
      double Case::OverturnedICO::SARDecorator,
        status: "Needs reassigning",
        external_deadline: (DateTime.now + 10.days).strftime(Settings.default_date_format),
        ico_reference_number: '123456789ABC',
        ico?: true,
        internal_deadline: nil,
        current_state: 'drafting',
        type_abbreviation: 'OVERTURNED_SAR',
        who_its_with: 'DACU',
        type_of_offender_sar?: false,
        offender_sar?: false
    }

    it 'displays ICO case reference number for ICO overturned SAR cases' do
      render partial: 'cases/case_status',
             locals: { case_details: ico_overturned_sar }
      partial = case_status_section(rendered)

      expect(partial.details.ico_ref_number_label.text)
        .to eq 'ICO case reference number'
      expect(partial.details.ico_ref_number.text).to eq '123456789ABC'
    end
  end

end


text:
<?php

namespace Trello\Tests\Functional\Api;

use Trello\Api\Board;

/**
 * @group functional
 */
class BoardTest extends TestCase
{
    protected $boardId = '5461efc60872da1eca5bf45c';

    /**
     * @test
     */
    public function shouldShowBoard()
    {
        $board = $this->client->api('board')->show($this->boardId, array('fields' => 'all'));

        $this->fieldsExist(Board::$fields, $board);
    }

    /**
     * @test
     */
    // public function shouldUpdateBoard()
    // {
    //     $boardName = 'Trello-Github';
    //     $boardNameTest = $boardName + ' test ' + time();

    //     $board = $this->client->api('board')->show($this->boardId);

    //     $board['name'] = $boardNameTest;

    //     $this->client->api('board')->update($this->boardId, $board);
    //     // $this->assertEquals($board['name'], $boardNameTest);

    //     $board = $this->client->api('board')->show($this->boardId);
    //     var_dump($board['name'] === $boardName);
    //     // $this->assertEquals($board['name'], $boardNameTest);

    //     $board['name'] = $boardName;

    //     $this->client->api('board')->update($this->boardId, $board);
    //     // $this->assertEquals($board['name'], $boardName);
    // }
}


text:
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Software Development on Plus-F</title>
    <link>http://plusf.socialthingy.com/tags/software-development/</link>
    <description>Recent content in Software Development on Plus-F</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-gb</language>
    <lastBuildDate>Tue, 13 Dec 2016 21:24:44 +0000</lastBuildDate>

	<atom:link href="http://plusf.socialthingy.com/tags/software-development/index.xml" rel="self" type="application/rss+xml" />

    <item>
      <title>Going Too Quickly, Working Too Hard</title>
      <link>http://plusf.socialthingy.com/blog/optimisation/</link>
      <pubDate>Tue, 13 Dec 2016 21:24:44 +0000</pubDate>

      <guid>http://plusf.socialthingy.com/blog/optimisation/</guid>
      <description>
The just-about-holding-together addition of tape loading emulation I told you about
last time was the last but one of the major bits
of +F. Having reached this milestone, I decided to take some time out and enjoy
playing a game or two of Match Day II before doing any more work on it. My work
may have stopped, but it turns out my computer was working as hard as ever.
</description>
    </item>

    <item>
      <title>If You Only Do One Thing</title>
      <link>http://plusf.socialthingy.com/blog/if-you-only-do-one-thing/</link>
      <pubDate>Mon, 28 Nov 2016 23:25:34 +0000</pubDate>

      <guid>http://plusf.socialthingy.com/blog/if-you-only-do-one-thing/</guid>
      <description>Over the years, there have been all number of innovations, techniques, tools, tricks and fads purported to help you build better-quality applications more quickly - model-driven code generation, object-relational frameworks, IoC containers, unit testing, Scrum, Kanban, documenting everything, documenting nothing, pair programming - even industrial quantities of XML (in the case of the abomination that was SOAP). For me, though, one stands head and shoulders above all the rest, Test-Driven Development.</description>
    </item>

    <item>
      <title>The Fundamentals are Important</title>
      <link>http://plusf.socialthingy.com/blog/fundamentals/</link>
      <pubDate>Sun, 13 Nov 2016 22:43:30 +0000</pubDate>

      <guid>http://plusf.socialthingy.com/blog/fundamentals/</guid>
      <description>The relationship between a programmer and a language is much like the relationship between the cricketer and a bat. Unless you know how to handle it properly, you&rsquo;re not going to achieve much and you could end up in a lot of pain. And so it was with +F, or at least the program which eventually became +F. It started off with the working title QAOPM, and was written in Python.</description>
    </item>

    <item>
      <title>Seeing Clearly</title>
      <link>http://plusf.socialthingy.com/blog/seeing-clearly/</link>
      <pubDate>Sun, 06 Nov 2016 22:02:33 +0000</pubDate>

      <guid>http://plusf.socialthingy.com/blog/seeing-clearly/</guid>
      <description>Before I dive into the missteps and mishaps of +F, I&rsquo;d like to start with one very important thing I did right, in the very early stages.
The original idea for +F came from the tail end of an IM conversation with an old school friend, reminiscing about the computer games we used to play when we were young. A particular favourite of ours was Match Day II (for those of you too young to remember, it was sort of like the best bits of FIFA and PES combined in a single game, only about a hundred times better than that) and we were at the time convinced we would be world champions at it, if such a competition had existed.</description>
    </item>

  </channel>
</rss>


text:
<?php
namespace GuzzleHttp\Command\Guzzle;

use GuzzleHttp\Command\CommandInterface;
use GuzzleHttp\Command\Guzzle\RequestLocation\BodyLocation;
use GuzzleHttp\Command\Guzzle\RequestLocation\FormParamLocation;
use GuzzleHttp\Command\Guzzle\RequestLocation\HeaderLocation;
use GuzzleHttp\Command\Guzzle\RequestLocation\JsonLocation;
use GuzzleHttp\Command\Guzzle\RequestLocation\MultiPartLocation;
use GuzzleHttp\Command\Guzzle\RequestLocation\QueryLocation;
use GuzzleHttp\Command\Guzzle\RequestLocation\RequestLocationInterface;
use GuzzleHttp\Command\Guzzle\RequestLocation\XmlLocation;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Uri;
use GuzzleHttp\Psr7\UriResolver;
use GuzzleHttp\UriTemplate\UriTemplate;
use Psr\Http\Message\RequestInterface;

/**
 * Serializes requests for a given command.
 */
class Serializer
{
    /** @var RequestLocationInterface[] */
    private $locations;

    /** @var DescriptionInterface */
    private $description;

    /**
     * @param DescriptionInterface       $description
     * @param RequestLocationInterface[] $requestLocations Extra request locations
     */
    public function __construct(
        DescriptionInterface $description,
        array $requestLocations = []
    ) {
        static $defaultRequestLocations;
        if (!$defaultRequestLocations) {
            $defaultRequestLocations = [
                'body'      => new BodyLocation(),
                'query'     => new QueryLocation(),
                'header'    => new HeaderLocation(),
                'json'      => new JsonLocation(),
                'xml'       => new XmlLocation(),
                'formParam' => new FormParamLocation(),
                'multipart' => new MultiPartLocation(),
            ];
        }

        $this->locations = $requestLocations + $defaultRequestLocations;
        $this->description = $description;
    }

    /**
     * @param CommandInterface $command
     * @return RequestInterface
     */
    public function __invoke(CommandInterface $command)
    {
        $request = $this->createRequest($command);
        return $this->prepareRequest($command, $request);
    }

    /**
     * Prepares a request for sending using location visitors
     *
     * @param CommandInterface $command
     * @param RequestInterface $request Request being created
     * @return RequestInterface
     * @throws \RuntimeException If a location cannot be handled
     */
    protected function prepareRequest(
        CommandInterface $command,
        RequestInterface $request
    ) {
        $visitedLocations = [];
        $operation = $this->description->getOperation($command->getName());

        // Visit each actual parameter
        foreach ($operation->getParams() as $name => $param) {
            /* @var Parameter $param */
            $location = $param->getLocation();
            // Skip parameters that have not been set or are URI location
            if ($location == 'uri' || !$command->hasParam($name)) {
                continue;
            }
            if (!isset($this->locations[$location])) {
                throw new \RuntimeException("No location registered for $name");
            }
            $visitedLocations[$location] = true;
            $request = $this->locations[$location]->visit($command, $request, $param);
        }

        // Ensure that the after() method is invoked for additionalParameters
        /** @var Parameter $additional */
        if ($additional = $operation->getAdditionalParameters()) {
            $visitedLocations[$additional->getLocation()] = true;
        }

        // Call the after() method for each visited location
        foreach (array_keys($visitedLocations) as $location) {
            $request = $this->locations[$location]->after($command, $request, $operation);
        }

        return $request;
    }

    /**
     * Create a request for the command and operation
     *
     * @param CommandInterface $command
     *
     * @return RequestInterface
     * @throws \RuntimeException
     */
    protected function createRequest(CommandInterface $command)
    {
        $operation = $this->description->getOperation($command->getName());

        // If command does not specify a template, assume the client's base URL.
        if (null === $operation->getUri()) {
            return new Request(
                $operation->getHttpMethod() ?: 'GET',
                $this->description->getBaseUri()
            );
        }

        return $this->createCommandWithUri($operation, $command);
    }

    /**
     * Create a request for an operation with a uri merged onto a base URI
     *
     * @param \GuzzleHttp\Command\Guzzle\Operation $operation
     * @param \GuzzleHttp\Command\CommandInterface $command
     *
     * @return \GuzzleHttp\Psr7\Request
     */
    private function createCommandWithUri(
        Operation $operation,
        CommandInterface $command
    ) {
        // Get the path values and use the client config settings
        $variables = [];
        foreach ($operation->getParams() as $name => $arg) {
            /* @var Parameter $arg */
            if ($arg->getLocation() == 'uri') {
                if (isset($command[$name])) {
                    $variables[$name] = $arg->filter($command[$name]);
                    if (!is_array($variables[$name])) {
                        $variables[$name] = (string) $variables[$name];
                    }
                }
            }
        }

        // Expand the URI template.
        $uri = new Uri(UriTemplate::expand($operation->getUri(), $variables));

        return new Request(
            $operation->getHttpMethod() ?: 'GET',
            UriResolver::resolve($this->description->getBaseUri(), $uri)
        );
    }
}


text:
using System;

namespace Microsoft.Toolkit.Uwp.Notifications
{
    /// <summary>
    /// The binding element contains the visual content for a specific Tile size.
    /// </summary>
    public sealed class TileBinding
    {
        /// <summary>
        /// The target locale of the XML payload, specified as a BCP-47 language tags such as "en-US" or "fr-FR". The locale specified here overrides that in visual, but can be overriden by that in text. If this value is a literal string, this attribute defaults to the user's UI language. If this value is a string reference, this attribute defaults to the locale chosen by Windows Runtime in resolving the string. See Remarks for when this value isn't specified.
        /// </summary>
        public string Language { get; set; }

        /// <summary>
        /// A default base URI that is combined with relative URIs in image source attributes. Defaults to null.
        /// </summary>
        public Uri BaseUri { get; set; }

        /// <summary>
        /// The form that the Tile should use to display the app's brand..
        /// </summary>
        public TileBranding Branding { get; set; } = Element_TileBinding.DEFAULT_BRANDING;

        /// <summary>
        /// Defaults to false. Set to true to allow Windows to append a query string to the image URI supplied in the Tile notification. Use this attribute if your server hosts images and can handle query strings, either by retrieving an image variant based on the query strings or by ignoring the query string and returning the image as specified without the query string. This query string specifies scale, contrast setting, and language; for instance, a value of
        ///
        /// "www.website.com/images/hello.png"
        ///
        /// included in the notification becomes
        ///
        /// "www.website.com/images/hello.png?ms-scale=100&ms-contrast=standard&ms-lang=en-us"
        /// </summary>
        public bool? AddImageQuery { get; set; }

        /// <summary>
        /// Set to a sender-defined string that uniquely identifies the content of the notification. This prevents duplicates in the situation where a large Tile template is displaying the last three wide Tile notifications.
        /// </summary>
        public string ContentId { get; set; }

        /// <summary>
        /// An optional string to override the Tile's display name while showing this notification.
        /// </summary>
        public string DisplayName { get; set; }

        /// <summary>
        /// New in Anniversary Update: App-defined data that is passed back to your app via the TileActivatedInfo property on LaunchActivatedEventArgs when the user launches your app from the Live Tile. This allows you to know which Tile notifications your user saw when they tapped your Live Tile. On devices without the Anniversary Update, this will simply be ignored.
        /// </summary>
        public string Arguments { get; set; }

        /// <summary>
        /// The actual content to be displayed. One of <see cref="TileBindingContentAdaptive"/>, <see cref="TileBindingContentIconic"/>, <see cref="TileBindingContentContact"/>, <see cref="TileBindingContentPeople"/>, or <see cref="TileBindingContentPhotos"/>
        /// </summary>
        public ITileBindingContent Content { get; set; }

        internal Element_TileBinding ConvertToElement(TileSize size)
        {
            TileTemplateNameV3 templateName = GetTemplateName(Content, size);

            Element_TileBinding binding = new Element_TileBinding(templateName)
            {
                Language = Language,
                BaseUri = BaseUri,
                Branding = Branding,
                AddImageQuery = AddImageQuery,
                DisplayName = DisplayName,
                ContentId = ContentId,
                Arguments = Arguments

                // LockDetailedStatus gets populated by TileVisual
            };

            PopulateElement(Content, binding, size);

            return binding;
        }

        private static void PopulateElement(ITileBindingContent bindingContent, Element_TileBinding binding, TileSize size)
        {
            if (bindingContent == null)
            {
                return;
            }

            if (bindingContent is TileBindingContentAdaptive)
            {
                (bindingContent as TileBindingContentAdaptive).PopulateElement(binding, size);
            }
            else if (bindingContent is TileBindingContentContact)
            {
                (bindingContent as TileBindingContentContact).PopulateElement(binding, size);
            }
            else if (bindingContent is TileBindingContentIconic)
            {
                (bindingContent as TileBindingContentIconic).PopulateElement(binding, size);
            }
            else if (bindingContent is TileBindingContentPeople)
            {
                (bindingContent as TileBindingContentPeople).PopulateElement(binding, size);
            }
            else if (bindingContent is TileBindingContentPhotos)
            {
                (bindingContent as TileBindingContentPhotos).PopulateElement(binding, size);
            }
            else
            {
                throw new NotImplementedException("Unknown binding content type: " + bindingContent.GetType());
            }
        }

        private static TileTemplateNameV3 GetTemplateName(ITileBindingContent bindingContent, TileSize size)
        {
            if (bindingContent == null)
            {
                return TileSizeToAdaptiveTemplateConverter.Convert(size);
            }

            if (bindingContent is TileBindingContentAdaptive)
            {
                return (bindingContent as TileBindingContentAdaptive).GetTemplateName(size);
            }

            if (bindingContent is TileBindingContentContact)
            {
                return (bindingContent as TileBindingContentContact).GetTemplateName(size);
            }

            if (bindingContent is TileBindingContentIconic)
            {
                return (bindingContent as TileBindingContentIconic).GetTemplateName(size);
            }

            if (bindingContent is TileBindingContentPeople)
            {
                return (bindingContent as TileBindingContentPeople).GetTemplateName(size);
            }

            if (bindingContent is TileBindingContentPhotos)
            {
                return (bindingContent as TileBindingContentPhotos).GetTemplateName(size);
            }

            throw new NotImplementedException("Unknown binding content type: " + bindingContent.GetType());
        }
    }

    /// <summary>
    /// Visual Tile content. One of <see cref="TileBindingContentAdaptive"/>, <see cref="TileBindingContentIconic"/>, <see cref="TileBindingContentPhotos"/>, <see cref="TileBindingContentPeople"/>, or <see cref="TileBindingContentContact"/>.
    /// </summary>
    public interface ITileBindingContent
    {
    }

    internal enum TileTemplate
    {
        TileSmall,
        TileMedium,
        TileWide,
        TileLarge
    }
}


text:
class UpdateActiveSetupVersionWorkItem : public WorkItem {
 public:
  // The components of the Active Setup Version entry, in order.
  enum VersionComponent {
    // The major version.
    MAJOR,
    // Unused component, always 0 for now.
    UNUSED1,
    // A component used to selectively trigger Active Setup based on local
    // factors such as an OS upgrade.
    SELECTIVE_TRIGGER,
    // Unused component, always 0 for now.
    UNUSED2,
  };

  // The operation to be performed by this UpdateActiveSetupVersionWorkItem.
  enum Operation {
    // Update (or install if not present) the Active Setup "Version" in the
    // registry.
    UPDATE,
    // Also bump the SELECTIVE_TRIGGER component on top of updating the version
    // (will default to 1 if the version was absent or invalid).
    UPDATE_AND_BUMP_SELECTIVE_TRIGGER,
  };

  // Constructs an UpdateActiveSetupVersionWorkItem that will perform
  // |operation| on the |active_setup_path| key in the registry. This key needs
  // to exist when this WorkItem is ran.
  UpdateActiveSetupVersionWorkItem(const std::wstring& active_setup_path,
                                   Operation operation);

  UpdateActiveSetupVersionWorkItem(const UpdateActiveSetupVersionWorkItem&) =
      delete;
  UpdateActiveSetupVersionWorkItem& operator=(
      const UpdateActiveSetupVersionWorkItem&) = delete;

 private:
  // WorkItem:
  bool DoImpl() override;
  void RollbackImpl() override;

  // Returns the updated Active Setup version to be used based on the
  // |existing_version|.
  std::wstring GetUpdatedActiveSetupVersion(
      const std::wstring& existing_version);

  // The underlying WorkItem re-used to operate forward and backward on the
  // registry.
  SetRegValueWorkItem set_reg_value_work_item_;

  // The Operation to be performed by this WorkItem when executed.
  const Operation operation_;
};

#endif  // CHROME_INSTALLER_SETUP_UPDATE_ACTIVE_SETUP_VERSION_WORK_ITEM_H_


text:
<!-- CSS -->
<link href="/assets/css/bootstrap.min.css" rel="stylesheet">
<link href="/assets/css/styles.min.css?v=20181022" rel="stylesheet">


text:
package de.kuix.android.apps.authenticator;

import android.os.Handler;

/**
 * Task that periodically notifies its listener about the time remaining until the value of a TOTP
 * counter changes.
 *
 * @author klyubin@google.com (Alex Klyubin)
 */
class TotpCountdownTask implements Runnable {
  private final TotpCounter mCounter;
  private final TotpClock mClock;
  private final long mRemainingTimeNotificationPeriod;
  private final Handler mHandler = new Handler();

  private long mLastSeenCounterValue = Long.MIN_VALUE;
  private boolean mShouldStop;
  private Listener mListener;

  /**
   * Listener notified of changes to the time remaining until the counter value changes.
   */
  interface Listener {

    /**
     * Invoked when the time remaining till the TOTP counter changes its value.
     *
     * @param millisRemaining time (milliseconds) remaining.
     */
    void onTotpCountdown(long millisRemaining);

    /** Invoked when the TOTP counter changes its value. */
    void onTotpCounterValueChanged();
  }

  /**
   * Constructs a new {@code TotpRefreshTask}.
   *
   * @param counter TOTP counter this task monitors.
   * @param clock TOTP clock that drives this task.
   * @param remainingTimeNotificationPeriod approximate interval (milliseconds) at which this task
   *        notifies its listener about the time remaining until the @{code counter} changes its
   *        value.
   */
  TotpCountdownTask(TotpCounter counter, TotpClock clock, long remainingTimeNotificationPeriod) {
    mCounter = counter;
    mClock = clock;
    mRemainingTimeNotificationPeriod = remainingTimeNotificationPeriod;
  }

  /**
   * Sets the listener that this task will periodically notify about the state of the TOTP counter.
   *
   * @param listener listener or {@code null} for no listener.
   */
  void setListener(Listener listener) {
    mListener = listener;
  }

  /**
   * Starts this task and immediately notifies the listener that the counter value has changed.
   *
   * <p>The immediate notification during startup ensures that the listener does not miss any
   * updates.
   *
   * @throws IllegalStateException if the task has already been stopped.
   */
  void startAndNotifyListener() {
    if (mShouldStop) {
      throw new IllegalStateException("Task already stopped and cannot be restarted.");
    }

    run();
  }

  /**
   * Stops this task. This task will never notify the listener after the task has been stopped.
   */
  void stop() {
    mShouldStop = true;
  }

  @Override
  public void run() {
    if (mShouldStop) {
      return;
    }

    long now = mClock.currentTimeMillis();
    long counterValue = getCounterValue(now);
    if (mLastSeenCounterValue != counterValue) {
      mLastSeenCounterValue = counterValue;
      fireTotpCounterValueChanged();
    }
    fireTotpCountdown(getTimeTillNextCounterValue(now));

    scheduleNextInvocation();
  }

  private void scheduleNextInvocation() {
    long now = mClock.currentTimeMillis();
    long counterValueAge = getCounterValueAge(now);
    long timeTillNextInvocation =
        mRemainingTimeNotificationPeriod - (counterValueAge % mRemainingTimeNotificationPeriod);
    mHandler.postDelayed(this, timeTillNextInvocation);
  }

  private void fireTotpCountdown(long timeRemaining) {
    if ((mListener != null) && (!mShouldStop)) {
      mListener.onTotpCountdown(timeRemaining);
    }
  }

  private void fireTotpCounterValueChanged() {
    if ((mListener != null) && (!mShouldStop)) {
      mListener.onTotpCounterValueChanged();
    }
  }

  /**
   * Gets the value of the counter at the specified time instant.
   *
   * @param time time instant (milliseconds since epoch).
   */
  private long getCounterValue(long time) {
    return mCounter.getValueAtTime(Utilities.millisToSeconds(time));
  }

  /**
   * Gets the time remaining till the counter assumes its next value.
   *
   * @param time time instant (milliseconds since epoch) for which to perform the query.
   *
   * @return time (milliseconds) till next value.
   */
  private long getTimeTillNextCounterValue(long time) {
    long currentValue = getCounterValue(time);
    long nextValue = currentValue + 1;
    long nextValueStartTime = Utilities.secondsToMillis(mCounter.getValueStartTime(nextValue));
    return nextValueStartTime - time;
  }

  /**
   * Gets the age of the counter value at the specified time instant.
   *
   * @param time time instant (milliseconds since epoch).
   *
   * @return age (milliseconds).
   */
  private long getCounterValueAge(long time) {
    return time - Utilities.secondsToMillis(mCounter.getValueStartTime(getCounterValue(time)));
  }
}


text:
using namespace Eclo::STM32F4;

HRESULT Library_Eclo_STM32F4_Eclo_STM32F4_System::NativeGetHardwareSerial___STATIC__VOID__SZARRAY_U1( CLR_RT_StackFrame& stack )
{
    TINYCLR_HEADER(); hr = S_OK;
    {
        CLR_RT_TypedArray_UINT8 param0;
        TINYCLR_CHECK_HRESULT( Interop_Marshal_UINT8_ARRAY( stack, 0, param0 ) );

        System::NativeGetHardwareSerial( param0, hr );
        TINYCLR_CHECK_HRESULT( hr );
    }
    TINYCLR_NOCLEANUP();
}


text:
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using Xunit;

internal class Outside
{
    public class Inside { }
}

internal class Outside<T>
{
    public class Inside<U> { }
}

namespace System.Tests
{
    public static class TypeTests
    {
        [Theory]
        [InlineData(typeof(int), null)]
        [InlineData(typeof(int[]), null)]
        [InlineData(typeof(Outside.Inside), typeof(Outside))]
        [InlineData(typeof(Outside.Inside[]), null)]
        [InlineData(typeof(Outside<int>), null)]
        [InlineData(typeof(Outside<int>.Inside<double>), typeof(Outside<>))]
        public static void DeclaringType(Type t, Type expected)
        {
            Assert.Equal(expected, t.DeclaringType);
        }

        [Theory]
        [InlineData(typeof(int))]
        [InlineData(typeof(int[]))]
        [InlineData(typeof(IList<int>))]
        [InlineData(typeof(IList<>))]
        public static void GenericParameterPosition_Invalid(Type t)
        {
            Assert.Throws<InvalidOperationException>(() => t.GenericParameterPosition);
        }

        [Theory]
        [InlineData(typeof(int), new Type[0])]
        [InlineData(typeof(IDictionary<int, string>), new[] { typeof(int), typeof(string) })]
        [InlineData(typeof(IList<int>), new[] { typeof(int) })]
        [InlineData(typeof(IList<>), new Type[0])]
        public static void GenericTypeArguments(Type t, Type[] expected)
        {
            Type[] result = t.GenericTypeArguments;
            Assert.Equal(expected.Length, result.Length);
            for (int i = 0; i < expected.Length; i++)
            {
                Assert.Equal(expected[i], result[i]);
            }
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), true)]
        [InlineData(typeof(IList<int>), false)]
        [InlineData(typeof(IList<>), false)]
        public static void HasElementType(Type t, bool expected)
        {
            Assert.Equal(expected, t.HasElementType);
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), true)]
        [InlineData(typeof(IList<int>), false)]
        [InlineData(typeof(IList<>), false)]
        public static void IsArray(Type t, bool expected)
        {
            Assert.Equal(expected, t.IsArray);
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), false)]
        [InlineData(typeof(IList<int>), false)]
        [InlineData(typeof(IList<>), false)]
        public static void IsByRef(Type t, bool expected)
        {
            Assert.Equal(expected, t.IsByRef);
            Assert.True(t.MakeByRefType().IsByRef);
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), false)]
        [InlineData(typeof(IList<int>), false)]
        [InlineData(typeof(IList<>), false)]
        [InlineData(typeof(int*), true)]
        public static void IsPointer(Type t, bool expected)
        {
            Assert.Equal(expected, t.IsPointer);
            Assert.True(t.MakePointerType().IsPointer);
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), false)]
        [InlineData(typeof(IList<int>), true)]
        [InlineData(typeof(IList<>), false)]
        public static void IsConstructedGenericType(Type t, bool expected)
        {
            Assert.Equal(expected, t.IsConstructedGenericType);
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), false)]
        [InlineData(typeof(IList<int>), false)]
        [InlineData(typeof(IList<>), false)]
        public static void IsGenericParameter(Type t, bool expected)
        {
            Assert.Equal(expected, t.IsGenericParameter);
        }

        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(int[]), false)]
        [InlineData(typeof(Outside.Inside), true)]
        [InlineData(typeof(Outside.Inside[]), false)]
        [InlineData(typeof(Outside<int>), false)]
        [InlineData(typeof(Outside<int>.Inside<double>), true)]
        public static void IsNested(Type t, bool expected)
        {
            Assert.Equal(expected, t.IsNested);
        }

        [Theory]
        [InlineData(typeof(int), typeof(int))]
        [InlineData(typeof(int[]), typeof(int[]))]
        [InlineData(typeof(Outside<int>), typeof(Outside<int>))]
        public static void TypeHandle(Type t1, Type t2)
        {
            RuntimeTypeHandle r1 = t1.TypeHandle;
            RuntimeTypeHandle r2 = t2.TypeHandle;
            Assert.Equal(r1, r2);

            Assert.Equal(t1, Type.GetTypeFromHandle(r1));
            Assert.Equal(t1, Type.GetTypeFromHandle(r2));
        }

        [Fact]
        public static void GetTypeFromDefaultHandle()
        {
            Assert.Null(Type.GetTypeFromHandle(default(RuntimeTypeHandle)));
        }

        [Theory]
        [InlineData(typeof(int[]), 1)]
        [InlineData(typeof(int[,,]), 3)]
        public static void GetArrayRank(Type t, int expected)
        {
            Assert.Equal(expected, t.GetArrayRank());
        }

        [Theory]
        [InlineData(typeof(int))]
        [InlineData(typeof(IList<int>))]
        [InlineData(typeof(IList<>))]
        public static void GetArrayRank_Invalid(Type t)
        {
            Assert.Throws<ArgumentException>(() => t.GetArrayRank());
        }

        [Theory]
        [InlineData(typeof(int), null)]
        [InlineData(typeof(Outside.Inside), null)]
        [InlineData(typeof(int[]), typeof(int))]
        [InlineData(typeof(Outside<int>.Inside<double>[]), typeof(Outside<int>.Inside<double>))]
        [InlineData(typeof(Outside<int>), null)]
        [InlineData(typeof(Outside<int>.Inside<double>), null)]
        public static void GetElementType(Type t, Type expected)
        {
            Assert.Equal(expected, t.GetElementType());
        }

        [Theory]
        [InlineData(typeof(int), typeof(int[]))]
        public static void MakeArrayType(Type t, Type tArrayExpected)
        {
            Type tArray = t.MakeArrayType();

            Assert.Equal(tArrayExpected, tArray);
            Assert.Equal(t, tArray.GetElementType());

            Assert.True(tArray.IsArray);
            Assert.True(tArray.HasElementType);

            string s1 = t.ToString();
            string s2 = tArray.ToString();
            Assert.Equal(s2, s1 + "[]");
        }

        [Theory]
        [InlineData(typeof(int))]
        public static void MakeByRefType(Type t)
        {
            Type tRef1 = t.MakeByRefType();
            Type tRef2 = t.MakeByRefType();

            Assert.Equal(tRef1, tRef2);

            Assert.True(tRef1.IsByRef);
            Assert.True(tRef1.HasElementType);

            Assert.Equal(t, tRef1.GetElementType());

            string s1 = t.ToString();
            string s2 = tRef1.ToString();
            Assert.Equal(s2, s1 + "&");
        }

        [Theory]
        [InlineData("System.Nullable`1[System.Int32]", typeof(int?))]
        [InlineData("System.Int32*", typeof(int*))]
        [InlineData("System.Int32**", typeof(int**))]
        [InlineData("Outside`1", typeof(Outside<>))]
        [InlineData("Outside`1+Inside`1", typeof(Outside<>.Inside<>))]
        [InlineData("Outside[]", typeof(Outside[]))]
        [InlineData("Outside[,,]", typeof(Outside[,,]))]
        [InlineData("Outside[][]", typeof(Outside[][]))]
        [InlineData("Outside`1[System.Nullable`1[System.Boolean]]", typeof(Outside<bool?>))]
        public static void GetTypeByName(string typeName, Type expectedType)
        {
            Type t = Type.GetType(typeName, throwOnError: false, ignoreCase: false);
            Assert.Equal(expectedType, t);

            t = Type.GetType(typeName.ToLower(), throwOnError: false, ignoreCase: true);
            Assert.Equal(expectedType, t);
        }

        [Theory]
        [InlineData("system.nullable`1[system.int32]", typeof(TypeLoadException), false)]
        [InlineData("System.NonExistingType", typeof(TypeLoadException), false)]
        [InlineData("", typeof(TypeLoadException), false)]
        [InlineData("System.Int32[,*,]", typeof(ArgumentException), false)]
        [InlineData("Outside`2", typeof(TypeLoadException), false)]
        [InlineData("Outside`1[System.Boolean, System.Int32]", typeof(ArgumentException), true)]
        public static void GetTypeByName_Invalid(string typeName, Type expectedException, bool alwaysThrowsException)
        {
            if (!alwaysThrowsException)
            {
                Type t = Type.GetType(typeName, throwOnError: false, ignoreCase: false);
                Assert.Null(t);
            }

            Assert.Throws(expectedException, () => Type.GetType(typeName, throwOnError: true, ignoreCase: false));
        }

        [Fact]
        public static void Delimiter()
        {
            Assert.NotNull(Type.Delimiter);
        }

        [Theory]
        [InlineData(typeof(bool), TypeCode.Boolean)]
        [InlineData(typeof(byte), TypeCode.Byte)]
        [InlineData(typeof(char), TypeCode.Char)]
        [InlineData(typeof(DateTime), TypeCode.DateTime)]
        [InlineData(typeof(decimal), TypeCode.Decimal)]
        [InlineData(typeof(double), TypeCode.Double)]
        [InlineData(null, TypeCode.Empty)]
        [InlineData(typeof(short), TypeCode.Int16)]
        [InlineData(typeof(int), TypeCode.Int32)]
        [InlineData(typeof(long), TypeCode.Int64)]
        [InlineData(typeof(object), TypeCode.Object)]
        [InlineData(typeof(System.Nullable), TypeCode.Object)]
        [InlineData(typeof(Nullable<int>), TypeCode.Object)]
        [InlineData(typeof(Dictionary<,>), TypeCode.Object)]
        [InlineData(typeof(Exception), TypeCode.Object)]
        [InlineData(typeof(sbyte), TypeCode.SByte)]
        [InlineData(typeof(float), TypeCode.Single)]
        [InlineData(typeof(string), TypeCode.String)]
        [InlineData(typeof(ushort), TypeCode.UInt16)]
        [InlineData(typeof(uint), TypeCode.UInt32)]
        [InlineData(typeof(ulong), TypeCode.UInt64)]
        public static void GetTypeCode(Type t, TypeCode typeCode)
        {
            Assert.Equal(typeCode, Type.GetTypeCode(t));
        }

        public static void ReflectionOnlyGetType()
        {
            AssertExtensions.Throws<ArgumentNullException>("typeName", () => Type.ReflectionOnlyGetType(null, true, false));
            Assert.Throws<TypeLoadException>(() => Type.ReflectionOnlyGetType("", true, true));
            Assert.Throws<NotSupportedException>(() => Type.ReflectionOnlyGetType("System.Tests.TypeTests", false, true));
        }
    }

    public class TypeTestsExtended : RemoteExecutorTestBase
    {
        public class ContextBoundClass : ContextBoundObject
        {
            public string Value = "The Value property.";
        }

        static string s_testAssemblyPath = Path.Combine(Environment.CurrentDirectory, "TestLoadAssembly.dll");
        static string testtype = "System.Collections.Generic.Dictionary`2[[Program, Foo], [Program, Foo]]";

        private static Func<AssemblyName, Assembly> assemblyloader = (aName) => aName.Name == "TestLoadAssembly" ?
                           Assembly.LoadFrom(@".\TestLoadAssembly.dll") :
                           null;
        private static Func<Assembly, String, Boolean, Type> typeloader = (assem, name, ignore) => assem == null ?
                             Type.GetType(name, false, ignore) :
                                 assem.GetType(name, false, ignore);
        [Fact]
        [SkipOnTargetFramework(TargetFrameworkMonikers.UapAot, "Assembly.LoadFrom() is not supported on UapAot")]
        public static void GetTypeByName()
        {
            RemoteInvokeOptions options = new RemoteInvokeOptions();
            RemoteInvoke(() =>
               {
                   string test1 = testtype;
                   Type t1 = Type.GetType(test1,
                             (aName) => aName.Name == "Foo" ?
                                   Assembly.LoadFrom(s_testAssemblyPath) : null,
                             typeloader,
                             true
                     );

                   Assert.NotNull(t1);

                   string test2 = "System.Collections.Generic.Dictionary`2[[Program, TestLoadAssembly], [Program, TestLoadAssembly]]";
                   Type t2 = Type.GetType(test2, assemblyloader, typeloader, true);

                   Assert.NotNull(t2);
                   Assert.Equal(t1, t2);

                   return SuccessExitCode;
               }, options).Dispose();
        }

        [Fact]
        [SkipOnTargetFramework(TargetFrameworkMonikers.UapAot, "Assembly.LoadFrom() is not supported on UapAot")]
        public static void GetTypeByNameTypeloadFailure()
        {
            RemoteInvokeOptions options = new RemoteInvokeOptions();
            RemoteInvoke(() =>
               {
                   string test1 = testtype;
                   //Loading from the wrong path
                   Assert.Throws<System.IO.FileNotFoundException>(() =>
                   Type.GetType(test1,
                     (aName) => aName.Name == "Foo" ?
                         Assembly.LoadFrom(@".\NoSuchTestLoadAssembly.dll") : null,
                     typeloader,
                     true
                  ));

                   //Type specified 'Program2' does not exst
                   string test2 = "System.Collections.Generic.Dictionary`2[[Program, TestLoadAssembly], [Program2, TestLoadAssembly]]";
                   Assert.Throws<TypeLoadException>(() => Type.GetType(test2, assemblyloader, typeloader, true));

                   //Api does not throw
                   Type t1 = Type.GetType(test2,
                                          assemblyloader,
                                          typeloader,
                                          false      //no throw
                    );

                   Assert.Null(t1);

                   return SuccessExitCode;
               }, options).Dispose();
        }

        [Fact]
        [SkipOnTargetFramework(TargetFrameworkMonikers.UapAot, "Assembly.LoadFrom() is not supported on UapAot")]
        public static void GetTypeByNameCaseSensitiveTypeloadFailure()
        {
            RemoteInvokeOptions options = new RemoteInvokeOptions();
            RemoteInvoke(() =>
               {
                   //Type load failure due to case sensitive search of type Ptogram
                   string test3 = "System.Collections.Generic.Dictionary`2[[Program, TestLoadAssembly], [program, TestLoadAssembly]]";
                   Assert.Throws<TypeLoadException>(() =>
                                Type.GetType(test3,
                                            assemblyloader,
                                            typeloader,
                                            true,
                                            false     //case sensitive
                   ));

                   //non throwing version
                   Type t2 = Type.GetType(test3,
                                          assemblyloader,
                                          typeloader,
                                          false,  //no throw
                                          false
                  );

                   Assert.Null(t2);

                   return SuccessExitCode;
               }, options).Dispose();
        }

        [Fact]
        [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
        public static void IsContextful()
        {
            Assert.True(!typeof(TypeTestsExtended).IsContextful);
            Assert.True(!typeof(ContextBoundClass).IsContextful);
        }
    }
}


text:
Graph::Graph(vertex_t vertices)
: _vertices(vertices)
, _edges(0)
{ }

void Graph::add_edge(vertex_t first, vertex_t second)
{
	_vertices[first].push_back({second, _edges});
	_vertices[second].push_back({first, _edges});

	++_edges;
}

const Graph::adjacent_t& Graph::adjacent(vertex_t vertex) const
{
	return _vertices[vertex];
}

Graph::size_t Graph::number_of_edges() const
{
	return _edges;
}

Graph::size_t Graph::number_of_vertices() const
{
	return _vertices.size();
}


text:
int main()
{
	namespace yapl = yet_another_process_library;
	// Making platform specific assumptions about charset of arguments:
	// With `make_ascii_args` you'll get an exception thrown in the face if you pass
	// a non-ASCII character instead of locale-specific Heisenbugs
	// (Hello, "local" codepage and xxxA WinAPI functions)
	try
	{
		yapl::process p("which", yapl::make_ascii_args({ "długa nazwa programu" }), [](boost::string_ref s)
		{
			std::cout << s << "\n";
		}, yapl::stderr_closed, yapl::stdin_closed | yapl::search_path_env);
		p.wait();
		assert(false);
	}
	catch(const yapl::invalid_encoding& ex)
	{
		std::cout << "Localization Heisenbug prevented!\n";
	}
}


text:
jest.mock('utils/dictionary/dictionary', () => {
  return {
    no_FAKE_NAME: 'This is a no items message fake'
  };
});

import React from 'react';
import { shallow } from 'enzyme';

import ListWithInputPanelList from './list-with-input-panel-list';
import ListWithInputPanelItem from './list-with-input-panel-item';

import { getFakeFields } from '../utils/test-utils';
import { noop } from 'utils/test/test-utils';
import { WIDGET_LIST_WITH_INPUT_PANEL } from 'constants/dom-constants';

const { LIST_EMPTY_CLASS } = WIDGET_LIST_WITH_INPUT_PANEL;

describe('<ListWithInputPanelList', () => {
  let props;
  const items = [
    {
      id: 'FAKE_ITEM_0',
      label: 'Fake label 0'
    },
    {
      id: 'FAKE_ITEM_1',
      label: 'Fake label 1'
    },
    {
      id: 'FAKE_ITEM_2',
      label: 'Fake label 2'
    }
  ];

  beforeEach(() => {
    props = {
      fields: getFakeFields(items, 'FAKE_NAME'),
      select: noop,
      dictionaryNoItems: ''
    };
  });

  test('Should render all the elements existing in the "fields" property', () => {
    const wrapper = shallow(<ListWithInputPanelList {...props} />);

    expect(wrapper.find(ListWithInputPanelItem)).toHaveLength(3);
  });

  test('Should render an one item list with the corresponding message when the list of fields is empty', () => {
    const messageNoItems = 'This is a no items message fake';
    props.fields = getFakeFields([], 'FAKE_NAME');
    props.dictionaryNoItems = 'fakeNoItems';
    const wrapper = shallow(<ListWithInputPanelList {...props} />);

    expect(wrapper.find(ListWithInputPanelItem)).toHaveLength(0);
    expect(wrapper.find(`.${LIST_EMPTY_CLASS}`)).toHaveLength(1);
    expect(wrapper.find(`.${LIST_EMPTY_CLASS}`).text()).toBe(messageNoItems);
  });
});


text:
/*
**  MFAPI.H -- Global definitions for mail filter library and mail filters.
*/

#ifndef _LIBMILTER_MFAPI_H
# define _LIBMILTER_MFAPI_H	1

#ifndef SMFI_VERSION
# if _FFR_MDS_NEGOTIATE
#  define SMFI_VERSION	0x01000002	/* libmilter version number */

   /* first libmilter version that has MDS support */
#  define SMFI_VERSION_MDS	0x01000002
# else /* _FFR_MDS_NEGOTIATE */
#  define SMFI_VERSION	0x01000001	/* libmilter version number */
# endif /* _FFR_MDS_NEGOTIATE */
#endif /* ! SMFI_VERSION */

#define SM_LM_VRS_MAJOR(v)	(((v) & 0x7f000000) >> 24)
#define SM_LM_VRS_MINOR(v)	(((v) & 0x007fff00) >> 8)
#define SM_LM_VRS_PLVL(v)	((v) & 0x0000007f)

# include <sys/types.h>
# include <sys/socket.h>

#include "libmilter/mfdef.h"

# define LIBMILTER_API		extern

/* Only need to export C interface if used by C++ source code */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#ifndef _SOCK_ADDR
# define _SOCK_ADDR	struct sockaddr
#endif /* ! _SOCK_ADDR */

/*
**  libmilter functions return one of the following to indicate
**  success/failure(/continue):
*/

#define MI_SUCCESS	0
#define MI_FAILURE	(-1)
#if _FFR_WORKERS_POOL
# define MI_CONTINUE	1
#endif /* _FFR_WORKERS_POOL */

/* "forward" declarations */
typedef struct smfi_str SMFICTX;
typedef struct smfi_str *SMFICTX_PTR;

typedef struct smfiDesc smfiDesc_str;
typedef struct smfiDesc	*smfiDesc_ptr;

/*
**  Type which callbacks should return to indicate message status.
**  This may take on one of the SMFIS_* values listed below.
*/

typedef int	sfsistat;

#if defined(__linux__) && defined(__GNUC__) && defined(__cplusplus) && __GNUC_MINOR__ >= 8
# define SM__P(X)	__PMT(X)
#else /* __linux__ && __GNUC__ && __cplusplus && _GNUC_MINOR__ >= 8 */
# define SM__P(X)	__P(X)
#endif /* __linux__ && __GNUC__ && __cplusplus && _GNUC_MINOR__ >= 8 */

/* Some platforms don't define __P -- do it for them here: */
#ifndef __P
# ifdef __STDC__
#  define __P(X) X
# else /* __STDC__ */
#  define __P(X) ()
# endif /* __STDC__ */
#endif /* __P */

#if SM_CONF_STDBOOL_H
# include <stdbool.h>
#else /* SM_CONF_STDBOOL_H */
# ifndef __cplusplus
#  ifndef bool
#   ifndef __bool_true_false_are_defined
typedef int	bool;
#    define false	0
#    define true	1
#    define __bool_true_false_are_defined	1
#   endif /* ! __bool_true_false_are_defined */
#  endif /* bool */
# endif /* ! __cplusplus */
#endif /* SM_CONF_STDBOOL_H */

/*
**  structure describing one milter
*/

struct smfiDesc
{
	char		*xxfi_name;	/* filter name */
	int		xxfi_version;	/* version code -- do not change */
	unsigned long	xxfi_flags;	/* flags */

	/* connection info filter */
	sfsistat	(*xxfi_connect) SM__P((SMFICTX *, char *, _SOCK_ADDR *));

	/* SMTP HELO command filter */
	sfsistat	(*xxfi_helo) SM__P((SMFICTX *, char *));

	/* envelope sender filter */
	sfsistat	(*xxfi_envfrom) SM__P((SMFICTX *, char **));

	/* envelope recipient filter */
	sfsistat	(*xxfi_envrcpt) SM__P((SMFICTX *, char **));

	/* header filter */
	sfsistat	(*xxfi_header) SM__P((SMFICTX *, char *, char *));

	/* end of header */
	sfsistat	(*xxfi_eoh) SM__P((SMFICTX *));

	/* body block */
	sfsistat	(*xxfi_body) SM__P((SMFICTX *, unsigned char *, size_t));

	/* end of message */
	sfsistat	(*xxfi_eom) SM__P((SMFICTX *));

	/* message aborted */
	sfsistat	(*xxfi_abort) SM__P((SMFICTX *));

	/* connection cleanup */
	sfsistat	(*xxfi_close) SM__P((SMFICTX *));

	/* any unrecognized or unimplemented command filter */
	sfsistat	(*xxfi_unknown) SM__P((SMFICTX *, const char *));

	/* SMTP DATA command filter */
	sfsistat	(*xxfi_data) SM__P((SMFICTX *));

	/* negotiation callback */
	sfsistat	(*xxfi_negotiate) SM__P((SMFICTX *,
					unsigned long, unsigned long,
					unsigned long, unsigned long,
					unsigned long *, unsigned long *,
					unsigned long *, unsigned long *));

#if 0
	/* signal handler callback, not yet implemented. */
	int		(*xxfi_signal) SM__P((int));
#endif

};

LIBMILTER_API int smfi_opensocket __P((bool));
LIBMILTER_API int smfi_register __P((struct smfiDesc));
LIBMILTER_API int smfi_main __P((void));
LIBMILTER_API int smfi_setbacklog __P((int));
LIBMILTER_API int smfi_setdbg __P((int));
LIBMILTER_API int smfi_settimeout __P((int));
LIBMILTER_API int smfi_setconn __P((char *));
LIBMILTER_API int smfi_stop __P((void));
LIBMILTER_API size_t smfi_setmaxdatasize __P((size_t));
LIBMILTER_API int smfi_version __P((unsigned int *, unsigned int *, unsigned int *));

/*
**  What the filter might do -- values to be ORed together for
**  smfiDesc.xxfi_flags.
*/

#define SMFIF_NONE	0x00000000L	/* no flags */
#define SMFIF_ADDHDRS	0x00000001L	/* filter may add headers */
#define SMFIF_CHGBODY	0x00000002L	/* filter may replace body */
#define SMFIF_MODBODY	SMFIF_CHGBODY	/* backwards compatible */
#define SMFIF_ADDRCPT	0x00000004L	/* filter may add recipients */
#define SMFIF_DELRCPT	0x00000008L	/* filter may delete recipients */
#define SMFIF_CHGHDRS	0x00000010L	/* filter may change/delete headers */
#define SMFIF_QUARANTINE 0x00000020L	/* filter may quarantine envelope */

/* filter may change "from" (envelope sender) */
#define SMFIF_CHGFROM	0x00000040L
#define SMFIF_ADDRCPT_PAR	0x00000080L	/* add recipients incl. args */

/* filter can send set of symbols (macros) that it wants */
#define SMFIF_SETSYMLIST	0x00000100L

/*
**  Macro "places";
**  Notes:
**  - must be coordinated with libmilter/engine.c and sendmail/milter.c
**  - the order MUST NOT be changed as it would break compatibility between
**	different versions. It's ok to append new entries however
**	(hence the list is not sorted by the SMT protocol steps).
*/

#define SMFIM_NOMACROS	(-1)	/* Do NOT use, internal only */
#define SMFIM_FIRST	0	/* Do NOT use, internal marker only */
#define SMFIM_CONNECT	0	/* connect */
#define SMFIM_HELO	1	/* HELO/EHLO */
#define SMFIM_ENVFROM	2	/* MAIL From */
#define SMFIM_ENVRCPT	3	/* RCPT To */
#define SMFIM_DATA	4	/* DATA */
#define SMFIM_EOM	5	/* end of message (final dot) */
#define SMFIM_EOH	6	/* end of header */
#define SMFIM_LAST	6	/* Do NOT use, internal marker only */

/*
**  Continue processing message/connection.
*/

#define SMFIS_CONTINUE	0

/*
**  Reject the message/connection.
**  No further routines will be called for this message
**  (or connection, if returned from a connection-oriented routine).
*/

#define SMFIS_REJECT	1

/*
**  Accept the message,
**  but silently discard the message.
**  No further routines will be called for this message.
**  This is only meaningful from message-oriented routines.
*/

#define SMFIS_DISCARD	2

/*
**  Accept the message/connection.
**  No further routines will be called for this message
**  (or connection, if returned from a connection-oriented routine;
**  in this case, it causes all messages on this connection
**  to be accepted without filtering).
*/

#define SMFIS_ACCEPT	3

/*
**  Return a temporary failure, i.e.,
**  the corresponding SMTP command will return a 4xx status code.
**  In some cases this may prevent further routines from
**  being called on this message or connection,
**  although in other cases (e.g., when processing an envelope
**  recipient) processing of the message will continue.
*/

#define SMFIS_TEMPFAIL	4

/*
**  Do not send a reply to the MTA
*/

#define SMFIS_NOREPLY	7

/*
**  Skip over rest of same callbacks, e.g., body.
*/

#define SMFIS_SKIP	8

/* xxfi_negotiate: use all existing protocol options/actions */
#define SMFIS_ALL_OPTS	10

#if 0
/*
**  Filter Routine Details
*/

/* connection info filter */
extern sfsistat	xxfi_connect __P((SMFICTX *, char *, _SOCK_ADDR *));

/*
**  xxfi_connect(ctx, hostname, hostaddr) Invoked on each connection
**
**	char *hostname; Host domain name, as determined by a reverse lookup
**		on the host address.
**	_SOCK_ADDR *hostaddr; Host address, as determined by a getpeername
**		call on the SMTP socket.
*/

/* SMTP HELO command filter */
extern sfsistat	xxfi_helo __P((SMFICTX *, char *));

/*
**  xxfi_helo(ctx, helohost) Invoked on SMTP HELO/EHLO command
**
**	char *helohost; Value passed to HELO/EHLO command, which should be
**		the domain name of the sending host (but is, in practice,
**		anything the sending host wants to send).
*/

/* envelope sender filter */
extern sfsistat	xxfi_envfrom __P((SMFICTX *, char **));

/*
**  xxfi_envfrom(ctx, argv) Invoked on envelope from
**
**	char **argv; Null-terminated SMTP command arguments;
**		argv[0] is guaranteed to be the sender address.
**		Later arguments are the ESMTP arguments.
*/

/* envelope recipient filter */
extern sfsistat	xxfi_envrcpt __P((SMFICTX *, char **));

/*
**  xxfi_envrcpt(ctx, argv) Invoked on each envelope recipient
**
**	char **argv; Null-terminated SMTP command arguments;
**		argv[0] is guaranteed to be the recipient address.
**		Later arguments are the ESMTP arguments.
*/

/* unknown command filter */

extern sfsistat	*xxfi_unknown __P((SMFICTX *, const char *));

/*
**  xxfi_unknown(ctx, arg) Invoked when SMTP command is not recognized or not
**  implemented.
**	const char *arg; Null-terminated SMTP command
*/

/* header filter */
extern sfsistat	xxfi_header __P((SMFICTX *, char *, char *));

/*
**  xxfi_header(ctx, headerf, headerv) Invoked on each message header. The
**  content of the header may have folded white space (that is, multiple
**  lines with following white space) included.
**
**	char *headerf; Header field name
**	char *headerv; Header field value
*/

/* end of header */
extern sfsistat	xxfi_eoh __P((SMFICTX *));

/*
**  xxfi_eoh(ctx) Invoked at end of header
*/

/* body block */
extern sfsistat	xxfi_body __P((SMFICTX *, unsigned char *, size_t));

/*
**  xxfi_body(ctx, bodyp, bodylen) Invoked for each body chunk. There may
**  be multiple body chunks passed to the filter. End-of-lines are
**  represented as received from SMTP (normally Carriage-Return/Line-Feed).
**
**	unsigned char *bodyp; Pointer to body data
**	size_t bodylen; Length of body data
*/

/* end of message */
extern sfsistat	xxfi_eom __P((SMFICTX *));

/*
**  xxfi_eom(ctx) Invoked at end of message. This routine can perform
**  special operations such as modifying the message header, body, or
**  envelope.
*/

/* message aborted */
extern sfsistat	xxfi_abort __P((SMFICTX *));

/*
**  xxfi_abort(ctx) Invoked if message is aborted outside of the control of
**  the filter, for example, if the SMTP sender issues an RSET command. If
**  xxfi_abort is called, xxfi_eom will not be called and vice versa.
*/

/* connection cleanup */
extern sfsistat	xxfi_close __P((SMFICTX *));

/*
**  xxfi_close(ctx) Invoked at end of the connection. This is called on
**  close even if the previous mail transaction was aborted.
*/
#endif /* 0 */

/*
**  Additional information is passed in to the vendor filter routines using
**  symbols. Symbols correspond closely to sendmail macros. The symbols
**  defined depend on the context. The value of a symbol is accessed using:
*/

/* Return the value of a symbol. */
LIBMILTER_API char * smfi_getsymval __P((SMFICTX *, char *));

/*
**  Return the value of a symbol.
**
**	SMFICTX *ctx; Opaque context structure
**	char *symname; The name of the symbol to access.
*/

/*
**  Vendor filter routines that want to pass additional information back to
**  the MTA for use in SMTP replies may call smfi_setreply before returning.
*/

LIBMILTER_API int smfi_setreply __P((SMFICTX *, char *, char *, char *));

/*
**  Alternatively, smfi_setmlreply can be called if a multi-line SMTP reply
**  is needed.
*/

LIBMILTER_API int smfi_setmlreply __P((SMFICTX *, const char *, const char *, ...));

/*
**  Set the specific reply code to be used in response to the active
**  command. If not specified, a generic reply code is used.
**
**	SMFICTX *ctx; Opaque context structure
**	char *rcode; The three-digit (RFC 821) SMTP reply code to be
**		returned, e.g., ``551''.
**	char *xcode; The extended (RFC 2034) reply code, e.g., ``5.7.6''.
**	char *message; The text part of the SMTP reply.
*/

/*
**  The xxfi_eom routine is called at the end of a message (essentially,
**  after the final DATA dot). This routine can call some special routines
**  to modify the envelope, header, or body of the message before the
**  message is enqueued. These routines must not be called from any vendor
**  routine other than xxfi_eom.
*/

LIBMILTER_API int smfi_addheader __P((SMFICTX *, char *, char *));

/*
**  Add a header to the message. It is not checked for standards
**  compliance; the mail filter must ensure that no protocols are violated
**  as a result of adding this header.
**
**	SMFICTX *ctx; Opaque context structure
**	char *headerf; Header field name
**	char *headerv; Header field value
*/

LIBMILTER_API int smfi_chgheader __P((SMFICTX *, char *, int, char *));

/*
**  Change/delete a header in the message.  It is not checked for standards
**  compliance; the mail filter must ensure that no protocols are violated
**  as a result of adding this header.
**
**	SMFICTX *ctx; Opaque context structure
**	char *headerf; Header field name
**	int index; The Nth occurence of header field name
**	char *headerv; New header field value (empty for delete header)
*/

LIBMILTER_API int smfi_insheader __P((SMFICTX *, int, char *, char *));

/*
**  Insert a header into the message.  It is not checked for standards
**  compliance; the mail filter must ensure that no protocols are violated
**  as a result of adding this header.
**
**	SMFICTX *ctx; Opaque context structure
**  	int idx; index into the header list where the insertion should happen
**	char *headerh; Header field name
**	char *headerv; Header field value
*/

LIBMILTER_API int smfi_chgfrom __P((SMFICTX *, char *, char *));

/*
**  Modify envelope sender address
**
**	SMFICTX *ctx; Opaque context structure
**	char *mail; New envelope sender address
**	char *args; ESMTP arguments
*/

LIBMILTER_API int smfi_addrcpt __P((SMFICTX *, char *));

/*
**  Add a recipient to the envelope
**
**	SMFICTX *ctx; Opaque context structure
**	char *rcpt; Recipient to be added
*/

LIBMILTER_API int smfi_addrcpt_par __P((SMFICTX *, char *, char *));

/*
**  Add a recipient to the envelope
**
**	SMFICTX *ctx; Opaque context structure
**	char *rcpt; Recipient to be added
**	char *args; ESMTP arguments
*/

LIBMILTER_API int smfi_delrcpt __P((SMFICTX *, char *));

/*
**  Send a "no-op" up to the MTA to tell it we're still alive, so long
**  milter-side operations don't time out.
**
**	SMFICTX *ctx; Opaque context structure
*/

LIBMILTER_API int smfi_progress __P((SMFICTX *));

/*
**  Delete a recipient from the envelope
**
**	SMFICTX *ctx; Opaque context structure
**	char *rcpt; Envelope recipient to be deleted. This should be in
**		exactly the form passed to xxfi_envrcpt or the address may
**		not be deleted.
*/

LIBMILTER_API int smfi_replacebody __P((SMFICTX *, unsigned char *, int));

/*
**  Replace the body of the message. This routine may be called multiple
**  times if the body is longer than convenient to send in one call. End of
**  line should be represented as Carriage-Return/Line Feed.
**
**	char *bodyp; Pointer to block of body information to insert
**	int bodylen; Length of data pointed at by bodyp
*/

/*
**  If the message is aborted (for example, if the SMTP sender sends the
**  envelope but then does a QUIT or RSET before the data is sent),
**  xxfi_abort is called. This can be used to reset state.
*/

/*
**  Quarantine an envelope
**
**	SMFICTX *ctx; Opaque context structure
**	char *reason: explanation
*/

LIBMILTER_API int smfi_quarantine __P((SMFICTX *ctx, char *reason));

/*
**  Connection-private data (specific to an SMTP connection) can be
**  allocated using the smfi_setpriv routine; routines can access private
**  data using smfi_getpriv.
*/

LIBMILTER_API int smfi_setpriv __P((SMFICTX *, void *));

/*
**  Set the private data pointer
**
**	SMFICTX *ctx; Opaque context structure
**	void *privatedata; Pointer to private data area
*/

LIBMILTER_API void *smfi_getpriv __P((SMFICTX *));

/*
**  Get the private data pointer
**
**	SMFICTX *ctx; Opaque context structure
**	void *privatedata; Pointer to private data area
*/

LIBMILTER_API int smfi_setsymlist __P((SMFICTX *, int, char *));

/*
**  Set list of symbols (macros) to receive
**
**	SMFICTX *ctx; Opaque context structure
**	int where; where in the SMTP dialogue should the macros be sent
**	char *macros; list of macros (space separated)
*/

#if _FFR_THREAD_MONITOR
LIBMILTER_API int smfi_set_max_exec_time __P((unsigned int));
#endif /* _FFR_THREAD_MONITOR */

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* ! _LIBMILTER_MFAPI_H */


text:
package de.techdev.trackr.core.pdf;

import com.itextpdf.text.DocumentException;
import org.xhtmlrenderer.pdf.ITextRenderer;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * @author Moritz Schulze
 */
public class HtmlPdfConverter {

    private ITextRenderer renderer;

    public HtmlPdfConverter() {
        renderer = new ITextRenderer();

        //This can be used to set a font?
//        ITextFontResolver fontResolver = renderer.getFontResolver();
//        ClassPathResource regular = new ClassPathResource("/META-INF/fonts/LiberationSerif-Regular.ttf");
//        fontResolver.addFont(regular.getURL().toString(), BaseFont.IDENTITY_H, true);
    }

    public byte[] renderHtmlToPdf(String htmlContent) throws PdfCreationException {
        renderer.setDocumentFromString(htmlContent);
        renderer.layout();
        byte[] pdfAsByteArray;
        try(ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            renderer.createPDF(bos);
            pdfAsByteArray = bos.toByteArray();
        } catch (DocumentException | IOException e) {
            throw new PdfCreationException(e);
        }
        return pdfAsByteArray;
    }
}


text:
.class Lcom/tencent/qrom/app/ProgressDialog$1;
.super Landroid/os/Handler;
.source "ProgressDialog.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingMethod;
    value = Lcom/tencent/qrom/app/ProgressDialog;->onCreate(Landroid/os/Bundle;)V
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x0
    name = null
.end annotation

# instance fields
.field final synthetic this$0:Lcom/tencent/qrom/app/ProgressDialog;

# direct methods
.method constructor <init>(Lcom/tencent/qrom/app/ProgressDialog;)V
    .locals 0

    .prologue
    .line 129
    iput-object p1, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    invoke-direct {p0}, Landroid/os/Handler;-><init>()V

    return-void
.end method

# virtual methods
.method public handleMessage(Landroid/os/Message;)V
    .locals 12
    .param p1, "msg"    # Landroid/os/Message;

    .prologue
    const/4 v11, 0x1

    const/4 v10, 0x0

    .line 132
    invoke-super {p0, p1}, Landroid/os/Handler;->handleMessage(Landroid/os/Message;)V

    .line 135
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgress:Landroid/widget/ProgressBar;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$000(Lcom/tencent/qrom/app/ProgressDialog;)Landroid/widget/ProgressBar;

    move-result-object v6

    invoke-virtual {v6}, Landroid/widget/ProgressBar;->getProgress()I

    move-result v4

    .line 136
    .local v4, "progress":I
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgress:Landroid/widget/ProgressBar;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$000(Lcom/tencent/qrom/app/ProgressDialog;)Landroid/widget/ProgressBar;

    move-result-object v6

    invoke-virtual {v6}, Landroid/widget/ProgressBar;->getMax()I

    move-result v1

    .line 137
    .local v1, "max":I
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressNumberFormat:Ljava/lang/String;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$100(Lcom/tencent/qrom/app/ProgressDialog;)Ljava/lang/String;

    move-result-object v6

    if-eqz v6, :cond_0

    .line 138
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressNumberFormat:Ljava/lang/String;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$100(Lcom/tencent/qrom/app/ProgressDialog;)Ljava/lang/String;

    move-result-object v0

    .line 139
    .local v0, "format":Ljava/lang/String;
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressNumber:Landroid/widget/TextView;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$200(Lcom/tencent/qrom/app/ProgressDialog;)Landroid/widget/TextView;

    move-result-object v6

    const/4 v7, 0x2

    new-array v7, v7, [Ljava/lang/Object;

    invoke-static {v4}, Ljava/lang/Integer;->valueOf(I)Ljava/lang/Integer;

    move-result-object v8

    aput-object v8, v7, v10

    invoke-static {v1}, Ljava/lang/Integer;->valueOf(I)Ljava/lang/Integer;

    move-result-object v8

    aput-object v8, v7, v11

    invoke-static {v0, v7}, Ljava/lang/String;->format(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;

    move-result-object v7

    invoke-virtual {v6, v7}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

    .line 143
    .end local v0    # "format":Ljava/lang/String;
    :goto_0
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressPercentFormat:Ljava/text/NumberFormat;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$300(Lcom/tencent/qrom/app/ProgressDialog;)Ljava/text/NumberFormat;

    move-result-object v6

    if-eqz v6, :cond_1

    .line 144
    int-to-double v6, v4

    int-to-double v8, v1

    div-double v2, v6, v8

    .line 145
    .local v2, "percent":D
    new-instance v5, Landroid/text/SpannableString;

    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressPercentFormat:Ljava/text/NumberFormat;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$300(Lcom/tencent/qrom/app/ProgressDialog;)Ljava/text/NumberFormat;

    move-result-object v6

    invoke-virtual {v6, v2, v3}, Ljava/text/NumberFormat;->format(D)Ljava/lang/String;

    move-result-object v6

    invoke-direct {v5, v6}, Landroid/text/SpannableString;-><init>(Ljava/lang/CharSequence;)V

    .line 146
    .local v5, "tmp":Landroid/text/SpannableString;
    new-instance v6, Landroid/text/style/StyleSpan;

    invoke-direct {v6, v11}, Landroid/text/style/StyleSpan;-><init>(I)V

    invoke-virtual {v5}, Landroid/text/SpannableString;->length()I

    move-result v7

    const/16 v8, 0x21

    invoke-virtual {v5, v6, v10, v7, v8}, Landroid/text/SpannableString;->setSpan(Ljava/lang/Object;III)V

    .line 148
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressPercent:Landroid/widget/TextView;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$400(Lcom/tencent/qrom/app/ProgressDialog;)Landroid/widget/TextView;

    move-result-object v6

    invoke-virtual {v6, v5}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

    .line 152
    .end local v2    # "percent":D
    .end local v5    # "tmp":Landroid/text/SpannableString;
    :goto_1
    return-void

    .line 141
    :cond_0
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressNumber:Landroid/widget/TextView;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$200(Lcom/tencent/qrom/app/ProgressDialog;)Landroid/widget/TextView;

    move-result-object v6

    const-string v7, ""

    invoke-virtual {v6, v7}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

    goto :goto_0

    .line 150
    :cond_1
    iget-object v6, p0, Lcom/tencent/qrom/app/ProgressDialog$1;->this$0:Lcom/tencent/qrom/app/ProgressDialog;

    # getter for: Lcom/tencent/qrom/app/ProgressDialog;->mProgressPercent:Landroid/widget/TextView;
    invoke-static {v6}, Lcom/tencent/qrom/app/ProgressDialog;->access$400(Lcom/tencent/qrom/app/ProgressDialog;)Landroid/widget/TextView;

    move-result-object v6

    const-string v7, ""

    invoke-virtual {v6, v7}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

    goto :goto_1
.end method


text:
FROM kbase/sdkbase2:python
MAINTAINER KBase Team
# -----------------------------------------

# RUN apt-get update
RUN pip install --upgrade pip

# Install MEGAHIT
WORKDIR /kb/module
ARG filename=MEGAHIT-1.2.9-Linux-x86_64-static
RUN cd /opt && \
  curl -L -O https://github.com/voutcn/megahit/releases/download/v1.2.9/${filename}.tar.gz && \
  tar -xvf ${filename}.tar.gz && \
  rm ${filename}.tar.gz && \
  ln -s /opt/${filename}/bin/megahit /usr/bin/megahit && \
  chmod +x /usr/bin/megahit

# copy local wrapper files, and build
COPY ./ /kb/module
RUN mkdir -p /kb/module/work
RUN chmod -R a+rw /kb/module

WORKDIR /kb/module

RUN make all

ENTRYPOINT [ "./scripts/entrypoint.sh" ]

CMD [ ]


text:
// Generated by xsd compiler for android/java
// DO NOT CHANGE!
package com.ebay.trading.api;

import java.io.Serializable;
import com.leansoft.nano.annotation.*;
import java.util.Date;

/**
 *
 * Includes the acknowledgement of date and time the auction was
 * ended due to the call to EndItem.
 *
 */
@RootElement(name = "EndItemResponse", namespace = "urn:ebay:apis:eBLBaseComponents")
public class EndItemResponseType extends AbstractResponseType implements Serializable {

    private static final long serialVersionUID = -1L;

	@Element(name = "EndTime")
	@Order(value=0)
	public Date endTime;

}