text:
// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.

package model

import (
	"fmt"
	"io"
	"strconv"
)

type OfficeCreate struct {
	OfficeCode   string  `json:"officeCode"`
	City         string  `json:"city"`
	Phone        string  `json:"phone"`
	AddressLine1 string  `json:"addressLine1"`
	AddressLine2 *string `json:"addressLine2"`
	State        *string `json:"state"`
	Country      string  `json:"country"`
	PostalCode   string  `json:"postalCode"`
	Territory    string  `json:"territory"`
}

type OfficeUpdate struct {
	OfficeCode   *string `json:"officeCode"`
	City         *string `json:"city"`
	Phone        *string `json:"phone"`
	AddressLine1 *string `json:"addressLine1"`
	AddressLine2 *string `json:"addressLine2"`
	State        *string `json:"state"`
	Country      *string `json:"country"`
	PostalCode   *string `json:"postalCode"`
	Territory    *string `json:"territory"`
}

type Role string

const (
	RoleAdmin Role = "ADMIN"
	RoleUser  Role = "USER"
)

var AllRole = []Role{
	RoleAdmin,
	RoleUser,
}

func (e Role) IsValid() bool {
	switch e {
	case RoleAdmin, RoleUser:
		return true
	}
	return false
}

func (e Role) String() string {
	return string(e)
}

func (e *Role) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("enums must be strings")
	}

	*e = Role(str)
	if !e.IsValid() {
		return fmt.Errorf("%s is not a valid Role", str)
	}
	return nil
}

func (e Role) MarshalGQL(w io.Writer) {
	fmt.Fprint(w, strconv.Quote(e.String()))
}

repository: GrassShrimp/gqlgen-gorm-example

repo_name: GrassShrimp/gqlgen-gorm-example


text:
/*
Copyright 2019 The Skaffold Authors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package initializer

import (
	"testing"

	"github.com/GoogleContainerTools/skaffold/testutil"
)

func TestIsSkaffoldConfig(t *testing.T) {
	tests := []struct {
		description string
		contents    string
		isValid     bool
	}{
		{
			description: "valid skaffold config",
			contents: `apiVersion: skaffold/v1beta6
kind: Config
deploy:
  kustomize: {}`,
			isValid: true,
		},
		{
			description: "not a valid format",
			contents:    "test",
			isValid:     false,
		},
		{
			description: "invalid skaffold config version",
			contents: `apiVersion: skaffold/v2beta1
kind: Config
deploy:
  kustomize: {}`,
			isValid: false,
		},
	}
	for _, test := range tests {
		testutil.Run(t, test.description, func(t *testutil.T) {
			tmpDir := t.NewTempDir().
				Write("skaffold.yaml", test.contents)

			isValid := IsSkaffoldConfig(tmpDir.Path("skaffold.yaml"))

			t.CheckDeepEqual(test.isValid, isValid)
		})
	}
}

repository: bookmoons/skaffold

license_type: permissive

repo_name: bookmoons/skaffold

branch_name: refs/heads/master

extension: go


text:
DESCRIPTION = "The Compute Library contains a comprehensive collection of \
software functions implemented for the Arm Cortex-A family of CPU \
processors and the Arm Mali family of GPUs. It is a convenient repository \
of low-level optimized functions that developers can source individually \
or use as part of complex pipelines in order to accelerate their algorithms \
and applications."
SUMMARY = "Arm Compute Library"
HOMEPAGE = "https://developer.arm.com/technologies/compute-library"
DESCRIPTION = "Arm Compute Library"
LICENSE = "MIT"

LIC_FILES_CHKSUM = "file://LICENSE;md5=9598101cf48c5f479cfda9f3fc6fc566"

# Tag v21.05
SRCREV = "f7399fd616cc8ccedfae668da3023e589a7ef558"

SRC_URI = " \
	git://github.com/ARM-software/ComputeLibrary.git \
	file://0001-Add-support-for-building-arm-and-aarch64-CL-with-Sco.patch \
	file://0001-Add-code-to-detect-Mali-TM-G31.patch \
"

COMPATIBLE_MACHINE = "(hihope-rzg2h|hihope-rzg2m|hihope-rzg2n|ek874|smarc-rzg2l|smarc-rzg2lc)"

S = "${WORKDIR}/git"

PR = "r0"

inherit scons

OESCONS_COMMON_FLAG = " extra_cxx_flags="${TOOLCHAIN_OPTIONS}" benchmark_tests=1 \
			validation_tests=0 neon=1 openmp=1 opencl=0 set_soname=1"

EXTRA_OESCONS_aarch64 = "arch=arm64-v8a${OESCONS_COMMON_FLAG}"

# Override the platform generic opencl flag for the RZ/G2L
OESCONS_COMMON_FLAG_append_smarc-rzg2l  = " opencl=1 embed_kernels=1"
OESCONS_COMMON_FLAG_append_smarc-rzg2lc = " opencl=1 embed_kernels=1"

do_install() {
	CP_ARGS="-Prf --preserve=mode,timestamps --no-preserve=ownership"

	install -d ${D}${libdir}
	for lib in ${S}/build/*.so*
	do
		cp $CP_ARGS $lib ${D}${libdir}
	done

	for lib in ${S}/build/*.a
	do
		cp $CP_ARGS $lib ${D}${libdir}
	done

	install -d ${D}${datadir}/${BPN}

	cp $CP_ARGS ${S}/arm_compute ${D}${datadir}/${BPN}/.
	cp $CP_ARGS ${S}/include ${D}${datadir}/${BPN}/.
	cp $CP_ARGS ${S}/support ${D}${datadir}/${BPN}/.
}

FILES_${PN} = "${libdir}/libarm_compute_core.so.23.0.0 \
               ${libdir}/libarm_compute_graph.so.23.0.0 \
               ${libdir}/libarm_compute.so.23.0.0 \
"

#Symlink .so files should go into the -dev package
FILES_${PN}-dev = "${datadir}/arm-compute-library \
                   ${libdir}/libarm_compute_graph.so.23 \
                   ${libdir}/libarm_compute.so.23 \
                   ${libdir}/libarm_compute.so \
                   ${libdir}/libarm_compute_core.so.23 \
                   ${libdir}/libarm_compute_core.so \
                   ${libdir}/libarm_compute_graph.so \
"

FILES_${PN}-dbg = "${libdir}/.debug"

FILES_${PN}-staticdev = "${libdir}/*.a"

INSANE_SKIP_${PN}-dev = "ldflags"

INSANE_SKIP_${PN} = "ldflags"

license: MIT

repository: patersonc/meta-renesas-ai

repo_name: patersonc/meta-renesas-ai

gha_license_id: MIT

extension: bb


text:
package main

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"sync"
)

var gopath string

var libs = []string{
	"github.com/kardianos/govendor",
	"bitbucket.org/liamstask/goose/cmd/goose",
	"gopkg.in/yaml.v2",
}

func main() {
	gopath = os.Getenv("GOPATH")
	os.Chdir(filepath.Join(gopath, "src/gozen"))

	goget(libs)
}

func goget(libs []string) {
	var wg sync.WaitGroup
	for _, lib := range libs {
		wg.Add(1)
		go func(lib string) {
			defer wg.Done()
			cmd := exec.Command("go", "get", lib)
			fmt.Println("Run", cmd.Args)
			err := cmd.Run()
			if err != nil {
				log.Fatal(err)
			}
			fmt.Println("Done", cmd.Args)
		}(lib)
	}
	wg.Wait()
}

repository: techvein/gozen

repo_name: techvein/gozen

gha_language: Go


text:
file(REMOVE_RECURSE
  "CMakeFiles/NumberOfBoomerangs.dir/main.cpp.o"
  "NumberOfBoomerangs.pdb"
  "NumberOfBoomerangs"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/NumberOfBoomerangs.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

extension: cmake


text:
file(REMOVE_RECURSE
  "CMakeFiles/test_fixtures.dir/test_fixtures.c.o"
  "test_fixtures.pdb"
  "test_fixtures"
)

# Per-language clean rules from dependency scanning.
foreach(lang C)
  include(CMakeFiles/test_fixtures.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

repository: pmaroti/unitTestExampleC

repo_name: pmaroti/unitTestExampleC


text:
package dhcpv6

import (
	"testing"

	"github.com/insomniacslk/dhcp/dhcpv6"
)

func validator(_, _ dhcpv6.DHCPv6) error {
	return nil
}

func TestExecutorTypeCheck(t *testing.T) {
	executor := CreateExecutor(nil, validator)
	_, err := executor(0, 42)
	if err == nil || err.Error() != "invalid request type int, want: *dhcpv6.Message" {
		t.Errorf("Expected executor to fail with invalid request type error, got (%s)", err)
	}
}

repository: earlgreyz/bender

repo_name: earlgreyz/bender


text:
package main

import "fmt"
import "strings"
import "strconv"

import "github.com/ory/ladon"
import "github.com/satori/go.uuid"
import manager "github.com/ory/ladon/manager/memory"

// Fake db data

// DBUser mocks a row in a user database table
type DBUser struct {
	ID   int
	Name string
}

// DBSquad mocks a row in a squad database table. A squad is a group which
// multiple users can access.
type DBSquad struct {
	ID   int
	Name string
}

// DBSquadMembership mocks a row in a squad membership table. Marks that a user
// is part of a squad.
type DBSquadMembership struct {
	ID      int
	SquadID int
	UserID  int
}

// users mocks a users database
var users = []DBUser{
	DBUser{0, "Foo"},
	DBUser{1, "Bar"},
	DBUser{2, "Bazz"},
}

// squads mocks a squad database
var squads = []DBSquad{
	DBSquad{0, "All Squad"},
	DBSquad{1, "Exclusive Squad"},
}

// squadMemberships mocks a squad membership database
var squadMemberships = []DBSquadMembership{
	DBSquadMembership{0, 0, 0}, // user:Foo -> squad:All Squad
	DBSquadMembership{1, 0, 1}, // user:Bar -> squad:All Squad
	DBSquadMembership{2, 0, 2}, // user:Bazz -> squad:All Squad
	DBSquadMembership{3, 1, 0}, // user:Foo -> squad:Exclusive Squad
	DBSquadMembership{4, 1, 1}, // user:Bar -> squad:Exclusive Squad
}

// Permission conditions
// extractURIID parses a URI for a resource ID.
func extract_uri_id(uri string) (int, error) {
	parts := strings.Split(uri, ":")

	if len(parts) != 3 {
		return -1, fmt.Errorf("uri does not contain 3 parts, "+
			"uri: \"%s\"", uri)
	}

	if parts[0] != "model" {
		return -1, fmt.Errorf("uri is not for a model, "+
			"uri: \"%s\"", uri)
	}

	id, err := strconv.Atoi(parts[2])
	if err != nil {
		return -1, fmt.Errorf("error converting third part of uri "+
			"to int, uri: \"%s\", error: %s", uri, err.Error())
	}

	return id, nil
}

// SelfCondition ensures that the subject of a request matches the resource
// being accessed.
type SelfCondition struct{}

func (c SelfCondition) GetName() string {
	return "SelfCondition"
}

func (c SelfCondition) Fulfills(_ interface{}, req *ladon.Request) bool {
	fmt.Printf("%s == %s\n", req.Subject, req.Resource)
	return req.Subject == req.Resource
}

// SquadMemberCondition ensures the subject is a member of the squad in a
// request.
type SquadMemberCondition struct{}

func (c SquadMemberCondition) GetName() string {
	return "SquadMemberCondition"
}

func (c SquadMemberCondition) Fulfills(_ interface{}, req *ladon.Request) bool {
	userID, err := extract_uri_id(req.Subject)
	if err != nil {
		fmt.Printf("SquadMemberCondition error extracting user id: %s\n",
			err.Error())
		return false
	}

	squadID, err := extract_uri_id(req.Resource)
	if err != nil {
		fmt.Printf("SquadMemberCondition error extracting squad id: %s\n",
			err.Error())
		return false
	}

	for _, membership := range squadMemberships {
		if membership.SquadID == squadID && membership.UserID == userID {
			return true
		}
	}

	return false
}

// test_request submits a request to a Ladon Warden and prints the result
func test_request(name string, warden *ladon.Ladon, req *ladon.Request,
	shouldFail bool) {

	fmt.Printf("Testing: \"%s\"\n", name)

	err := warden.IsAllowed(req)

	if shouldFail {
		if err == nil {
			fmt.Println("    BAD: Did not fail")
		} else {
			fmt.Printf("    OK: Failed with: \"%s\"\n", err.Error())
		}
	} else {
		if err == nil {
			fmt.Println("    OK")
		} else {
			fmt.Printf("    BAD: Failed with: \"%s\"\n", err.Error())
		}
	}
}

func main() {
	// Create warden
	warden := &ladon.Ladon{
		Manager: manager.NewMemoryManager(),
	}

	// Define policies
	policies := []ladon.DefaultPolicy{
		ladon.DefaultPolicy{
			ID:          uuid.NewV4().String(),
			Description: "Only user can update their profile",
			Subjects:    []string{"model:user:<.*>"},
			Resources:   []string{"model:user:<.*>"},
			Actions:     []string{"service:user:set"},
			Effect:      ladon.AllowAccess,
			Conditions: ladon.Conditions{
				"self": SelfCondition{},
			},
		},
		ladon.DefaultPolicy{
			ID:          uuid.NewV4().String(),
			Description: "Only squad members can view squad info",
			Subjects:    []string{"model:user:<.*>"},
			Resources:   []string{"model:squad:<.*>"},
			Actions:     []string{"service:squad:get"},
			Effect:      ladon.AllowAccess,
			Conditions: ladon.Conditions{
				"member": SquadMemberCondition{},
			},
		},
	}

	for _, policy := range policies {
		err := warden.Manager.Create(&policy)
		if err != nil {
			fmt.Printf("error creating \"%s\" policy: %s\n",
				policy.Description, err.Error())
			return
		}
		fmt.Printf("Loaded %s policy\n", policy.ID)
	}

	// Test access
	// TODO: Figure out why user policy tests break when squad policy was added
	test_request("self allowed service:user:set", warden, &ladon.Request{
		Subject:  "model:user:0",
		Action:   "service:user:set",
		Resource: "model:user:0",
		Context:  ladon.Context{},
	}, false)

	test_request("other not allowed service:user:set", warden, &ladon.Request{
		Subject:  "model:user:1",
		Action:   "service:user:set",
		Resource: "model:user:0",
		Context:  ladon.Context{},
	}, true)

	test_request("members allowed service:squad:get", warden, &ladon.Request{
		Subject:  "model:user:0",
		Action:   "service:squad:get",
		Resource: "model:squad:1",
		Context:  ladon.Context{},
	}, false)

	test_request("non members not allowed service:squad:get", warden, &ladon.Request{
		Subject:  "model:user:2",
		Action:   "service:squad:get",
		Resource: "model:squad:1",
		Context:  ladon.Context{},
	}, true)
}

repository: Noah-Huppert/hello-rbac

repo_name: Noah-Huppert/hello-rbac


text:
package mem

import (
	"bytes"
	"context"
	"io/ioutil"
	"testing"

	"github.com/stretchr/testify/suite"
)

const (
	module  = "testmodule"
	version = "v1.0.0"
)

var (
	// TODO: put these values inside of the suite, and generate longer values.
	// This should help catch edge cases, like https://github.com/gomods/athens/issues/38
	//
	// Also, consider doing something similar to what testing/quick does
	// with the Generator interface (https://godoc.org/testing/quick#Generator).
	// The rough, simplified idea would be to run a single test case multiple
	// times over different (increasing) values.
	mod  = []byte("123")
	zip  = []byte("456")
	info = []byte("789")
)

type MemTests struct {
	suite.Suite
}

func TestMemStorage(t *testing.T) {
	suite.Run(t, new(MemTests))
}

func (d *MemTests) TestGetSaveListRoundTrip() {
	r := d.Require()
	// create new in mem storage
	storage, err := NewStorage()
	d.Require().NoError(err)

	// save and list modules
	r.NoError(storage.Save(context.Background(), module, version, mod, bytes.NewReader(zip), info))
	listedVersions, err := storage.List(module)
	r.NoError(err)
	r.Equal(1, len(listedVersions))
	retVersion := listedVersions[0]
	r.Equal(version, retVersion)

	// create new in-mem storage - we should be able to get the saved module
	storage, err = NewStorage()
	d.Require().NoError(err)

	gotten, err := storage.Get(module, version)
	r.NoError(err)
	defer gotten.Zip.Close()
	// TODO: test the time
	r.Equal(gotten.Mod, mod)
	zipContent, err := ioutil.ReadAll(gotten.Zip)
	r.NoError(err)
	r.Equal(zipContent, zip)
	r.Equal(gotten.Info, info)
}

repository: marwan-at-work/athens

repo_name: marwan-at-work/athens


text:
package blueaccount

import (
	"regexp"
	"strings"

	weave "github.com/iov-one/weave"
	"github.com/iov-one/weave/errors"
	"github.com/iov-one/weave/migration"
	"github.com/iov-one/weave/orm"
)

func init() {
	migration.MustRegister(1, &Account{}, migration.NoModification)
	migration.MustRegister(1, &Domain{}, migration.NoModification)
}

var _ orm.Model = (*Account)(nil)

func (a *Account) Validate() error {
	var errs error
	errs = errors.AppendField(errs, "Metadata", a.Metadata.Validate())
	errs = errors.AppendField(errs, "Domain", validateDomain(a.Domain))
	if len(a.Owner) != 0 {
		errs = errors.AppendField(errs, "Owner", a.Owner.Validate())
	}
	errs = errors.AppendField(errs, "Targets", validateTargets(a.Targets))
	return errs
}

func NewAccountBucket() orm.ModelBucket {
	b := orm.NewModelBucket("account", &Account{})
	return migration.NewModelBucket("blueaccount", b)
}

// accountKey returns a bucket wide unique account key.
//
// Key starts with the domain name which allows for iteration over accounts by
// the domain they belong to.
func accountKey(name, domain string) []byte {
	key := make([]byte, 0, len(name)+len(domain)+1)
	key = append(key, domain...)
	key = append(key, '*')
	key = append(key, name...)
	return key
}

var _ orm.Model = (*Domain)(nil)

func (d *Domain) Validate() error {
	var errs error
	errs = errors.AppendField(errs, "Metadata", d.Metadata.Validate())
	errs = errors.AppendField(errs, "Domain", validateDomain(d.Domain))
	errs = errors.AppendField(errs, "Owner", d.Owner.Validate())
	errs = errors.AppendField(errs, "ValidUntil", d.ValidUntil.Validate())
	return errs
}

func NewDomainBucket() orm.ModelBucket {
	b := orm.NewModelBucket("domain", &Domain{})
	return migration.NewModelBucket("blueaccount", b)
}

// DomainAccounts returns an iterator through all account that belong to a
// given domain.
// It is the client responsibility to releast the iterator.
func DomainAccounts(db weave.ReadOnlyKVStore, domain string) (weave.Iterator, error) {
	// This implementation relies on account keys being constructed by
	// including the domain first (see accountKey function). This allows to
	// iterate over keys using database native iteration mechanism instead
	// of secondary index.
	const bucketPrefix = "account:"
	start := append([]byte(bucketPrefix + domain)) //, '*'-1)
	end := append([]byte(bucketPrefix+domain), '*'+1)
	return db.Iterator(start, end)
}

// itemKeys returns list all item keys that give iterator represents.
//
// This function consumes and releases given iterator, collecting all keys it
// returns. This functionality is helpful when the intention is to access
// database for every key. Because iterator is using gorutines to read data,
// accessing database while reading an iterator will cause a data race.
func itemKeys(it weave.Iterator, err error) ([][]byte, error) {
	if err != nil {
		return nil, err
	}
	defer it.Release()

	var keys [][]byte
	for {
		switch k, _, err := it.Next(); {
		case err == nil:
			keys = append(keys, k)
		case errors.ErrIteratorDone.Is(err):
			return keys, nil
		default:
			return keys, err
		}
	}
}

func (ba *BlockchainAddress) Validate() error {
	if !validBlockchainID(ba.BlockchainID) {
		return errors.Wrap(errors.ErrInput, "invalid blockchain ID")
	}
	switch n := len(ba.Address); {
	case n == 0:
		return errors.Wrap(errors.ErrInput, "address is required")
	case n > addressMaxLen:
		return errors.Wrap(errors.ErrInput, "address too long")
	}
	return nil
}

var validBlockchainID = regexp.MustCompile(`^[a-zA-Z0-9_.-]{4,32}$`).MatchString

const addressMaxLen = 128

// validateTargets returns an error if given list of blockchain addresses is
// not a valid target state. This function ensures the business logic is
// respected.
func validateTargets(targets []BlockchainAddress) error {
	for i, t := range targets {
		if err := t.Validate(); err != nil {
			return errors.Wrapf(err, "target #%d", i)
		}
	}
	if dups := duplicatedBlockchains(targets); len(dups) != 0 {
		return errors.Wrapf(errors.ErrDuplicate, "blokchain ID used more than once: %s",
			strings.Join(dups, ", "))
	}
	return nil
}

// duplicatedBlockchains returns the list of blockchain IDs that were used more
// than once in given list.
func duplicatedBlockchains(bas []BlockchainAddress) []string {
	if len(bas) < 2 {
		return nil
	}

	cnt := make(map[string]uint8)
	for _, ba := range bas {
		cnt[ba.BlockchainID]++
	}

	var dups []string
	for bid, n := range cnt {
		if n > 1 {
			dups = append(dups, bid)
		}
	}
	return dups
}

repository: all-forks/weave

repo_name: all-forks/weave


text:
inherit setuptools3
require python-snappy.inc

SRC_URI[md5sum] = "0c06bbed70a8390b55a60f5ee79a27d2"
SRC_URI[sha256sum] = "385fb216e7d1241f70c14c2bea3f042ec235caa65d708294f1ece50d3efa5de3"

repository: Emantor/meta-labgrid

repo_name: Emantor/meta-labgrid


text:
// Code generated by counterfeiter. DO NOT EDIT.
package fakes

import (
	sync "sync"

	cfclient "github.com/cloudfoundry-community/go-cfclient"
	organization "github.com/pivotalservices/cf-mgmt/organization"
)

type FakeManager struct {
	CreateOrgsStub        func() error
	createOrgsMutex       sync.RWMutex
	createOrgsArgsForCall []struct {
	}
	createOrgsReturns struct {
		result1 error
	}
	createOrgsReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteOrgsStub        func() error
	deleteOrgsMutex       sync.RWMutex
	deleteOrgsArgsForCall []struct {
	}
	deleteOrgsReturns struct {
		result1 error
	}
	deleteOrgsReturnsOnCall map[int]struct {
		result1 error
	}
	FindOrgStub        func(string) (cfclient.Org, error)
	findOrgMutex       sync.RWMutex
	findOrgArgsForCall []struct {
		arg1 string
	}
	findOrgReturns struct {
		result1 cfclient.Org
		result2 error
	}
	findOrgReturnsOnCall map[int]struct {
		result1 cfclient.Org
		result2 error
	}
	FindOrgByGUIDStub        func(string) (cfclient.Org, error)
	findOrgByGUIDMutex       sync.RWMutex
	findOrgByGUIDArgsForCall []struct {
		arg1 string
	}
	findOrgByGUIDReturns struct {
		result1 cfclient.Org
		result2 error
	}
	findOrgByGUIDReturnsOnCall map[int]struct {
		result1 cfclient.Org
		result2 error
	}
	GetOrgByGUIDStub        func(string) (cfclient.Org, error)
	getOrgByGUIDMutex       sync.RWMutex
	getOrgByGUIDArgsForCall []struct {
		arg1 string
	}
	getOrgByGUIDReturns struct {
		result1 cfclient.Org
		result2 error
	}
	getOrgByGUIDReturnsOnCall map[int]struct {
		result1 cfclient.Org
		result2 error
	}
	GetOrgGUIDStub        func(string) (string, error)
	getOrgGUIDMutex       sync.RWMutex
	getOrgGUIDArgsForCall []struct {
		arg1 string
	}
	getOrgGUIDReturns struct {
		result1 string
		result2 error
	}
	getOrgGUIDReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	ListOrgsStub        func() ([]cfclient.Org, error)
	listOrgsMutex       sync.RWMutex
	listOrgsArgsForCall []struct {
	}
	listOrgsReturns struct {
		result1 []cfclient.Org
		result2 error
	}
	listOrgsReturnsOnCall map[int]struct {
		result1 []cfclient.Org
		result2 error
	}
	RenameOrgStub        func(string, string) error
	renameOrgMutex       sync.RWMutex
	renameOrgArgsForCall []struct {
		arg1 string
		arg2 string
	}
	renameOrgReturns struct {
		result1 error
	}
	renameOrgReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateOrgStub        func(string, cfclient.OrgRequest) (cfclient.Org, error)
	updateOrgMutex       sync.RWMutex
	updateOrgArgsForCall []struct {
		arg1 string
		arg2 cfclient.OrgRequest
	}
	updateOrgReturns struct {
		result1 cfclient.Org
		result2 error
	}
	updateOrgReturnsOnCall map[int]struct {
		result1 cfclient.Org
		result2 error
	}
	UpdateOrgsMetadataStub        func() error
	updateOrgsMetadataMutex       sync.RWMutex
	updateOrgsMetadataArgsForCall []struct {
	}
	updateOrgsMetadataReturns struct {
		result1 error
	}
	updateOrgsMetadataReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeManager) CreateOrgs() error {
	fake.createOrgsMutex.Lock()
	ret, specificReturn := fake.createOrgsReturnsOnCall[len(fake.createOrgsArgsForCall)]
	fake.createOrgsArgsForCall = append(fake.createOrgsArgsForCall, struct {
	}{})
	fake.recordInvocation("CreateOrgs", []interface{}{})
	fake.createOrgsMutex.Unlock()
	if fake.CreateOrgsStub != nil {
		return fake.CreateOrgsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.createOrgsReturns
	return fakeReturns.result1
}

func (fake *FakeManager) CreateOrgsCallCount() int {
	fake.createOrgsMutex.RLock()
	defer fake.createOrgsMutex.RUnlock()
	return len(fake.createOrgsArgsForCall)
}

func (fake *FakeManager) CreateOrgsCalls(stub func() error) {
	fake.createOrgsMutex.Lock()
	defer fake.createOrgsMutex.Unlock()
	fake.CreateOrgsStub = stub
}

func (fake *FakeManager) CreateOrgsReturns(result1 error) {
	fake.createOrgsMutex.Lock()
	defer fake.createOrgsMutex.Unlock()
	fake.CreateOrgsStub = nil
	fake.createOrgsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) CreateOrgsReturnsOnCall(i int, result1 error) {
	fake.createOrgsMutex.Lock()
	defer fake.createOrgsMutex.Unlock()
	fake.CreateOrgsStub = nil
	if fake.createOrgsReturnsOnCall == nil {
		fake.createOrgsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createOrgsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) DeleteOrgs() error {
	fake.deleteOrgsMutex.Lock()
	ret, specificReturn := fake.deleteOrgsReturnsOnCall[len(fake.deleteOrgsArgsForCall)]
	fake.deleteOrgsArgsForCall = append(fake.deleteOrgsArgsForCall, struct {
	}{})
	fake.recordInvocation("DeleteOrgs", []interface{}{})
	fake.deleteOrgsMutex.Unlock()
	if fake.DeleteOrgsStub != nil {
		return fake.DeleteOrgsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.deleteOrgsReturns
	return fakeReturns.result1
}

func (fake *FakeManager) DeleteOrgsCallCount() int {
	fake.deleteOrgsMutex.RLock()
	defer fake.deleteOrgsMutex.RUnlock()
	return len(fake.deleteOrgsArgsForCall)
}

func (fake *FakeManager) DeleteOrgsCalls(stub func() error) {
	fake.deleteOrgsMutex.Lock()
	defer fake.deleteOrgsMutex.Unlock()
	fake.DeleteOrgsStub = stub
}

func (fake *FakeManager) DeleteOrgsReturns(result1 error) {
	fake.deleteOrgsMutex.Lock()
	defer fake.deleteOrgsMutex.Unlock()
	fake.DeleteOrgsStub = nil
	fake.deleteOrgsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) DeleteOrgsReturnsOnCall(i int, result1 error) {
	fake.deleteOrgsMutex.Lock()
	defer fake.deleteOrgsMutex.Unlock()
	fake.DeleteOrgsStub = nil
	if fake.deleteOrgsReturnsOnCall == nil {
		fake.deleteOrgsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteOrgsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) FindOrg(arg1 string) (cfclient.Org, error) {
	fake.findOrgMutex.Lock()
	ret, specificReturn := fake.findOrgReturnsOnCall[len(fake.findOrgArgsForCall)]
	fake.findOrgArgsForCall = append(fake.findOrgArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindOrg", []interface{}{arg1})
	fake.findOrgMutex.Unlock()
	if fake.FindOrgStub != nil {
		return fake.FindOrgStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeManager) FindOrgCallCount() int {
	fake.findOrgMutex.RLock()
	defer fake.findOrgMutex.RUnlock()
	return len(fake.findOrgArgsForCall)
}

func (fake *FakeManager) FindOrgCalls(stub func(string) (cfclient.Org, error)) {
	fake.findOrgMutex.Lock()
	defer fake.findOrgMutex.Unlock()
	fake.FindOrgStub = stub
}

func (fake *FakeManager) FindOrgArgsForCall(i int) string {
	fake.findOrgMutex.RLock()
	defer fake.findOrgMutex.RUnlock()
	argsForCall := fake.findOrgArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeManager) FindOrgReturns(result1 cfclient.Org, result2 error) {
	fake.findOrgMutex.Lock()
	defer fake.findOrgMutex.Unlock()
	fake.FindOrgStub = nil
	fake.findOrgReturns = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) FindOrgReturnsOnCall(i int, result1 cfclient.Org, result2 error) {
	fake.findOrgMutex.Lock()
	defer fake.findOrgMutex.Unlock()
	fake.FindOrgStub = nil
	if fake.findOrgReturnsOnCall == nil {
		fake.findOrgReturnsOnCall = make(map[int]struct {
			result1 cfclient.Org
			result2 error
		})
	}
	fake.findOrgReturnsOnCall[i] = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) FindOrgByGUID(arg1 string) (cfclient.Org, error) {
	fake.findOrgByGUIDMutex.Lock()
	ret, specificReturn := fake.findOrgByGUIDReturnsOnCall[len(fake.findOrgByGUIDArgsForCall)]
	fake.findOrgByGUIDArgsForCall = append(fake.findOrgByGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindOrgByGUID", []interface{}{arg1})
	fake.findOrgByGUIDMutex.Unlock()
	if fake.FindOrgByGUIDStub != nil {
		return fake.FindOrgByGUIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findOrgByGUIDReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeManager) FindOrgByGUIDCallCount() int {
	fake.findOrgByGUIDMutex.RLock()
	defer fake.findOrgByGUIDMutex.RUnlock()
	return len(fake.findOrgByGUIDArgsForCall)
}

func (fake *FakeManager) FindOrgByGUIDCalls(stub func(string) (cfclient.Org, error)) {
	fake.findOrgByGUIDMutex.Lock()
	defer fake.findOrgByGUIDMutex.Unlock()
	fake.FindOrgByGUIDStub = stub
}

func (fake *FakeManager) FindOrgByGUIDArgsForCall(i int) string {
	fake.findOrgByGUIDMutex.RLock()
	defer fake.findOrgByGUIDMutex.RUnlock()
	argsForCall := fake.findOrgByGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeManager) FindOrgByGUIDReturns(result1 cfclient.Org, result2 error) {
	fake.findOrgByGUIDMutex.Lock()
	defer fake.findOrgByGUIDMutex.Unlock()
	fake.FindOrgByGUIDStub = nil
	fake.findOrgByGUIDReturns = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) FindOrgByGUIDReturnsOnCall(i int, result1 cfclient.Org, result2 error) {
	fake.findOrgByGUIDMutex.Lock()
	defer fake.findOrgByGUIDMutex.Unlock()
	fake.FindOrgByGUIDStub = nil
	if fake.findOrgByGUIDReturnsOnCall == nil {
		fake.findOrgByGUIDReturnsOnCall = make(map[int]struct {
			result1 cfclient.Org
			result2 error
		})
	}
	fake.findOrgByGUIDReturnsOnCall[i] = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) GetOrgByGUID(arg1 string) (cfclient.Org, error) {
	fake.getOrgByGUIDMutex.Lock()
	ret, specificReturn := fake.getOrgByGUIDReturnsOnCall[len(fake.getOrgByGUIDArgsForCall)]
	fake.getOrgByGUIDArgsForCall = append(fake.getOrgByGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrgByGUID", []interface{}{arg1})
	fake.getOrgByGUIDMutex.Unlock()
	if fake.GetOrgByGUIDStub != nil {
		return fake.GetOrgByGUIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getOrgByGUIDReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeManager) GetOrgByGUIDCallCount() int {
	fake.getOrgByGUIDMutex.RLock()
	defer fake.getOrgByGUIDMutex.RUnlock()
	return len(fake.getOrgByGUIDArgsForCall)
}

func (fake *FakeManager) GetOrgByGUIDCalls(stub func(string) (cfclient.Org, error)) {
	fake.getOrgByGUIDMutex.Lock()
	defer fake.getOrgByGUIDMutex.Unlock()
	fake.GetOrgByGUIDStub = stub
}

func (fake *FakeManager) GetOrgByGUIDArgsForCall(i int) string {
	fake.getOrgByGUIDMutex.RLock()
	defer fake.getOrgByGUIDMutex.RUnlock()
	argsForCall := fake.getOrgByGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeManager) GetOrgByGUIDReturns(result1 cfclient.Org, result2 error) {
	fake.getOrgByGUIDMutex.Lock()
	defer fake.getOrgByGUIDMutex.Unlock()
	fake.GetOrgByGUIDStub = nil
	fake.getOrgByGUIDReturns = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) GetOrgByGUIDReturnsOnCall(i int, result1 cfclient.Org, result2 error) {
	fake.getOrgByGUIDMutex.Lock()
	defer fake.getOrgByGUIDMutex.Unlock()
	fake.GetOrgByGUIDStub = nil
	if fake.getOrgByGUIDReturnsOnCall == nil {
		fake.getOrgByGUIDReturnsOnCall = make(map[int]struct {
			result1 cfclient.Org
			result2 error
		})
	}
	fake.getOrgByGUIDReturnsOnCall[i] = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) GetOrgGUID(arg1 string) (string, error) {
	fake.getOrgGUIDMutex.Lock()
	ret, specificReturn := fake.getOrgGUIDReturnsOnCall[len(fake.getOrgGUIDArgsForCall)]
	fake.getOrgGUIDArgsForCall = append(fake.getOrgGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrgGUID", []interface{}{arg1})
	fake.getOrgGUIDMutex.Unlock()
	if fake.GetOrgGUIDStub != nil {
		return fake.GetOrgGUIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getOrgGUIDReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeManager) GetOrgGUIDCallCount() int {
	fake.getOrgGUIDMutex.RLock()
	defer fake.getOrgGUIDMutex.RUnlock()
	return len(fake.getOrgGUIDArgsForCall)
}

func (fake *FakeManager) GetOrgGUIDCalls(stub func(string) (string, error)) {
	fake.getOrgGUIDMutex.Lock()
	defer fake.getOrgGUIDMutex.Unlock()
	fake.GetOrgGUIDStub = stub
}

func (fake *FakeManager) GetOrgGUIDArgsForCall(i int) string {
	fake.getOrgGUIDMutex.RLock()
	defer fake.getOrgGUIDMutex.RUnlock()
	argsForCall := fake.getOrgGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeManager) GetOrgGUIDReturns(result1 string, result2 error) {
	fake.getOrgGUIDMutex.Lock()
	defer fake.getOrgGUIDMutex.Unlock()
	fake.GetOrgGUIDStub = nil
	fake.getOrgGUIDReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) GetOrgGUIDReturnsOnCall(i int, result1 string, result2 error) {
	fake.getOrgGUIDMutex.Lock()
	defer fake.getOrgGUIDMutex.Unlock()
	fake.GetOrgGUIDStub = nil
	if fake.getOrgGUIDReturnsOnCall == nil {
		fake.getOrgGUIDReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.getOrgGUIDReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) ListOrgs() ([]cfclient.Org, error) {
	fake.listOrgsMutex.Lock()
	ret, specificReturn := fake.listOrgsReturnsOnCall[len(fake.listOrgsArgsForCall)]
	fake.listOrgsArgsForCall = append(fake.listOrgsArgsForCall, struct {
	}{})
	fake.recordInvocation("ListOrgs", []interface{}{})
	fake.listOrgsMutex.Unlock()
	if fake.ListOrgsStub != nil {
		return fake.ListOrgsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.listOrgsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeManager) ListOrgsCallCount() int {
	fake.listOrgsMutex.RLock()
	defer fake.listOrgsMutex.RUnlock()
	return len(fake.listOrgsArgsForCall)
}

func (fake *FakeManager) ListOrgsCalls(stub func() ([]cfclient.Org, error)) {
	fake.listOrgsMutex.Lock()
	defer fake.listOrgsMutex.Unlock()
	fake.ListOrgsStub = stub
}

func (fake *FakeManager) ListOrgsReturns(result1 []cfclient.Org, result2 error) {
	fake.listOrgsMutex.Lock()
	defer fake.listOrgsMutex.Unlock()
	fake.ListOrgsStub = nil
	fake.listOrgsReturns = struct {
		result1 []cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) ListOrgsReturnsOnCall(i int, result1 []cfclient.Org, result2 error) {
	fake.listOrgsMutex.Lock()
	defer fake.listOrgsMutex.Unlock()
	fake.ListOrgsStub = nil
	if fake.listOrgsReturnsOnCall == nil {
		fake.listOrgsReturnsOnCall = make(map[int]struct {
			result1 []cfclient.Org
			result2 error
		})
	}
	fake.listOrgsReturnsOnCall[i] = struct {
		result1 []cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) RenameOrg(arg1 string, arg2 string) error {
	fake.renameOrgMutex.Lock()
	ret, specificReturn := fake.renameOrgReturnsOnCall[len(fake.renameOrgArgsForCall)]
	fake.renameOrgArgsForCall = append(fake.renameOrgArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("RenameOrg", []interface{}{arg1, arg2})
	fake.renameOrgMutex.Unlock()
	if fake.RenameOrgStub != nil {
		return fake.RenameOrgStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.renameOrgReturns
	return fakeReturns.result1
}

func (fake *FakeManager) RenameOrgCallCount() int {
	fake.renameOrgMutex.RLock()
	defer fake.renameOrgMutex.RUnlock()
	return len(fake.renameOrgArgsForCall)
}

func (fake *FakeManager) RenameOrgCalls(stub func(string, string) error) {
	fake.renameOrgMutex.Lock()
	defer fake.renameOrgMutex.Unlock()
	fake.RenameOrgStub = stub
}

func (fake *FakeManager) RenameOrgArgsForCall(i int) (string, string) {
	fake.renameOrgMutex.RLock()
	defer fake.renameOrgMutex.RUnlock()
	argsForCall := fake.renameOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeManager) RenameOrgReturns(result1 error) {
	fake.renameOrgMutex.Lock()
	defer fake.renameOrgMutex.Unlock()
	fake.RenameOrgStub = nil
	fake.renameOrgReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) RenameOrgReturnsOnCall(i int, result1 error) {
	fake.renameOrgMutex.Lock()
	defer fake.renameOrgMutex.Unlock()
	fake.RenameOrgStub = nil
	if fake.renameOrgReturnsOnCall == nil {
		fake.renameOrgReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameOrgReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) UpdateOrg(arg1 string, arg2 cfclient.OrgRequest) (cfclient.Org, error) {
	fake.updateOrgMutex.Lock()
	ret, specificReturn := fake.updateOrgReturnsOnCall[len(fake.updateOrgArgsForCall)]
	fake.updateOrgArgsForCall = append(fake.updateOrgArgsForCall, struct {
		arg1 string
		arg2 cfclient.OrgRequest
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrg", []interface{}{arg1, arg2})
	fake.updateOrgMutex.Unlock()
	if fake.UpdateOrgStub != nil {
		return fake.UpdateOrgStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeManager) UpdateOrgCallCount() int {
	fake.updateOrgMutex.RLock()
	defer fake.updateOrgMutex.RUnlock()
	return len(fake.updateOrgArgsForCall)
}

func (fake *FakeManager) UpdateOrgCalls(stub func(string, cfclient.OrgRequest) (cfclient.Org, error)) {
	fake.updateOrgMutex.Lock()
	defer fake.updateOrgMutex.Unlock()
	fake.UpdateOrgStub = stub
}

func (fake *FakeManager) UpdateOrgArgsForCall(i int) (string, cfclient.OrgRequest) {
	fake.updateOrgMutex.RLock()
	defer fake.updateOrgMutex.RUnlock()
	argsForCall := fake.updateOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeManager) UpdateOrgReturns(result1 cfclient.Org, result2 error) {
	fake.updateOrgMutex.Lock()
	defer fake.updateOrgMutex.Unlock()
	fake.UpdateOrgStub = nil
	fake.updateOrgReturns = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) UpdateOrgReturnsOnCall(i int, result1 cfclient.Org, result2 error) {
	fake.updateOrgMutex.Lock()
	defer fake.updateOrgMutex.Unlock()
	fake.UpdateOrgStub = nil
	if fake.updateOrgReturnsOnCall == nil {
		fake.updateOrgReturnsOnCall = make(map[int]struct {
			result1 cfclient.Org
			result2 error
		})
	}
	fake.updateOrgReturnsOnCall[i] = struct {
		result1 cfclient.Org
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) UpdateOrgsMetadata() error {
	fake.updateOrgsMetadataMutex.Lock()
	ret, specificReturn := fake.updateOrgsMetadataReturnsOnCall[len(fake.updateOrgsMetadataArgsForCall)]
	fake.updateOrgsMetadataArgsForCall = append(fake.updateOrgsMetadataArgsForCall, struct {
	}{})
	fake.recordInvocation("UpdateOrgsMetadata", []interface{}{})
	fake.updateOrgsMetadataMutex.Unlock()
	if fake.UpdateOrgsMetadataStub != nil {
		return fake.UpdateOrgsMetadataStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.updateOrgsMetadataReturns
	return fakeReturns.result1
}

func (fake *FakeManager) UpdateOrgsMetadataCallCount() int {
	fake.updateOrgsMetadataMutex.RLock()
	defer fake.updateOrgsMetadataMutex.RUnlock()
	return len(fake.updateOrgsMetadataArgsForCall)
}

func (fake *FakeManager) UpdateOrgsMetadataCalls(stub func() error) {
	fake.updateOrgsMetadataMutex.Lock()
	defer fake.updateOrgsMetadataMutex.Unlock()
	fake.UpdateOrgsMetadataStub = stub
}

func (fake *FakeManager) UpdateOrgsMetadataReturns(result1 error) {
	fake.updateOrgsMetadataMutex.Lock()
	defer fake.updateOrgsMetadataMutex.Unlock()
	fake.UpdateOrgsMetadataStub = nil
	fake.updateOrgsMetadataReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) UpdateOrgsMetadataReturnsOnCall(i int, result1 error) {
	fake.updateOrgsMetadataMutex.Lock()
	defer fake.updateOrgsMetadataMutex.Unlock()
	fake.UpdateOrgsMetadataStub = nil
	if fake.updateOrgsMetadataReturnsOnCall == nil {
		fake.updateOrgsMetadataReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateOrgsMetadataReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeManager) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createOrgsMutex.RLock()
	defer fake.createOrgsMutex.RUnlock()
	fake.deleteOrgsMutex.RLock()
	defer fake.deleteOrgsMutex.RUnlock()
	fake.findOrgMutex.RLock()
	defer fake.findOrgMutex.RUnlock()
	fake.findOrgByGUIDMutex.RLock()
	defer fake.findOrgByGUIDMutex.RUnlock()
	fake.getOrgByGUIDMutex.RLock()
	defer fake.getOrgByGUIDMutex.RUnlock()
	fake.getOrgGUIDMutex.RLock()
	defer fake.getOrgGUIDMutex.RUnlock()
	fake.listOrgsMutex.RLock()
	defer fake.listOrgsMutex.RUnlock()
	fake.renameOrgMutex.RLock()
	defer fake.renameOrgMutex.RUnlock()
	fake.updateOrgMutex.RLock()
	defer fake.updateOrgMutex.RUnlock()
	fake.updateOrgsMetadataMutex.RLock()
	defer fake.updateOrgsMetadataMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeManager) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ organization.Manager = new(FakeManager)

repository: pupimvictor/cf-mgmt

repo_name: pupimvictor/cf-mgmt


text:
SUMMARY = "NV Overlay Sync"
DESCRIPTION = "Script to periodically sync the overlay to NV storage"

S = "${WORKDIR}"
SRC_URI = "file://nv-sync.service \
           file://nv-syncd \
           file://nv-sync-tmp.conf \
"

LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${INTELBASE}/COPYING.apache-2.0;md5=34400b68072d710fecd0a2940a0d1658"

inherit systemd

RDEPENDS:${PN} += "bash"

FILES:${PN} += "${systemd_system_unitdir}/nv-sync.service \
                ${libdir}/tmpfiles.d/nv-sync-tmp.conf"

do_install() {
    install -d ${D}${systemd_system_unitdir}
    install -m 0644 ${WORKDIR}/nv-sync.service ${D}${systemd_system_unitdir}
    install -d ${D}${bindir}
    install -m 0755 ${WORKDIR}/nv-syncd ${D}${bindir}/nv-syncd
    install -d ${D}${libdir}/tmpfiles.d
    install -m 0644 ${WORKDIR}/nv-sync-tmp.conf ${D}${libdir}/tmpfiles.d/
}

SYSTEMD_SERVICE:${PN} += " nv-sync.service"

repository: Intel-BMC/openbmc

repo_name: Intel-BMC/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
package apitool

import (
	"bytes"
	"encoding/json"
	"io"
	"io/ioutil"
	"net/http"
	"testing"
	"time"
)

// WaitForServerToStart return true only when API is ready
func WaitForServerToStart(url string) bool {
	for i := 0; i < 5; i++ {
		req, _ := http.NewRequest("GET", url, nil)
		client := &http.Client{}
		if _, err := client.Do(req); err == nil {
			return true
		}
		time.Sleep(2500)
	}
	return false
}

// HttpRequestHandlerForUnitTesting is the same as HttpRequestHandler but add logging for tests
func HttpRequestHandlerForUnitTesting(t *testing.T, requestHeader RequestHeader, requestBody interface{}, responseDTO interface{}) (*http.Response, ApiErrors) {

	// Log header
	t.Log(requestHeader)

	// Create request
	req, err := http.NewRequest(requestHeader.Method, requestHeader.URL, encodeRequestBodyAndLog(t, requestBody))
	req.Header.Set("Content-Type", requestHeader.ContentType)
	req.Header.Set("Authorization", requestHeader.Authorization)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}

	// Read response
	body, _ := ioutil.ReadAll(resp.Body)

	apiErrors := ApiErrors{}
	json.Unmarshal(body, &responseDTO)
	json.Unmarshal(body, &apiErrors)

	// Log response
	t.Log(responseDTO)
	t.Log(apiErrors)
	return resp, apiErrors
}

func encodeRequestBodyAndLog(t *testing.T, reqBody interface{}) io.Reader {
	t.Log("testing with following parameters:")
	t.Log(reqBody)

	b := new(bytes.Buffer)
	json.NewEncoder(b).Encode(reqBody)
	return b
}

repository: adriendomoison/apitool

repo_name: adriendomoison/apitool


text:
package main

import (
	"context"
	"flag"
	"log"
	"time"

	"cloud.google.com/go/bigtable"
	"google.golang.org/api/option"
)

var projectID *string
var gcpCredentialsFile *string
var outputBTInstanceID *string
var outputBTTableID *string
var outputBTFamily *string

func init() {
	projectID = flag.String("project_id", "wptdashboard", "Google Cloud Platform project id")
	gcpCredentialsFile = flag.String("gcp_credentials_file", "client-secret.json", "Path to credentials file for authenticating against Google Cloud Platform services")
	outputBTInstanceID = flag.String("output_bt_instance_id", "wpt-results-matrix", "Output BigTable instance ID")
	outputBTTableID = flag.String("output_bt_table_id", "wpt-results", "Output BigTable table ID")
	outputBTFamily = flag.String("output_bt_family", "tests", "Output BigTable column family for test results")
}

func main() {
	log.SetFlags(log.LstdFlags | log.Llongfile | log.LUTC)
	flag.Parse()

	ctx := context.Background()

	btClient, err := bigtable.NewClient(ctx, *projectID, *outputBTInstanceID, option.WithCredentialsFile(*gcpCredentialsFile))
	if err != nil {
		log.Fatal(err)
	}
	tbl := btClient.Open(*outputBTTableID)

	start := time.Now()
	rows := make([]bigtable.Row, 0)
	err = tbl.ReadRows(
		ctx,
		bigtable.PrefixRange("chrome-62.0-linux-3.16@de6ce4a47fe10bc7a86947ca9ff7dbc48c2d4648#"),
		func(r bigtable.Row) bool {
			rows = append(rows, r)
			return true
		},
		bigtable.RowFilter(bigtable.ChainFilters(
			bigtable.ColumnRangeFilter(*outputBTFamily, "/2dcontext/", "/2dcontext0"), // Col filter v1
			//bigtable.ColumnFilter("^/2dcontext/.*$"),                                  // Col filter v2 ** Somehow not equivalent?
			bigtable.ValueRangeFilter([]byte("OK"), []byte("PAST")), // Value filter v1
			//bigtable.ValueFilter("^ERROR$"), // Value filter v2
		)),
		bigtable.LimitRows(100),
	)
	if err != nil {
		log.Fatal(err)
	}
	end := time.Now()
	log.Printf("Query time: %v ; number of rows: %d", end.Sub(start), len(rows))
	if len(rows) > 0 {
		log.Printf("First row num cols: %v", len(rows[0][*outputBTFamily]))
	}
}

repository: web-platform-tests/data-migration

repo_name: web-platform-tests/data-migration


text:
# Copyright (c) 2016, Ruslan Baratov, Alexandre Pretyman
# All rights reserved.

if(DEFINED HUNTER_CMAKE_PROJECTS_POSTGRESQL_HUNTER_CMAKE)
  return()
else()
  set(HUNTER_CMAKE_PROJECTS_POSTGRESQL_HUNTER_CMAKE 1)
endif()

include(hunter_add_version)
include(hunter_pick_scheme)
include(hunter_download)

hunter_add_version(
    PACKAGE_NAME
    PostgreSQL
    VERSION
    "9.5.0"
    URL
    "https://github.com/hunter-packages/PostgreSQL/archive/PostgreSQL-9.5.0.tar.gz"
    SHA1
    b82ddcee4644ef42f3a69ee93916afa448d178c4
)

hunter_pick_scheme(DEFAULT url_sha1_autotools)
hunter_download(PACKAGE_NAME PostgreSQL)

repository: nirousi/hunter

repo_name: nirousi/hunter


text:
// Code generated by webidl-bind. DO NOT EDIT.

package scrollanimations

import "syscall/js"

import (
	"github.com/gowebapi/webapi/core"
	"github.com/gowebapi/webapi/css/animations/webani"
	"github.com/gowebapi/webapi/dom"
)

// using following types:
// dom.Element
// webani.AnimationTimeline
// webani.FillMode

// source idl files:
// scroll-animations.idl

// transform files:
// scroll-animations.go.md

// workaround for compiler error
func unused(value interface{}) {
	// TODO remove this method
}

type Union struct {
	Value js.Value
}

func (u *Union) JSValue() js.Value {
	return u.Value
}

func UnionFromJS(value js.Value) *Union {
	return &Union{Value: value}
}

// enum: ScrollDirection
type ScrollDirection int

const (
	BlockScrollDirection ScrollDirection = iota
	InlineScrollDirection
	HorizontalScrollDirection
	VerticalScrollDirection
)

var scrollDirectionToWasmTable = []string{
	"block", "inline", "horizontal", "vertical",
}

var scrollDirectionFromWasmTable = map[string]ScrollDirection{
	"block": BlockScrollDirection, "inline": InlineScrollDirection, "horizontal": HorizontalScrollDirection, "vertical": VerticalScrollDirection,
}

// JSValue is converting this enum into a javascript object
func (this *ScrollDirection) JSValue() js.Value {
	return js.ValueOf(this.Value())
}

// Value is converting this into javascript defined
// string value
func (this ScrollDirection) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(scrollDirectionToWasmTable) {
		return scrollDirectionToWasmTable[idx]
	}
	panic("unknown input value")
}

// ScrollDirectionFromJS is converting a javascript value into
// a ScrollDirection enum value.
func ScrollDirectionFromJS(value js.Value) ScrollDirection {
	key := value.String()
	conv, ok := scrollDirectionFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}

// enum: ScrollTimelineAutoKeyword
type ScrollTimelineAutoKeyword int

const (
	AutoScrollTimelineAutoKeyword ScrollTimelineAutoKeyword = iota
)

var scrollTimelineAutoKeywordToWasmTable = []string{
	"auto",
}

var scrollTimelineAutoKeywordFromWasmTable = map[string]ScrollTimelineAutoKeyword{
	"auto": AutoScrollTimelineAutoKeyword,
}

// JSValue is converting this enum into a javascript object
func (this *ScrollTimelineAutoKeyword) JSValue() js.Value {
	return js.ValueOf(this.Value())
}

// Value is converting this into javascript defined
// string value
func (this ScrollTimelineAutoKeyword) Value() string {
	idx := int(this)
	if idx >= 0 && idx < len(scrollTimelineAutoKeywordToWasmTable) {
		return scrollTimelineAutoKeywordToWasmTable[idx]
	}
	panic("unknown input value")
}

// ScrollTimelineAutoKeywordFromJS is converting a javascript value into
// a ScrollTimelineAutoKeyword enum value.
func ScrollTimelineAutoKeywordFromJS(value js.Value) ScrollTimelineAutoKeyword {
	key := value.String()
	conv, ok := scrollTimelineAutoKeywordFromWasmTable[key]
	if !ok {
		panic("unable to convert '" + key + "'")
	}
	return conv
}

// dictionary: ScrollTimelineOptions
type ScrollTimelineOptions struct {
	ScrollSource      *dom.Element
	Orientation       ScrollDirection
	StartScrollOffset string
	EndScrollOffset   string
	TimeRange         *Union
	Fill              webani.FillMode
}

// JSValue is allocating a new javascript object and copy
// all values
func (_this *ScrollTimelineOptions) JSValue() js.Value {
	out := js.Global().Get("Object").New()
	value0 := _this.ScrollSource.JSValue()
	out.Set("scrollSource", value0)
	value1 := _this.Orientation.JSValue()
	out.Set("orientation", value1)
	value2 := _this.StartScrollOffset
	out.Set("startScrollOffset", value2)
	value3 := _this.EndScrollOffset
	out.Set("endScrollOffset", value3)
	value4 := _this.TimeRange.JSValue()
	out.Set("timeRange", value4)
	value5 := _this.Fill.JSValue()
	out.Set("fill", value5)
	return out
}

// ScrollTimelineOptionsFromJS is allocating a new
// ScrollTimelineOptions object and copy all values in the value javascript object.
func ScrollTimelineOptionsFromJS(value js.Value) *ScrollTimelineOptions {
	var out ScrollTimelineOptions
	var (
		value0 *dom.Element    // javascript: Element {scrollSource ScrollSource scrollSource}
		value1 ScrollDirection // javascript: ScrollDirection {orientation Orientation orientation}
		value2 string          // javascript: DOMString {startScrollOffset StartScrollOffset startScrollOffset}
		value3 string          // javascript: DOMString {endScrollOffset EndScrollOffset endScrollOffset}
		value4 *Union          // javascript: Union {timeRange TimeRange timeRange}
		value5 webani.FillMode // javascript: FillMode {fill Fill fill}
	)
	if value.Get("scrollSource").Type() != js.TypeNull && value.Get("scrollSource").Type() != js.TypeUndefined {
		value0 = dom.ElementFromJS(value.Get("scrollSource"))
	}
	out.ScrollSource = value0
	value1 = ScrollDirectionFromJS(value.Get("orientation"))
	out.Orientation = value1
	value2 = (value.Get("startScrollOffset")).String()
	out.StartScrollOffset = value2
	value3 = (value.Get("endScrollOffset")).String()
	out.EndScrollOffset = value3
	value4 = UnionFromJS(value.Get("timeRange"))
	out.TimeRange = value4
	value5 = webani.FillModeFromJS(value.Get("fill"))
	out.Fill = value5
	return &out
}

// class: ScrollTimeline
type ScrollTimeline struct {
	webani.AnimationTimeline
}

// ScrollTimelineFromJS is casting a js.Value into ScrollTimeline.
func ScrollTimelineFromJS(value js.Value) *ScrollTimeline {
	if typ := value.Type(); typ == js.TypeNull || typ == js.TypeUndefined {
		return nil
	}
	ret := &ScrollTimeline{}
	ret.Value_JS = value
	return ret
}

// ScrollTimelineFromJS is casting from something that holds a js.Value into ScrollTimeline.
func ScrollTimelineFromWrapper(input core.Wrapper) *ScrollTimeline {
	return ScrollTimelineFromJS(input.JSValue())
}

func NewScrollTimeline(options *ScrollTimelineOptions) (_result *ScrollTimeline) {
	_klass := js.Global().Get("ScrollTimeline")
	var (
		_args [1]interface{}
		_end  int
	)
	if options != nil {
		_p0 := options.JSValue()
		_args[0] = _p0
		_end++
	}
	_returned := _klass.New(_args[0:_end]...)
	var (
		_converted *ScrollTimeline // javascript: ScrollTimeline _what_return_name
	)
	_converted = ScrollTimelineFromJS(_returned)
	_result = _converted
	return
}

// ScrollSource returning attribute 'scrollSource' with
// type dom.Element (idl: Element).
func (_this *ScrollTimeline) ScrollSource() *dom.Element {
	var ret *dom.Element
	value := _this.Value_JS.Get("scrollSource")
	ret = dom.ElementFromJS(value)
	return ret
}

// Orientation returning attribute 'orientation' with
// type ScrollDirection (idl: ScrollDirection).
func (_this *ScrollTimeline) Orientation() ScrollDirection {
	var ret ScrollDirection
	value := _this.Value_JS.Get("orientation")
	ret = ScrollDirectionFromJS(value)
	return ret
}

// StartScrollOffset returning attribute 'startScrollOffset' with
// type string (idl: DOMString).
func (_this *ScrollTimeline) StartScrollOffset() string {
	var ret string
	value := _this.Value_JS.Get("startScrollOffset")
	ret = (value).String()
	return ret
}

// EndScrollOffset returning attribute 'endScrollOffset' with
// type string (idl: DOMString).
func (_this *ScrollTimeline) EndScrollOffset() string {
	var ret string
	value := _this.Value_JS.Get("endScrollOffset")
	ret = (value).String()
	return ret
}

// TimeRange returning attribute 'timeRange' with
// type Union (idl: Union).
func (_this *ScrollTimeline) TimeRange() *Union {
	var ret *Union
	value := _this.Value_JS.Get("timeRange")
	ret = UnionFromJS(value)
	return ret
}

// Fill returning attribute 'fill' with
// type webani.FillMode (idl: FillMode).
func (_this *ScrollTimeline) Fill() webani.FillMode {
	var ret webani.FillMode
	value := _this.Value_JS.Get("fill")
	ret = webani.FillModeFromJS(value)
	return ret
}

repository: gowebapi/webapi

repo_name: gowebapi/webapi


text:
include ${PN}.inc

PV = "1.2.0+cvs-${CVSDATE}"
PR = "r0"

SRC_URI = "${HANDHELDS_CVS};module=opie/core/settings/launcher \
           ${HANDHELDS_CVS};module=opie/apps \
	   cvs://anoncvs:anoncvs@cvs.handhelds.org/Cvs;module=opie/pics"

repository: BackupTheBerlios/openslug-svn

repo_name: BackupTheBerlios/openslug-svn


text:
# requires installed libcurl
# target: restclient-cpp

include(FetchContent)

set(NAME "restclient-cpp")
set(TAG "master")

FetchContent_Declare(${NAME}
        GIT_REPOSITORY https://github.com/mrtazz/restclient-cpp.git
        GIT_TAG ${TAG}
        )

FetchContent_GetProperties(${NAME})
string(TOLOWER ${NAME} lcName)
if (NOT ${lcName}_POPULATED)
    FetchContent_Populate(${NAME})

    set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "")

    add_subdirectory(${${lcName}_SOURCE_DIR} ${${lcName}_BINARY_DIR} EXCLUDE_FROM_ALL)
    set_target_properties(${NAME} PROPERTIES
            INCLUDE_DIRECTORIES "${${lcName}_SOURCE_DIR}/include ${${lcName}_BINARY_DIR}/include")
endif ()

repository: egor-spk/cxx-cmake-dependencies

repo_name: egor-spk/cxx-cmake-dependencies


text:
require edison-image-minimal.bb

DESCRIPTION = "A fully functional image to run EDISON"
#KERNEL_IMAGETYPE_pn-edison-image = "bzImage-initramfs-edison.bin"
LICENSE = "MIT"

IMAGE_INSTALL:append = " connman"
IMAGE_INSTALL:append = " connman-client"
IMAGE_INSTALL:append = " connman-tools"
IMAGE_INSTALL:append = " connman-plugin-vpn-openvpn"
IMAGE_INSTALL:append = " openvpn"

IMAGE_INSTALL:append = " ap-mode-toggle"
IMAGE_INSTALL:append = " ethtool"
IMAGE_INSTALL:append = " pwr-button-handler"
IMAGE_INSTALL:append = " blink-led"
IMAGE_INSTALL:append = " post-install"
IMAGE_INSTALL:append = " bluez5-dev"
IMAGE_INSTALL:append = " bluez5-noinst-tools"
IMAGE_INSTALL:append = " bluez5-testtools"
IMAGE_INSTALL:append = " bluez5-obex"
IMAGE_INSTALL:append = " systemd-analyze"
# Allows to enable open pam feature
IMAGE_INSTALL:append = " libpam"
# Allows to enable OpenMP feature
IMAGE_INSTALL:append = " libgomp"

# Add audio firmware
IMAGE_INSTALL:append = " sof-fw"

# ALSA lib and utilities
#IMAGE_INSTALL:append = " alsa-lib"
IMAGE_INSTALL:append = " alsa-utils-alsamixer alsa-utils-alsactl alsa-utils-aplay alsa-utils-amixer"

# OOBE
IMAGE_INSTALL:append = " run-timezone"

# Python and some basic modules
#IMAGE_INSTALL:append = " python-distutils python-pkgutil python-audio python-image python-email python-netserver python-xmlrpc python-ctypes python-html python-json python-compile python-misc python-numbers python-unittest python-pydoc"

IMAGE_INSTALL:append = " crashlog"

# Adds various other tools
IMAGE_INSTALL:append = " tcpdump"
IMAGE_INSTALL:append = " net-tools"
IMAGE_INSTALL:append = " iperf3"
IMAGE_INSTALL:append = " vim"
IMAGE_INSTALL:append = " btrfs-compsize"

# Add pulseaudio
IMAGE_INSTALL:append = " pulseaudio-server libpulsecore libpulsecommon libpulse libpulse-simple pulseaudio-misc"

#Add Gstreamer
IMAGE_INSTALL:append = " gstreamer1.0 gstreamer1.0-meta-base gstreamer1.0-meta-audio"

# Edison Middleware stuff
IMAGE_INSTALL:append = " packagegroup-core-buildessential"
IMAGE_INSTALL:append = " zeromq-dev"
IMAGE_INSTALL:append = " cppzmq-dev"
IMAGE_INSTALL:append = " python3-paho-mqtt-dev"
IMAGE_INSTALL:append = " libnss-mdns-dev"
#IMAGE_INSTALL:append = " xdk-daemon"
IMAGE_INSTALL:append = " oobe"

# mosquitto and dependencies
IMAGE_INSTALL:append = " mosquitto-dev"
IMAGE_INSTALL:append = " mosquitto-clients"

# node and sub-components
IMAGE_INSTALL:append = " nodejs-dev"
IMAGE_INSTALL:append = " nodejs-npm"

# libiio replaces the former MRAA and UPM to access sensor/actuator drivers in the kernel
IMAGE_INSTALL:append = " libiio"
IMAGE_INSTALL:append = " libiio-iiod"
IMAGE_INSTALL:append = " libiio-python3"
IMAGE_INSTALL:append = " libiio-tests"

# gpiod replaces the former MRAA and UPM to access sensor/actuator drivers in the kernel
IMAGE_INSTALL:append = " libgpiod-python"
IMAGE_INSTALL:append = " libgpiodcxx"

# libserialport replaces the former MRAA and UPM to access serial ports
IMAGE_INSTALL:append = " libserialport"

# INTEL MCU FW - disable for now as not supported by kernel
#IMAGE_INSTALL:append = " mcu-fw-load"
#IMAGE_INSTALL:append = " mcu-fw-bin"

# nfs
#IMAGE_INSTALL:append = " nfs-utils"

# Add oFono
IMAGE_INSTALL:append = " ofono"

# Add ppp if supported by DISTRO_FEATURES
IMAGE_INSTALL:append = " ${@bb.utils.contains("DISTRO_FEATURES", "ppp", " ppp", "", d)}"

# Add cyclictest needed by ppp and for measuring latencies
IMAGE_INSTALL:append = " rt-tests"

# Add battery level detection
IMAGE_INSTALL:append = " battery-voltage"

# Add linux performance monitoring tool
# remove until the build hang issue gets sorted out
#IMAGE_INSTALL:append = " perf"

# package management - where to find this?
#IMAGE_INSTALL:append = " aptitude"
IMAGE_INSTALL:append = " gnupg"
IMAGE_INSTALL:append = " diffutils"

# Provides strace and gdb
IMAGE_FEATURES += " tools-debug"
IMAGE_INSTALL:append = " rsync"

# Add the nano text editor
IMAGE_INSTALL:append = " nano"

# SWIG
IMAGE_INSTALL:append = " swig"

# Add monitoring tools
IMAGE_INSTALL:append = " iotop"
IMAGE_INSTALL:append = " powertop"

# Clean corrupted journald entries
IMAGE_INSTALL:append = " cleanjournal"

repository: edison-fw/meta-intel-edison

repo_name: edison-fw/meta-intel-edison

gha_language: Shell


text:
package main

import (
	"io/ioutil"
	"log"
	"os"
)

// logger list
var (
	errLogger   = log.New(os.Stderr, "[PROXY ERROR] ", log.LstdFlags)
	infoLogger  = log.New(ioutil.Discard, "[PROXY INFO] ", log.LstdFlags)
	debugLogger = log.New(ioutil.Discard, "[PROXY DEBUG] ", log.LstdFlags)
)

// enableInfoLog enables info logs.
func enableInfoLog() {
	infoLogger.SetOutput(os.Stdout)
}

// enableDebugLog enables debug logs.
func enableDebugLog() {
	debugLogger.SetOutput(os.Stdout)
}

// loggingInfo outputs info log.
func loggingInfo(log string, v ...interface{}) {
	infoLogger.Printf(log+"\n", v...)
}

// loggingError outputs error log.
func loggingError(log string, v ...interface{}) {
	errLogger.Printf(log+"\n", v...)
}

// loggingDebug outputs debug log.
func loggingDebug(log string, v ...interface{}) {
	debugLogger.Printf(log+"\n", v...)
}

repository: evalphobia/go-simple-proxy

repo_name: evalphobia/go-simple-proxy


text:
SUMMARY = "User space applications in Elk Audio OS devices"
HOMEPAGE = "https://github.com/elk-audio/meta-elk"
LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"

inherit packagegroup

RDEPENDS_packagegroup-elk-applications = "\
    sushi \
    sensei \
    "

repository: elk-audio/meta-elk

repo_name: elk-audio/meta-elk

branch_name: refs/heads/hardknott

gha_language: BitBake


text:
// Code generated by mockery v0.0.0-dev. DO NOT EDIT.

package mocks

import (
	api "github.com/hashicorp/consul/api"
	mock "github.com/stretchr/testify/mock"
	consul "github.com/trento-project/trento/internal/consul"
)

// Client is an autogenerated mock type for the Client type
type Client struct {
	mock.Mock
}

// AcquireLockKey provides a mock function with given fields: prefix
func (_m *Client) AcquireLockKey(prefix string) (*api.Lock, error) {
	ret := _m.Called(prefix)

	var r0 *api.Lock
	if rf, ok := ret.Get(0).(func(string) *api.Lock); ok {
		r0 = rf(prefix)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*api.Lock)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(prefix)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Agent provides a mock function with given fields:
func (_m *Client) Agent() consul.Agent {
	ret := _m.Called()

	var r0 consul.Agent
	if rf, ok := ret.Get(0).(func() consul.Agent); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(consul.Agent)
		}
	}

	return r0
}

// Catalog provides a mock function with given fields:
func (_m *Client) Catalog() consul.Catalog {
	ret := _m.Called()

	var r0 consul.Catalog
	if rf, ok := ret.Get(0).(func() consul.Catalog); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(consul.Catalog)
		}
	}

	return r0
}

// Health provides a mock function with given fields:
func (_m *Client) Health() consul.Health {
	ret := _m.Called()

	var r0 consul.Health
	if rf, ok := ret.Get(0).(func() consul.Health); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(consul.Health)
		}
	}

	return r0
}

// KV provides a mock function with given fields:
func (_m *Client) KV() consul.KV {
	ret := _m.Called()

	var r0 consul.KV
	if rf, ok := ret.Get(0).(func() consul.KV); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(consul.KV)
		}
	}

	return r0
}

// WaitLock provides a mock function with given fields: prefix
func (_m *Client) WaitLock(prefix string) error {
	ret := _m.Called(prefix)

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(prefix)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

branch_name: refs/heads/main


text:
DESCRIPTION = "Unique technology suite that makes possible the management of extremely large and complex data collections"
AUTHOR = "Alexander Leiva <norxander@gmail.com>"
SUMMARY = "HDF5 is a data model, library, and file format for storing and managing data"
HOMEPAGE = "http://caffe.berkeleyvision.org/"
LICENSE = "BSD"
PRIORITY= "optional"
SECTION = "libs"
PR = "r0"

RDEPENDS_${PN} = "zlib"

LIC_FILES_CHKSUM = "file://COPYING;md5=57e5351b17591e659eedae107265c606"

inherit cmake

SRC_URI = " \
    https://support.hdfgroup.org/ftp/HDF5/current18/src/${PN}-${PV}.tar.bz2 \
    file://configuration.patch \
    file://generation.patch \
    file://copy_generated.patch \
"

SRC_URI[md5sum] = "6f0353ee33e99089c110a1c8d2dd1b22"
SRC_URI[sha256sum] = "59c03816105d57990329537ad1049ba22c2b8afe1890085f0c022b75f1727238"

PACKAGES += "${PN}-extra"
FILES_${PN} += "/usr/lib/libhdf5.settings"
FILES_${PN}-extra = "/usr/share/hdf5_examples/"

# EXTRA_OECONF = "--enable-production --enable-cxx --with-zlib=${STAGING_INCDIR},${STAGING_LIBDIR}"
EXTRA_OECMAKE = " \
    -DHAVE_DEFAULT_SOURCE_RUN=0 \
    -DHAVE_DEFAULT_SOURCE_RUN__TRYRUN_OUTPUT= \
    -DTEST_LFS_WORKS_RUN=0 \
    -DTEST_LFS_WORKS_RUN__TRYRUN_OUTPUT=0 \
    -DH5_PRINTF_LL_TEST_RUN=1 \
    -DH5_PRINTF_LL_TEST_RUN__TRYRUN_OUTPUT='8' \
    -DTEST_DIRECT_VFD_WORKS_RUN=0 \
    -DTEST_DIRECT_VFD_WORKS_RUN__TRYRUN_OUTPUT=0 \
    -DH5_LDOUBLE_TO_LONG_SPECIAL_RUN=0 \
    -DH5_LDOUBLE_TO_LONG_SPECIAL_RUN__TRYRUN_OUTPUT= \
    -DH5_LONG_TO_LDOUBLE_SPECIAL_RUN=0 \
    -DH5_LONG_TO_LDOUBLE_SPECIAL_RUN__TRYRUN_OUTPUT= \
    -DH5_LDOUBLE_TO_LLONG_ACCURATE_RUN=0 \
    -DH5_LDOUBLE_TO_LLONG_ACCURATE_RUN__TRYRUN_OUTPUT= \
    -DH5_LLONG_TO_LDOUBLE_CORRECT_RUN=0 \
    -DH5_LLONG_TO_LDOUBLE_CORRECT_RUN__TRYRUN_OUTPUT= \
    -DH5_NO_ALIGNMENT_RESTRICTIONS_RUN=0 \
    -DH5_NO_ALIGNMENT_RESTRICTIONS_RUN__TRYRUN_OUTPUT= \
    -DCMAKE_INSTALL_PREFIX='${D}/usr' \
"

do_install() {
    oe_runmake install
    rm -f ${D}/usr/lib/*la
    rm -f ${D}/usr/share/cmake/*
    rm -f ${D}/usr/share/COPYING
    rm -f ${D}/usr/share/RELEASE.txt
    rm -f ${D}/usr/share/USING_HDF5_CMake.txt
    rmdir ${D}/usr/share/cmake
    rmdir ${D}/usr/share

    ln -sr ${D}/usr/lib/libhdf5_cpp-shared.so ${D}/usr/lib/libhdf5_cpp.so
    ln -sr ${D}/usr/lib/libhdf5_hl-shared.so ${D}/usr/lib/libhdf5_hl.so
    ln -sr ${D}/usr/lib/libhdf5_hl_cpp-shared.so ${D}/usr/lib/libhdf5_hl_cpp.so
    ln -sr ${D}/usr/lib/libhdf5-shared.so ${D}/usr/lib/libhdf5.so
    ln -sr ${D}/usr/lib/libhdf5_tools-shared.so ${D}/usr/lib/libhdf5_tools.so
}

repository: intel/intel-iot-refkit

repo_name: intel/intel-iot-refkit


text:
package types

import (
	engineapi "github.com/docker/engine-api/client"
	enginetypes "github.com/docker/engine-api/types"
	"golang.org/x/net/context"
)

// only relationship with pod and node is stored
// if you wanna get realtime information, use Inspect method
type Container struct {
	ID       string            `json:"id"`
	Podname  string            `json:"podname"`
	Nodename string            `json:"nodename"`
	Engine   *engineapi.Client `json:"-"`
}

func (c *Container) Inspect() (enginetypes.ContainerJSON, error) {
	return c.Engine.ContainerInspect(context.Background(), c.ID)
}


text:
// Copyright 2020 The VectorSQL Authors.
//
// Code is licensed under Apache License, Version 2.0.

package planners

import (
	"encoding/json"
)

type MapPlan struct {
	Name     string
	SubPlans []IPlan `json:",omitempty"`
}

func NewMapPlan(plans ...IPlan) *MapPlan {
	return &MapPlan{
		Name:     "MapPlan",
		SubPlans: plans,
	}
}

func (plan *MapPlan) Build() error {
	for _, p := range plan.SubPlans {
		if err := p.Build(); err != nil {
			return err
		}
	}
	return nil
}

func (plan *MapPlan) Walk(visit Visit) error {
	return Walk(visit, plan.SubPlans...)
}

func (plan *MapPlan) String() string {
	out, err := json.MarshalIndent(plan, "", "    ")
	if err != nil {
		return err.Error()
	}
	return string(out)
}

func (plan *MapPlan) Length() int {
	return len(plan.SubPlans)
}

func (plan *MapPlan) Add(p IPlan) {
	plan.SubPlans = append(plan.SubPlans, p)
}

func (plan *MapPlan) AsPlans() []IPlan {
	return plan.SubPlans
}

repository: zhenruyan/vectorsql

repo_name: zhenruyan/vectorsql


text:
require mpmd.inc
require uhd_4.0_src.inc

LIC_FILES_CHKSUM = "file://../host/LICENSE;md5=8255adf1069294c928e0e18b01a16282"

repository: EttusResearch/meta-ettus

repo_name: EttusResearch/meta-ettus

branch_name: refs/heads/zeus


text:
package goapi;

import (
   "fmt"
   "io"
   "io/ioutil"
   "mime/multipart"
   "net/http"
   "reflect"
   "runtime"
   "strconv"
   "strings"
   "time"
)

const (
   MULTIPART_PARSE_SIZE = 4 * 1024 * 1024 // Store the first 4M in memory.
   PARAM_TOKEN = "token"
)

const (
   API_PARAM_TYPE_INT = iota
   API_PARAM_TYPE_STRING
   API_PARAM_TYPE_FILE
)

// We need to define these as types, so we can figure it out when we want to pass params.
type Token string;
type UserId int;
type UserName string;

type File struct {
   Io *multipart.File
}

func (file File) Valid() bool {
   return file.Io != nil;
}

func (file File) Data() ([]byte, error) {
   if (!file.Valid()) {
      return nil, fmt.Errorf("Cannot get data of invalid file");
   }

   return ioutil.ReadAll(*file.Io);
}

type ApiMethod struct {
   path string
   handler interface{}
   auth bool
   allowTokenParam bool
   params []ApiMethodParam
   log Logger
   serializer Serializer
   contentType string
   errorResponder ErrorResponder
   tokenValidator ValidateToken
}

type ApiMethodParam struct {
   Name string
   ParamType int
   Required bool
}

func (method ApiMethod) Path() string {
   return method.path;
}

// Returns this so you can chain.
func (method *ApiMethod) SetAllowTokenParam(val bool) *ApiMethod {
   method.allowTokenParam = val;
   return method;
}

// Will just panic on error.
func (method ApiMethod) validate() {
   // Check the definitions.
   if (method.path == "") {
      method.log.Panic("Bad path for API handler");
   }

   if (method.handler == nil) {
      method.log.Panic(fmt.Sprintf("Nil handler for API handler for path: %s", method.path));
   }

   for _, param := range(method.params) {
      if (param.Name == "") {
         method.log.Panic(fmt.Sprintf("Empty name for param for API handler for path: %s", method.path));
      }

      if (!(param.ParamType == API_PARAM_TYPE_INT || param.ParamType == API_PARAM_TYPE_STRING || param.ParamType == API_PARAM_TYPE_FILE)) {
         method.log.Panic(fmt.Sprintf("Param (%s) for API handler (%s) has bad type (%d)", param.Name, method.path, param.ParamType));
      }
   }

   // Check parameter semantics.

   var handlerType reflect.Type = reflect.TypeOf(method.handler);

   var numParams int = handlerType.NumIn();
   var additionalParams = 0;

   for i := 0; i < numParams; i++ {
      var ParamType reflect.Type = handlerType.In(i);

      if (ParamType.String() == "goapi.Token") {
         additionalParams++;

         if (!method.auth) {
            method.log.Panic(fmt.Sprintf("API handler (%s) requested a token without authentication", method.path));
         }
      } else if (ParamType.String() == "goapi.UserId") {
         additionalParams++;

         if (!method.auth) {
            method.log.Panic(fmt.Sprintf("API handler (%s) requested a user id without authentication", method.path));
         }
      } else if (ParamType.String() == "goapi.UserName") {
         additionalParams++;

         if (!method.auth) {
            method.log.Panic(fmt.Sprintf("API handler (%s) requested a user name without authentication", method.path));
         }
      } else if (ParamType.String() == "*http.Request") {
         additionalParams++;
      } else if (ParamType.String() == "http.ResponseWriter") {
         additionalParams++;
      } else {
         if (!(ParamType.String() == "int" || ParamType.String() == "string" || ParamType.String() == "goapi.File")) {
            method.log.Panic(fmt.Sprintf("API handler (%s) has an actual parameter with incorrect type (%s) must be string or int", method.path, ParamType.String()));
         }
      }
   }

   if (numParams != len(method.params) + additionalParams) {
      method.log.Panic(fmt.Sprintf("API handler (%s) actually expects %d parameters, but is defined to expect %d (%d defined, %d implicit)", method.path, numParams, len(method.params) + additionalParams, len(method.params), additionalParams));
   }

   // Check the return semantics.
   var numReturns int = handlerType.NumOut();

   if (numReturns > 4) {
      method.log.Panic(fmt.Sprintf("API handler (%s) has too many return values. Got %d. Maximum is 4.", method.path, numReturns));
   }

   // All of the return types are unique.
   var seenReturnTypes map[string]bool = make(map[string]bool);
   for i := 0; i < numReturns; i++ {
      var returnType string = handlerType.Out(i).String();

      if (!(returnType == "interface {}" || returnType == "int" || returnType == "string" || returnType == "error")) {
         method.log.Panic(fmt.Sprintf("API handler (%s) has an bad return type (%s) must be interface{}, int, string, or error", method.path, returnType));
      }

      if (seenReturnTypes[returnType]) {
         method.log.Panic(fmt.Sprintf("API handler (%s) has duplicate return types (%s). Can only have up to four return types and each must be a unique type (interface{}, int, string, or error).", method.path, returnType));
      }
      seenReturnTypes[returnType] = true;
   }
}

func (method ApiMethod) Middleware() func(response http.ResponseWriter, request *http.Request) {
   return func(response http.ResponseWriter, request *http.Request) {
      // Skip preflight checks.
      if (request.Method == "OPTIONS") {
         return;
      }

      if (request.URL != nil) {
         method.log.Debug(request.URL.String());
      }

      responseObj, httpStatus, contentType, err := method.handleAPIRequest(response, request);
      response.Header().Set("Content-Type", contentType);

      if (err != nil) {
         method.sendResponse("", err, httpStatus, response);
         return;
      }

      // Check to see if we need to close the caller's response object when we are done.
      defer func() {
         closer, ok := responseObj.(io.Closer);
         if (ok) {
            err = closer.Close();
            if (err != nil) {
               method.log.WarnE("Error closing a response reader, but the response still went out fine.", err);
            }
         }
      }();

      // If the response object is an io.ReadSeeker, then we will let
      // http.ServeContent take care of almost all the work
      // (except setting the content type).
      readSeeker, ok := responseObj.(io.ReadSeeker);
      if (ok) {
         http.ServeContent(response, request, "", time.Time{}, readSeeker);
         return;
      }

      // Set some standard headers.
      response.Header().Set("Access-Control-Allow-Origin", "*");
      response.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
      response.Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, Authorization");

      // If the response object is a reader, then stream it into the response writer.
      reader, ok := responseObj.(io.Reader);
      if (ok) {
         if (httpStatus == 0) {
            httpStatus = http.StatusOK;
         }

         response.WriteHeader(httpStatus);

         _, err = io.Copy(response, reader);
         if (err != nil) {
            // The reeponse may have got partially written... so just abandon the request.
            method.log.ErrorE("Failed to stream the response", err);
         }
      } else {
         // Otherwise, just serialize the response and send it over.
         responseString, err := method.serializer(responseObj);
         method.sendResponse(responseString, err, httpStatus, response);
      }
   }
}

// This handles the API side of the request.
// None of the boilerplate.
func (method ApiMethod) handleAPIRequest(response http.ResponseWriter, request *http.Request) (interface{}, int, string, error) {
   var userId int = -1;
   var userName string = "";
   var ok bool;
   var token string = "";

   if (method.auth) {
      var responseObject interface{};
      ok, userId, userName, token, responseObject = method.authRequest(request);
      if (!ok) {
         return responseObject, http.StatusUnauthorized, method.contentType, nil;
      }
   }

   ok, args := method.createArguments(UserId(userId), UserName(userName), Token(token), response, request);
   if (!ok) {
      return method.errorResponder(nil, http.StatusBadRequest), http.StatusBadRequest, method.contentType, nil;
   }

   var handlerValue reflect.Value = reflect.ValueOf(method.handler);
   returns := handlerValue.Call(args);

   return method.createReturnValues(returns);
}

func (method ApiMethod) createReturnValues(returns []reflect.Value) (interface{}, int, string, error) {
   var responseObj interface{} = nil;
   var httpStatus int = 0;
   var err error = nil;
   var contentType string = method.contentType;

   // Returns are optional.
   for _, val := range(returns) {
      var returnType reflect.Type = val.Type();

      if (returnType.String() == "interface {}") {
         if (!val.IsNil()) {
            responseObj = val.Interface();
         }
      } else if (returnType.String() == "int") {
         httpStatus = int(val.Int());
      } else if (returnType.String() == "string") {
         if (val.String() != "") {
            contentType = val.String();
         }
      } else if (returnType.String() == "error") {
         if (!val.IsNil()) {
            err = val.Interface().(error);
         }
      } else {
         method.log.Fatal(fmt.Sprintf("Unkown return type (%s) for API handler for path: %s", returnType.String(), method.path));
      }
   }

   return responseObj, httpStatus, contentType, err;
}

// Get all the parameters setup for invocation.
func (method ApiMethod) createArguments(userId UserId, userName UserName, token Token, response http.ResponseWriter, request *http.Request) (bool, []reflect.Value) {
   var handlerType reflect.Type = reflect.TypeOf(method.handler);
   var numParams int = handlerType.NumIn();

   var apiParamIndex = 0;
   var paramValues []reflect.Value = make([]reflect.Value, numParams);

   for i := 0; i < numParams; i++ {
      var ParamType reflect.Type = handlerType.In(i);

      // The user id, token, request, and response get handled specially.
      if (method.auth && ParamType.String() == "goapi.Token") {
         paramValues[i] = reflect.ValueOf(token);
      } else if (method.auth && ParamType.String() == "goapi.UserId") {
         paramValues[i] = reflect.ValueOf(userId);
      } else if (method.auth && ParamType.String() == "goapi.UserName") {
         paramValues[i] = reflect.ValueOf(userName);
      } else if (ParamType.String() == "*http.Request") {
         paramValues[i] = reflect.ValueOf(request);
      } else if (ParamType.String() == "http.ResponseWriter") {
         paramValues[i] = reflect.ValueOf(response);
      } else {
         // Normal param, fetch the next api parameter and pass it along.
         ok, val := method.fetchParam(apiParamIndex, request);
         if (!ok) {
            return false, []reflect.Value{};
         }

         paramValues[i] = val;
         apiParamIndex++;
      }
   }

   return true, paramValues;
}

func (method ApiMethod) fetchParam(apiParamIndex int, request *http.Request) (bool, reflect.Value) {
   // Only the first call will do anything.
   request.ParseMultipartForm(MULTIPART_PARSE_SIZE);

   var param ApiMethodParam = method.params[apiParamIndex];

   if (param.ParamType == API_PARAM_TYPE_FILE) {
      file, _, err := request.FormFile(param.Name);
      if (err != nil) {
         if (param.Required) {
            method.log.Warn(fmt.Sprintf("Required file parameter not found: %s", param.Name));
            return false, reflect.Value{};
         } else {
            return true, reflect.ValueOf(File{nil});
         }
      }

      return true, reflect.ValueOf(File{&file});
   }

   var stringValue string = strings.TrimSpace(request.FormValue(param.Name));

   if (param.Required && stringValue == "") {
      method.log.Warn(fmt.Sprintf("Required parameter not found: %s", param.Name));
      return false, reflect.Value{};
   }

   // If we are looking for string, then we are done.
   if (param.ParamType == API_PARAM_TYPE_STRING) {
      return true, reflect.ValueOf(stringValue);
   }

   // We must be looking for an int (only ints, files, and strings are allowed).

   // First check for an empty non-required int.
   if (stringValue == "") {
      return true, reflect.ValueOf(0);
   }

   intValue, err := strconv.Atoi(stringValue);
   if (err != nil) {
      method.log.WarnE(fmt.Sprintf("Unable to convert int parameter (%s) from string: '%s'", param.Name, stringValue), err);
      return false, reflect.ValueOf(0);
   }

   return true, reflect.ValueOf(intValue);
}

// Send a response over |response|.
// On error, |responseString| will be ignored.
// In not supplied, the |httpStatus| will become http.StatusInternalServerError on error and
// http.StatusOK on success.
func (method ApiMethod) sendResponse(responseString string, err error, httpStatus int, response http.ResponseWriter) {
   if (err != nil) {
      method.log.ErrorE("API Error", err);

      if (httpStatus == 0) {
         httpStatus = http.StatusInternalServerError;
      }

      // Any serialization errors will be ignored at this point.
      responseString, _ = method.serializer(method.errorResponder(err, httpStatus));
      response.WriteHeader(httpStatus);
      fmt.Fprintln(response, responseString);
   } else {
      method.log.Debug("Successful Response:\n" + responseString);

      if (httpStatus == 0) {
         httpStatus = http.StatusOK;
      }

      response.WriteHeader(httpStatus)
      fmt.Fprintln(response, responseString);
   }
}

// Tries to authorize a request.
// Returns: success, user id, user name, request token, and response object.
// user id and token will only be populated on success.
// response object will only be populated on error.
func (method ApiMethod) authRequest(request *http.Request) (bool, int, string, string, interface{}) {
   token, ok := getToken(request, method.allowTokenParam);

   if (!ok) {
      return false, 0, "", "", method.errorResponder(TokenValidationError{TOKEN_VALIDATION_NO_TOKEN}, http.StatusUnauthorized);
   }

   // Check for empty tokens.
   if (strings.TrimSpace(token) == "") {
      return false, 0, "", "", method.errorResponder(TokenValidationError{TOKEN_VALIDATION_NO_TOKEN}, http.StatusUnauthorized);
   }

   userId, userName, err := method.tokenValidator(token, method.log);
   if (err != nil) {
      validationErr, ok := err.(TokenValidationError);
      if (!ok) {
         // Some other (non-validation) error.
         return false, 0, "", "", method.errorResponder(nil, http.StatusInternalServerError);
      }

      return false, 0, "", "", method.errorResponder(validationErr, http.StatusUnauthorized);
   }

   return true, userId, userName, token, nil;
}

func (method ApiMethod) String() string {
   var rtn string = "";

   rtn += fmt.Sprintf("%s\n", method.path);
   rtn += fmt.Sprintf("   Authentication Required: %v\n", method.auth);

   if (len(method.params) == 0) {
      rtn += "   Params: None\n"
   } else {
      rtn += "   Params:\n"
      for _, param := range(method.params) {
         rtn += fmt.Sprintf("      %v\n", param);
      }
   }

   rtn += fmt.Sprintf("   Handler: %s ", runtime.FuncForPC(reflect.ValueOf(method.handler).Pointer()).Name());
   return rtn;
}

func (param ApiMethodParam) String() string {
   var typeString string = "int";
   if (param.ParamType == API_PARAM_TYPE_STRING) {
      typeString = "string";
   } else if (param.ParamType == API_PARAM_TYPE_FILE) {
      typeString = "File";
   }

   var requiredString string = "";
   if (param.Required) {
      requiredString = " (required)";
   }

   return fmt.Sprintf("%s %s%s", param.Name, typeString, requiredString);
}

repository: eriq-augustine/goapi

repo_name: eriq-augustine/goapi


text:
DESCRIPTION = "Xfce4 development tools"
SECTION = "x11/libs"
LICENSE = "GPL"

PR = "r2"

inherit xfce
XFCE_VERSION = 4.4.2

do_install_append() {
       install -d ${D}${datadir}/aclocal
       install -m 644 m4macros/*.m4 ${D}${datadir}/aclocal/
}

FILES_${PN}-dev += " ${datadir}/xfce4/dev-tools/m4macros/*.m4"

SRC_URI[md5sum] = "7d09d161efc7ef86b3b48791d98c8ae8"
SRC_URI[sha256sum] = "1e7a506f08c8a4f368dd18648006ba3934a94eb96fd4545f5303d46aeae9cc3e"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD