text:
<?php
namespace App\Test\TestCase\Controller;

use App\Controller\PadsController;
use App\Test\TestCase\NotejamTestCase;
use Cake\ORM\TableRegistry;

/**
 * Pads test case
 */
class PadsControllerTest extends NotejamTestCase
{

    /**
     * Fixtures
     *
     * @var array
     */
    public $fixtures = [
        'app.pads',
        'app.users',
        'app.notes'
    ];

    /**
     * Test if pad can be successfully created
     *
     * @return void
     */
    public function testCreateSuccess()
    {
        $this->signin($this->user);
        $data = ['name' => 'New pad'];
        $this->post('/pads/create', $data);
        $this->assertResponseSuccess();
        $this->assertRedirect('/pads/2');
        $this->assertEquals(
            TableRegistry::get('Pads')->get(2)->name,
            $data['name']
        );
    }

    /**
     * Test if validation works when create a pad
     *
     * @return void
     */
    public function testCreateFailRequiredFields()
    {
        $this->signin($this->user);
        $this->post('/pads/create', ['name' => '']);
        $this->assertResponseContains('This field cannot be left empty');
    }

    /**
     * Test if pad can be successfully edited
     *
     * @return void
     */
    public function testEditSuccess()
    {
        $this->signin($this->user);
        $data = ['name' => 'New pad name'];
        $this->post('/pads/1/edit', $data);
        $this->assertResponseSuccess();
        $this->assertRedirect('/pads/1');
        $this->assertEquals(
            TableRegistry::get('Pads')->get(1)->name,
            $data['name']
        );
    }

    /**
     * Test if validation works when edit a pad
     *
     * @return void
     */
    public function testEditFailRequiredFields()
    {
        $this->signin($this->user);
        $this->post('/pads/1/edit', ['name' => '']);
        $this->assertResponseContains('This field cannot be left empty');
    }

    /**
     * Test if pad cannot be edited by not an owner
     *
     * @return void
     */
    public function testEditFailNotAnOwner()
    {
        $this->signin(['id' => 2, 'email' => 'user2@example.com']);
        $data = ['name' => 'New pad name'];
        $this->post('/pads/1/edit', $data);
        $this->assertResponseError();
    }

    /**
     * Test if pad can be successfully viewed
     *
     * @return void
     */
    public function testViewSuccess()
    {
        $this->signin($this->user);
        $this->get('/pads/1');
        $this->assertResponseSuccess();
        $this->assertResponseContains('Pad (1)');
    }

    /**
     * Test if pad cannot be viewed by not an owner
     *
     * @return void
     */
    public function testViewFailNotAnOwner()
    {
        $this->signin(['id' => 2, 'email' => 'user2@example.com']);
        $this->get('/pads/1');
        $this->assertResponseError();
    }

    /**
     * Test if pad can be successfully deleted
     *
     * @return void
     */
    public function testDeleteSuccess()
    {
        $this->signin($this->user);
        $this->post('/pads/1/delete', []);
        $this->assertResponseSuccess();
        $this->assertRedirect('/');
        $this->assertEquals(
            TableRegistry::get('Pads')->find('all')->count(),
            0
        );
    }

    /**
     * Test if pad cannot be deleted by not an owner
     *
     * @return void
     */
    public function testDeleteFailNotAnOwner()
    {
        $this->signin(['id' => 2, 'email' => 'user2@example.com']);
        $this->post('/pads/1/delete', []);
        $this->assertResponseError();
    }
}


text:
""" P1 tests for Dedicating Public IP addresses
"""
#Import Local Modules
import marvin
from nose.plugins.attrib import attr
from marvin.cloudstackTestCase import *
from marvin.cloudstackAPI import *
from marvin.integration.lib.utils import *
from marvin.integration.lib.base import *
from marvin.integration.lib.common import *
import datetime

class Services:
    """Test Dedicating Public IP addresses
    """

    def __init__(self):
        self.services = {
                        "domain": {
                                   "name": "Domain",
                                   },
                        "account": {
                                    "email": "test@test.com",
                                    "firstname": "Test",
                                    "lastname": "User",
                                    "username": "test",
                                    "password": "password",
                         },
                        "gateway": "10.102.197.1",
                        "netmask": "255.255.255.0",
                        "forvirtualnetwork": "true",
                        "startip": "10.102.197.70",
                        "endip": "10.102.197.73",
                        "zoneid": "1",
                        "podid": "",
                        "vlan": "4444",
                    }

class TestDedicatePublicIPRange(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):
        cls.api_client = super(TestDedicatePublicIPRange, cls).getClsTestClient().getApiClient()
        cls.services = Services().services
        # Get Zone, Domain
        cls.domain = get_domain(cls.api_client, cls.services)
        cls.zone = get_zone(cls.api_client, cls.services)

        # Create Account
        cls.account = Account.create(
                            cls.api_client,
                            cls.services["account"],
                            domainid=cls.domain.id
                            )
        cls._cleanup = [
                        cls.account,
                        ]
        return

    @classmethod
    def tearDownClass(cls):
        try:
            # Cleanup resources used
            cleanup_resources(cls.api_client, cls._cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

    def setUp(self):
        self.apiclient = self.testClient.getApiClient()
        self.dbclient = self.testClient.getDbConnection()
        self.cleanup = []
        return

    def tearDown(self):
        try:
            # Clean up
            cleanup_resources(self.apiclient, self.cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

    @attr(tags = ["simulator", "advanced", "publiciprange", "dedicate", "release"])
    def test_dedicatePublicIpRange(self):
        """Test public IP range dedication
        """

        # Validate the following:
        # 1. Create a Public IP range
        # 2. Created IP range should be present, verify with listVlanIpRanges
        # 3. Dedicate the created IP range to user account
        # 4. Verify IP range is dedicated, verify with listVlanIpRanges
        # 5. Release the dedicated Public IP range back to the system
        # 6. Verify IP range has been released, verify with listVlanIpRanges
        # 7. Delete the Public IP range

        self.debug("Creating Public IP range")
        self.public_ip_range = PublicIpRange.create(
                                    self.api_client,
                                    self.services
                               )
        list_public_ip_range_response = PublicIpRange.list(
                                            self.apiclient,
                                            id=self.public_ip_range.vlan.id
                                        )
        self.debug(
                "Verify listPublicIpRanges response for public ip ranges: %s" \
                % self.public_ip_range.vlan.id
            )
        self.assertEqual(
                         isinstance(list_public_ip_range_response, list),
                         True,
                         "Check for list Public IP range response"
                         )
        public_ip_response = list_public_ip_range_response[0]
        self.assertEqual(
                            public_ip_response.id,
                            self.public_ip_range.vlan.id,
                            "Check public ip range response id is in listVlanIpRanges"
                        )

        self.debug("Dedicating Public IP range");
        dedicate_public_ip_range_response = PublicIpRange.dedicate(
                                                self.apiclient,
                                                self.public_ip_range.vlan.id,
                                                account=self.account.name,
                                                domainid=self.account.domainid
                                            )
        list_public_ip_range_response = PublicIpRange.list(
                                            self.apiclient,
                                            id=self.public_ip_range.vlan.id
                                        )
        public_ip_response = list_public_ip_range_response[0]
        self.assertEqual(
                            public_ip_response.account,
                            self.account.name,
                            "Check account name is in listVlanIpRanges as the account public ip range is dedicated to"
                        )

        self.debug("Releasing Public IP range");
        self.public_ip_range.release(self.apiclient)
        list_public_ip_range_response = PublicIpRange.list(
                                            self.apiclient,
                                            id=self.public_ip_range.vlan.id
                                        )
        public_ip_response = list_public_ip_range_response[0]
        self.assertEqual(
                            public_ip_response.account,
                            "system",
                            "Check account name is system account in listVlanIpRanges"
                        )

        self.debug("Deleting Public IP range");
        self.public_ip_range.delete(self.apiclient)

        return

redpajama_set_name: RedPajamaGithub


text:
import {Request, RequestHandler, Response} from 'express';

export function transformResponse(transformer: ResponseTransformer):
    RequestHandler {
  return (req: Request, res: Response, next: () => void) => {
    let ended = false;

    const chunks: Buffer[] = [];

    let _shouldTransform: boolean = null;

    // Note: this function memoizes its result.
    function shouldTransform() {
      if (_shouldTransform == null) {
        const successful = res.statusCode >= 200 && res.statusCode < 300;
        _shouldTransform =
            successful && !!transformer.shouldTransform(req, res);
      }
      return _shouldTransform;
    }

    // Cast is required because this method is overloaded, but assigning a
    // method to a variable seems to pick only one of the overload signatures.
    const _write = res.write as (
                       chunk: string|Buffer,
                       cbOrEncoding?: Function|string,
                       cb?: Function) => boolean;

    res.write = function(
        chunk: Buffer|string, cbOrEncoding?: Function|string, cb?: Function):
        boolean {
          if (ended) {
            _write.call(this, chunk, cbOrEncoding, cb);
            return false;
          }

          if (shouldTransform()) {
            const buffer = (typeof chunk === 'string') ?
                Buffer.from(chunk, cbOrEncoding as BufferEncoding) :
                chunk;
            chunks.push(buffer);
            return true;
          } else {
            return _write.call(this, chunk, cbOrEncoding, cb);
          }
        };

    // Cast is required because this method is overloaded, but assigning a
    // method to a variable seems to pick only one of the overload signatures.
    const _end = res.end as (
                     cbOrChunk: (() => void)|string|Buffer,
                     cbOrEncoding?: (() => void)|string,
                     cb?: () => void) => void;

    res.end = function(
        cbOrChunk?: (() => void)|Buffer|string,
        cbOrEncoding?: (() => void)|string,
        cb?: () => void): void {
      if (ended) {
        return;
      }
      ended = true;

      if (shouldTransform()) {
        if (Buffer.isBuffer(cbOrChunk)) {
          chunks.push(cbOrChunk);
        } else if (typeof cbOrChunk === 'string') {
          chunks.push(Buffer.from(cbOrChunk, cbOrEncoding as BufferEncoding));
        }
        const body = Buffer.concat(chunks).toString('utf8');
        let newBody = body;
        try {
          newBody = transformer.transform(req, res, body);
        } catch (e) {
          console.warn('Error', e);
        }
        // TODO(justinfagnani): re-enable setting of content-length when we know
        // why it was causing truncated files. Could be multi-byte characters.
        // Assumes single-byte code points!
        // res.setHeader('Content-Length', `${newBody.length}`);
        res.removeHeader('Content-Length');
        // TODO(aomarks) Shouldn't we call the callbacks?
        return _end.call(this, newBody);
      } else {
        return _end.call(this, cbOrChunk, cbOrEncoding, cb);
      }
    };

    next();
  };
}

export interface ResponseTransformer {
  /**
   * Returns `true` if this transformer should be invoked.
   * Transformers should only look at headers, do not call res.write().
   */
  shouldTransform(request: Request, response: Response): boolean;

  transform(request: Request, response: Response, body: string): string;
}


text:
'use strict';

angular.module('myApp.model.commitment', []).factory('CommitmentModel', ['config',
    function (config) {
        /**
         * @constructor
         *
         * @param {Number} commits
         * @param {Number} additions
         * @param {Number} deletions
         */
        function Commitment(commits, additions, deletions) {
            /**
             * @type {Number}
             */
            this.commits = commits;

            /**
             * @type {Number}
             */
            this.additions = additions;

            /**
             * @type {Number}
             */
            this.deletions = deletions;
        }

        /**
         * @returns {Number}
         */
        Commitment.prototype.points = function () {
            return this.commits +
                Math.floor(this.additions / config.commitment_average_add) +
                Math.floor(this.deletions / config.commitment_average_delete);
        };

        /**
         * @param {Commitment} commitment
         */
        Commitment.prototype.add = function (commitment) {
            this.commits += commitment.commits;
            this.additions += commitment.additions;
            this.deletions += commitment.deletions;
        };

        /**
         * @returns {Commitment}
         */
        Commitment.create = function () {
            return new Commitment(0, 0, 0);
        };

        return Commitment;
    }
]);


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.9.1"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Shopify SDK for Unity: Shopify.Unity.CommentEdge Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />

Shopify SDK for Unity

Shopify

Unity

CommentEdge

Public Member Functions |
List of all members

Shopify.Unity.CommentEdge Class Reference

An auto-generated type which holds one Comment and a cursor during pagination.
 More...

Inheritance diagram for Shopify.Unity.CommentEdge:

  <map id="Shopify.Unity.CommentEdge_map" name="Shopify.Unity.CommentEdge_map">
<area href="class_shopify_1_1_unity_1_1_s_d_k_1_1_abstract_response.html" alt="Shopify.Unity.SDK.AbstractResponse" shape="rect" coords="0,0,222,24"/>
  </map>

Public Member Functions

 	CommentEdge (Dictionary< string, object > dataJSON)

 	Accepts deserialized json data.  Will further parse passed in data.  More...

string 	cursor ()

 	A cursor for use in pagination.  More...

Comment 	node ()

 	The item at the end of CommentEdge.  More...

object 	Clone ()

Additional Inherited Members

 Protected Member Functions inherited from Shopify.Unity.SDK.AbstractResponse

T 	Get< T > (string field, string alias=null)

 Protected Attributes inherited from Shopify.Unity.SDK.AbstractResponse

Dictionary< string, object > 	Data

 Properties inherited from Shopify.Unity.SDK.AbstractResponse

Dictionary< string, object > 	DataJSON [get, protected set]

Detailed Description

An auto-generated type which holds one Comment and a cursor during pagination.

Constructor & Destructor Documentation

◆ CommentEdge()

          Shopify.Unity.CommentEdge.CommentEdge
          (
          Dictionary< string, object >
          dataJSON	)

inline

Accepts deserialized json data.  Will further parse passed in data.

Parameters

dataJSON	Deserialized JSON data for CommentEdge

Member Function Documentation

◆ cursor()

          string Shopify.Unity.CommentEdge.cursor
          (
          	)

inline

A cursor for use in pagination.

◆ node()

          Comment Shopify.Unity.CommentEdge.node
          (
          	)

inline

The item at the end of CommentEdge.

The documentation for this class was generated from the following file:

Assets/Shopify/Unity/Generated/CommentEdge.cs

<address class="footer">

</address>


text:
<!DOCTYPE html>

    <title>Reuse App</title>
    <meta charset="UTF-8"/>


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

namespace Bivi.Domaine.Results
{
    public class DemandeReservationsResult
    {
        public long PlanningID { get; set; }
        public long PersonneID { get; set; }
        public string PersonneNom { get; set; }
        public string PersonnePrenom { get; set; }
        public string PersonneEmail { get; set; }
        public string MailPlanningContenu { get; set; }
        public DateTime DateDebut { get; set; }
        public DateTime DateFin { get; set; }
        public long TypePlanningEventID { get; set; }
        public string Description { get; set; }

        public string SitePrincipal { get; set; }
        public string NombreIntervenants { get; set; }
        public string SiteAudit { get; set; }
        public string Prestation { get; set; }
        public string Activite { get; set; }
        public string Champ1 { get; set; }
        public string Champ2 { get; set; }
        public string Champ3 { get; set; }
        public string Champ4 { get; set; }
        public string Champ5 { get; set; }
    }
}


text:
'use strict';

let caughtError = null;

/**
 * Call a function while guarding against errors that happens within it.
 * Returns an error if it throws, otherwise null.
 *
 * @param {String} name of the guard to use for logging or debugging
 * @param {Function} func The function to invoke
 * @param {*} context The context to use when calling the function
 * @param {...*} args Arguments for function
 */
const ReactErrorUtils = {
  invokeGuardedCallback: function<A, B, C, D, E, F, Context>(
    name: string | null,
    func: (a: A, b: B, c: C, d: D, e: E, f: F) => void,
    context: Context,
    a: A,
    b: B,
    c: C,
    d: D,
    e: E,
    f: F,
  ): Error | null {
    const funcArgs = Array.prototype.slice.call(arguments, 3);
    try {
      func.apply(context, funcArgs);
    } catch (error) {
      return error;
    }
    return null;
  },

  /**
   * Same as invokeGuardedCallback, but instead of returning an error, it stores
   * it in a global so it can be rethrown by `rethrowCaughtError` later.
   *
   * @param {String} name of the guard to use for logging or debugging
   * @param {Function} func The function to invoke
   * @param {*} context The context to use when calling the function
   * @param {...*} args Arguments for function
   */
  invokeGuardedCallbackAndCatchFirstError: function<A, B, C, D, E, F, Context>(
    name: string | null,
    func: (a: A, b: B, c: C, d: D, e: E, f: F) => void,
    context: Context,
    a: A,
    b: B,
    c: C,
    d: D,
    e: E,
    f: F,
  ): void {
    const error = ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);
    if (error !== null && caughtError === null) {
      caughtError = error;
    }
  },

  /**
   * During execution of guarded functions we will capture the first error which
   * we will rethrow to be handled by the top level error handler.
   */
  rethrowCaughtError: function() {
    if (caughtError) {
      const error = caughtError;
      caughtError = null;
      throw error;
    }
  },
};

if (__DEV__) {
  /**
   * To help development we can get better devtools integration by simulating a
   * real browser event.
   */
  if (
    typeof window !== 'undefined' &&
    typeof window.dispatchEvent === 'function' &&
    typeof document !== 'undefined' &&
    typeof document.createEvent === 'function'
  ) {
    const fakeNode = document.createElement('react');
    let depth = 0;

    ReactErrorUtils.invokeGuardedCallback = function(
      name,
      func,
      context,
      a,
      b,
      c,
      d,
      e,
      f,
    ) {
      depth++;
      const thisDepth = depth;
      const funcArgs = Array.prototype.slice.call(arguments, 3);
      const boundFunc = function() {
        func.apply(context, funcArgs);
      };
      let fakeEventError = null;
      const onFakeEventError = function(event) {
        // Don't capture nested errors
        if (depth === thisDepth) {
          fakeEventError = event.error;
        }
      };
      const evtType = `react-${name ? name : 'invokeguardedcallback'}-${depth}`;
      window.addEventListener('error', onFakeEventError);
      fakeNode.addEventListener(evtType, boundFunc, false);
      const evt = document.createEvent('Event');
      evt.initEvent(evtType, false, false);
      fakeNode.dispatchEvent(evt);
      fakeNode.removeEventListener(evtType, boundFunc, false);
      window.removeEventListener('error', onFakeEventError);
      depth--;
      return fakeEventError;
    };
  }
}

module.exports = ReactErrorUtils;


text:
package com.vmware.vim25;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for NumPortsProfile complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="NumPortsProfile">
 *   <complexContent>
 *     <extension base="{urn:vim25}ApplyProfile">
 *       <sequence>
 *       </sequence>
 *     </extension>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "NumPortsProfile")
public class NumPortsProfile
    extends ApplyProfile
{

}


text:
package org.innovateuk.ifs.questionnaire.link.service;

import org.innovateuk.ifs.commons.service.ServiceResult;
import org.innovateuk.ifs.questionnaire.resource.QuestionnaireLinkResource;
import org.springframework.security.access.prepost.PreAuthorize;

import java.util.UUID;

public interface QuestionnaireResponseLinkService {

    @PreAuthorize("hasPermission(#applicationId, 'org.innovateuk.ifs.application.resource.ApplicationResource', 'READ')")
    ServiceResult<UUID> getResponseIdByApplicationIdAndOrganisationIdAndQuestionnaireId(long applicationId, long organisationId, long questionnaireId);

    @PreAuthorize("hasPermission(#questionnaireResponseId, 'org.innovateuk.ifs.questionnaire.resource.QuestionnaireResponseResource', 'READ')")
    ServiceResult<QuestionnaireLinkResource> get(UUID questionnaireResponseId);

    @PreAuthorize("hasPermission(#projectId, 'org.innovateuk.ifs.project.resource.ProjectResource', 'READ')")
    ServiceResult<UUID> getResponseIdByProjectIdAndOrganisationIdAndQuestionnaireId(long projectId, long organisationId, long questionnaireId);
}


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

			<title>Docs For Class OAuthServer</title>
			<link rel="stylesheet" href="../media/stylesheet.css" />
			<meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1'/>

Class OAuthServer

Description

					Description |
													Vars (details)
						|											Methods (details)

			Located in /adwords/src/third_party/oauth/OAuth.php (line 496)

Variable Summary

			Description |
						Vars (details)
							|
									Methods (details)

					mixed
					$data_store

					mixed
					$signature_methods

					mixed
					$timestamp_threshold

					mixed
					$version

Method Summary

			Description |
																		Vars (details)

				|
						Methods (details)

											OAuthServer
										__construct
											( $data_store)

											void
										add_signature_method
											( $signature_method)

											void
										fetch_access_token
											( &$request)

											void
										fetch_request_token
											( &$request)

											void
										verify_request
											( &$request)

Variables

			Description |
										Vars (details)

										|
									Methods (details)

			mixed
			$data_store
						(line 501)

access: protected

			mixed
			$signature_methods
			 = array()			(line 499)

access: protected

			mixed
			$timestamp_threshold
			 =  300			(line 497)

access: protected

			mixed
			$version
			 =  '1.0'			(line 498)

access: protected

Methods

			Description |
															Vars (details)
																	Methods (details)

		Constructor __construct (line 503)

		OAuthServer

			__construct

					( $data_store)

				$data_store

		add_signature_method (line 507)

access: public

		void

			add_signature_method

					( $signature_method)

				$signature_method

		fetch_access_token (line 539)

process an access_token request

returns the access token on success

access: public

		void

			fetch_access_token

					( &$request)

				&$request

		fetch_request_token (line 518)

process a request_token request

returns the request token on success

access: public

		void

			fetch_request_token

					( &$request)

				&$request

		verify_request (line 559)

verify an api call, checks all the parameters

access: public

		void

			verify_request

					( &$request)

				&$request

		Documentation generated by phpDocumentor 1.4.4


text:
package resources

import "github.com/awslabs/goformation/cloudformation/policies"

// AWSIoTAnalyticsPipeline_Lambda AWS CloudFormation Resource (AWS::IoTAnalytics::Pipeline.Lambda)
// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-lambda.html
type AWSIoTAnalyticsPipeline_Lambda struct {

	// BatchSize AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-lambda.html#cfn-iotanalytics-pipeline-lambda-batchsize
	BatchSize int `json:"BatchSize,omitempty"`

	// LambdaName AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-lambda.html#cfn-iotanalytics-pipeline-lambda-lambdaname
	LambdaName string `json:"LambdaName,omitempty"`

	// Name AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-lambda.html#cfn-iotanalytics-pipeline-lambda-name
	Name string `json:"Name,omitempty"`

	// Next AWS CloudFormation Property
	// Required: false
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-lambda.html#cfn-iotanalytics-pipeline-lambda-next
	Next string `json:"Next,omitempty"`

	// _deletionPolicy represents a CloudFormation DeletionPolicy
	_deletionPolicy policies.DeletionPolicy

	// _dependsOn stores the logical ID of the resources to be created before this resource
	_dependsOn []string

	// _metadata stores structured data associated with this resource
	_metadata map[string]interface{}
}

// AWSCloudFormationType returns the AWS CloudFormation resource type
func (r *AWSIoTAnalyticsPipeline_Lambda) AWSCloudFormationType() string {
	return "AWS::IoTAnalytics::Pipeline.Lambda"
}

// DependsOn returns a slice of logical ID names this resource depends on.
// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html
func (r *AWSIoTAnalyticsPipeline_Lambda) DependsOn() []string {
	return r._dependsOn
}

// SetDependsOn specify that the creation of this resource follows another.
// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html
func (r *AWSIoTAnalyticsPipeline_Lambda) SetDependsOn(dependencies []string) {
	r._dependsOn = dependencies
}

// Metadata returns the metadata associated with this resource.
// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-metadata.html
func (r *AWSIoTAnalyticsPipeline_Lambda) Metadata() map[string]interface{} {
	return r._metadata
}

// SetMetadata enables you to associate structured data with this resource.
// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-metadata.html
func (r *AWSIoTAnalyticsPipeline_Lambda) SetMetadata(metadata map[string]interface{}) {
	r._metadata = metadata
}

// SetDeletionPolicy applies an AWS CloudFormation DeletionPolicy to this resource
// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html
func (r *AWSIoTAnalyticsPipeline_Lambda) SetDeletionPolicy(policy policies.DeletionPolicy) {
	r._deletionPolicy = policy
}


text:
namespace Google.Cloud.PubSub.V1.Snippets
{
    // [START pubsub_v1_generated_SchemaService_GetSchema_async_flattened_resourceNames]
    using Google.Cloud.PubSub.V1;
    using System.Threading.Tasks;

    public sealed partial class GeneratedSchemaServiceClientSnippets
    {
        /// <summary>Snippet for GetSchemaAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public async Task GetSchemaResourceNamesAsync()
        {
            // Create client
            SchemaServiceClient schemaServiceClient = await SchemaServiceClient.CreateAsync();
            // Initialize request argument(s)
            SchemaName name = SchemaName.FromProjectSchema("[PROJECT]", "[SCHEMA]");
            // Make the request
            Schema response = await schemaServiceClient.GetSchemaAsync(name);
        }
    }
    // [END pubsub_v1_generated_SchemaService_GetSchema_async_flattened_resourceNames]
}


text:
using System;
using System.IO;
using System.Linq;
using BooliStat.Code;

namespace BooliStat
{
    public static class Start
    {
        [STAThread]
        public static void Main(string[] args)
        {
            var callerId = args[0];
            var privateKey = args[1];
            var file = args[2];
            var area = args[3];
            var rooms = int.Parse(args[4]);

            var fetchSoldApartments =
                new FetchSoldApartments(new ResultFetcher(new FetchSettings(callerId, privateKey, area, 500, rooms)));
            var createMedianPrices = new CreateMedianPrices();
            var result = createMedianPrices.Execute(new DateTime(2010,1,1), fetchSoldApartments.Execute());

            var output = result.Select(item => $"{item.Key:d}, {item.Value}");
            File.WriteAllLines(file, output);
        }
    }
}