text:
#
# Copyright (C) 2010 Intel Corporation
#

SUMMARY = "Standard full-featured Linux system"
DESCRIPTION = "Package group bringing in packages needed for a more traditional full-featured Linux system"
PR = "r6"
LICENSE = "MIT"

inherit packagegroup

PACKAGES = "\
    packagegroup-core-cmdline \
    packagegroup-core-cmdline-libs \
    packagegroup-core-cmdline-utils \
    packagegroup-core-cmdline-extended \
    packagegroup-core-cmdline-dev-utils \
    packagegroup-core-cmdline-multiuser \
    packagegroup-core-cmdline-sys-services \
    "

python __anonymous () {
    # For backwards compatibility after rename
    namemap = {}
    namemap["packagegroup-core-cmdline"] = "packagegroup-core-basic"
    namemap["packagegroup-core-cmdline-libs"] = "packagegroup-core-basic-libs"
    namemap["packagegroup-core-cmdline-utils"] = "packagegroup-core-basic-utils"
    namemap["packagegroup-core-cmdline-extended"] = "packagegroup-core-basic-extended"
    namemap["packagegroup-core-cmdline-dev-utils"] = "packagegroup-core-dev-utils"
    namemap["packagegroup-core-cmdline-multiuser"] = "packagegroup-core-multiuser"
    namemap["packagegroup-core-cmdline-sys-services"] = "packagegroup-core-sys-services"

    packages = d.getVar("PACKAGES", True).split()
    for pkg in packages:
        if pkg.endswith('-dev'):
            mapped = namemap.get(pkg[:-4], None)
            if mapped:
                mapped += '-dev'
        elif pkg.endswith('-dbg'):
            mapped = namemap.get(pkg[:-4], None)
            if mapped:
                mapped += '-dbg'
        else:
            mapped = namemap.get(pkg, None)

        if mapped:
            oldtaskname = mapped.replace("packagegroup-core", "task-core")
            mapstr = " %s %s" % (mapped, oldtaskname)
            d.appendVar("RPROVIDES_%s" % pkg, mapstr)
            d.appendVar("RREPLACES_%s" % pkg, mapstr)
            d.appendVar("RCONFLICTS_%s" % pkg, mapstr)
}

RDEPENDS_packagegroup-core-cmdline = "\
    packagegroup-core-cmdline-libs \
    packagegroup-core-cmdline-utils \
    packagegroup-core-cmdline-extended \
    packagegroup-core-cmdline-dev-utils \
    packagegroup-core-cmdline-multiuser \
    packagegroup-core-cmdline-sys-services \
    "

RDEPENDS_packagegroup-core-cmdline-libs = "\
    glib-2.0 \
    "

RDEPENDS_packagegroup-core-cmdline-utils = "\
    bash \
    acl \
    attr \
    bc \
    coreutils \
    cpio \
    e2fsprogs \
    ed \
    file \
    findutils \
    gawk \
    gmp \
    grep \
    makedevs \
    mktemp \
    ncurses \
    popt \
    sed \
    tar \
    time \
    util-linux \
    zlib \
    "

RDEPENDS_packagegroup-core-cmdline-extended = "\
    openssl \
    "

RDEPENDS_packagegroup-core-cmdline-dev-utils = "\
    byacc \
    diffutils \
    m4 \
    make \
    patch \
    "

RDEPENDS_packagegroup-core-cmdline-multiuser = "\
    shadow \
    sudo \
    "

RDEPENDS_packagegroup-core-cmdline-sys-services = "\
    bzip2 \
    dbus \
    dbus-glib \
    python-dbus \
    elfutils \
    pigz \
    less \
    libcap \
    libevent \
    nfs-utils \
    libpcre \
    rpcbind \
    tcp-wrappers \
    tzdata \
    "

repository: XavierBerger/oe-meta-container

repo_name: XavierBerger/oe-meta-container


text:
require bug-app.inc

DESCRIPTION = "This BUGapp tests the menubar and statusbar."
HOMEPAGE = "http://buglabs.net/applications/MenuSBTestCase"

DEPENDS += "com.buglabs.app.blueback com.buglabs.bug.menu com.buglabs.common "

PV = "2"

SRC_LINK = "http://buglabs.net/program_version/download/552"

APIVERSION = ""

COMPATIBLE_MACHINE = "bug"
PACKAGE_ARCH = "${MACHINE_ARCH}"

license: MIT

repository: overo/overo-oe-natty

license_type: permissive

repo_name: overo/overo-oe-natty

branch_name: HEAD

extension: bb


text:
@article{mbtagendergap2022,
  title = {Why Do Women Earn Less Than Men? Evidence from Bus and Train Operators},
  author={Bolotnyy, Valentin and Emanuel, Natalia},
  journal = {Journal of Labor Economics},
  year    = {2022},
  volume  = {40},
  number  = {2},
  pages   = {283-323},
  url     = {https://doi.org/10.1086/715835}
}

branch_name: refs/heads/master

extension: bib


text:
MACHINE = "poodle"
COMPATIBLE_HOST = "arm.*-linux"

require openzaurus-pxa_2.4.18-rmk7-pxa3-embedix20031107.inc


text:
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: image.proto

// 依照 https://cloud.google.com/apis/design/naming_convention 規範

package captainkube_v2

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type Image struct {
	Host                 string   `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	Repo                 string   `protobuf:"bytes,2,opt,name=repo,proto3" json:"repo,omitempty"`
	Tag                  string   `protobuf:"bytes,3,opt,name=tag,proto3" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Image) Reset()         { *m = Image{} }
func (m *Image) String() string { return proto.CompactTextString(m) }
func (*Image) ProtoMessage()    {}
func (*Image) Descriptor() ([]byte, []int) {
	return fileDescriptor_9624c68e2b547544, []int{0}
}

func (m *Image) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Image.Unmarshal(m, b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Image.Marshal(b, m, deterministic)
}
func (m *Image) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Image.Merge(m, src)
}
func (m *Image) XXX_Size() int {
	return xxx_messageInfo_Image.Size(m)
}
func (m *Image) XXX_DiscardUnknown() {
	xxx_messageInfo_Image.DiscardUnknown(m)
}

var xxx_messageInfo_Image proto.InternalMessageInfo

func (m *Image) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *Image) GetRepo() string {
	if m != nil {
		return m.Repo
	}
	return ""
}

func (m *Image) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

type ReTag struct {
	From                 string   `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
	To                   string   `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReTag) Reset()         { *m = ReTag{} }
func (m *ReTag) String() string { return proto.CompactTextString(m) }
func (*ReTag) ProtoMessage()    {}
func (*ReTag) Descriptor() ([]byte, []int) {
	return fileDescriptor_9624c68e2b547544, []int{1}
}

func (m *ReTag) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReTag.Unmarshal(m, b)
}
func (m *ReTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReTag.Marshal(b, m, deterministic)
}
func (m *ReTag) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReTag.Merge(m, src)
}
func (m *ReTag) XXX_Size() int {
	return xxx_messageInfo_ReTag.Size(m)
}
func (m *ReTag) XXX_DiscardUnknown() {
	xxx_messageInfo_ReTag.DiscardUnknown(m)
}

var xxx_messageInfo_ReTag proto.InternalMessageInfo

func (m *ReTag) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

func (m *ReTag) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

type RegistryAuth struct {
	Username             string   `protobuf:"bytes,1,opt,name=Username,proto3" json:"Username,omitempty"`
	Password             string   `protobuf:"bytes,2,opt,name=Password,proto3" json:"Password,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RegistryAuth) Reset()         { *m = RegistryAuth{} }
func (m *RegistryAuth) String() string { return proto.CompactTextString(m) }
func (*RegistryAuth) ProtoMessage()    {}
func (*RegistryAuth) Descriptor() ([]byte, []int) {
	return fileDescriptor_9624c68e2b547544, []int{2}
}

func (m *RegistryAuth) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegistryAuth.Unmarshal(m, b)
}
func (m *RegistryAuth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegistryAuth.Marshal(b, m, deterministic)
}
func (m *RegistryAuth) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegistryAuth.Merge(m, src)
}
func (m *RegistryAuth) XXX_Size() int {
	return xxx_messageInfo_RegistryAuth.Size(m)
}
func (m *RegistryAuth) XXX_DiscardUnknown() {
	xxx_messageInfo_RegistryAuth.DiscardUnknown(m)
}

var xxx_messageInfo_RegistryAuth proto.InternalMessageInfo

func (m *RegistryAuth) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *RegistryAuth) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func init() {
	proto.RegisterType((*Image)(nil), "softleader.captainkube.v2.Image")
	proto.RegisterType((*ReTag)(nil), "softleader.captainkube.v2.ReTag")
	proto.RegisterType((*RegistryAuth)(nil), "softleader.captainkube.v2.RegistryAuth")
}

func init() { proto.RegisterFile("image.proto", fileDescriptor_9624c68e2b547544) }

var fileDescriptor_9624c68e2b547544 = []byte{
	// 207 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x41, 0x4b, 0x86, 0x40,
	0x10, 0x86, 0xf9, 0xfc, 0x32, 0x6a, 0x0a, 0x89, 0x3d, 0x59, 0x27, 0xf1, 0x14, 0x04, 0x7b, 0xb0,
	0x5f, 0x60, 0x87, 0xa0, 0x5b, 0x48, 0x5d, 0xba, 0x8d, 0x3a, 0xae, 0x52, 0xeb, 0xc8, 0xee, 0x98,
	0xf4, 0xef, 0x63, 0xcd, 0x84, 0x0e, 0xdd, 0x9e, 0xf7, 0xdd, 0x87, 0x1d, 0x66, 0xe0, 0x62, 0xb0,
	0x68, 0x48, 0x4f, 0x8e, 0x85, 0xd5, 0xb5, 0xe7, 0x4e, 0x3e, 0x08, 0x5b, 0x72, 0xba, 0xc1, 0x49,
	0x70, 0x18, 0xdf, 0xe7, 0x9a, 0xf4, 0x67, 0x91, 0x97, 0x10, 0x3f, 0x05, 0x53, 0x29, 0x38, 0xe9,
	0xd9, 0x4b, 0x7a, 0xc8, 0x0e, 0xb7, 0xe7, 0xd5, 0xca, 0xa1, 0x73, 0x34, 0x71, 0x1a, 0xfd, 0x74,
	0x81, 0xd5, 0x15, 0x1c, 0x05, 0x4d, 0x7a, 0x5c, 0xab, 0x80, 0xf9, 0x1d, 0xc4, 0x15, 0xbd, 0xa0,
	0x09, 0x7a, 0xe7, 0xd8, 0xfe, 0xea, 0x81, 0x55, 0x02, 0x91, 0xf0, 0x66, 0x47, 0xc2, 0xf9, 0x23,
	0x5c, 0x56, 0x64, 0x06, 0x2f, 0xee, 0xab, 0x9c, 0xa5, 0x57, 0x37, 0x70, 0xf6, 0xea, 0xc9, 0x8d,
	0x68, 0x69, 0x1b, 0xbd, 0xe7, 0xf0, 0xf6, 0x8c, 0xde, 0x2f, 0xec, 0xda, 0xed, 0xcf, 0x3d, 0x3f,
	0x14, 0x90, 0xc9, 0xa2, 0x1b, 0xb6, 0xfa, 0xdf, 0xdd, 0xde, 0x92, 0xbf, 0xb9, 0x3e, 0x5d, 0xaf,
	0x71, 0xff, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xba, 0x48, 0xbd, 0x1c, 0x01, 0x00, 0x00,
}

repository: softleader/captain-kube

repo_name: softleader/captain-kube

gha_language: CSS

extension: go


text:
@article{salfnerSurvey,
 author = {Salfner, F. and Lenk, M. and Malek, M.},
 title = {A Survey of Online Failure Prediction Methods},
 journal = {ACM Comput. Surv.},
 issue_date = {March 2010},
 volume = {42},
 number = {3},
 month = mar,
 year = {2010},
 issn = {0360-0300},
 pages = {10:1--10:42},
 articleno = {10},
 numpages = {42},
 url = {http://doi.acm.org/10.1145/1670679.1670680},
 doi = {10.1145/1670679.1670680},
 acmid = {1670680},
 publisher = {ACM},
 address = {New York, NY, USA},
 annotate = {
   There isn't really a problem statement since this is a survey, but in
   general, machines tend to fail for many reasons.  The methods described in
   this survey are for predicting failure in real-time (as opposed to
   before-hand statistical analysis).  Again, many approaches and solutions are
   presented in this survey.  Our focus is on the machine learning approaches
   that focus on error messages (or log messages).  The key takeaway for our
   work is that this helps set the stage for our problem.
 }
}

@article{irrera2015,
 author = {Irrera, I. and Vieira, M. and Duraes, J.},
 doi = {10.1109/HASE.2015.29},
 isbn = {978-1-4799-8111-3},
 journal = {2015 IEEE 16th International Symposium on High Assurance Systems Engineering},
 pages = {142--149},
 title = {{Adaptive Failure Prediction for Computer Systems: A Framework and a Case Study}},
 url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=7027425},
 year = {2015},
 annotate = {
   The problem this paper attempts to solve is that many failure prediction
   techniques have been developed and shown to be effective but they have not
   been implemented on production machines.  The authors present a framework
   and then demonstrate its efficacy by doing a case study.  The key takeaway
   for our work is that our work enables the extension of this framework for a
   distributed environment.
 }
}

@article{irrera2014,
 author = {Irrera, I. and Vieira, M.},
 doi = {10.1109/PRDC.2014.19},
 isbn = {978-1-4799-6474-1},
 journal = {2014 IEEE 20th Pacific Rim International Symposium on Dependable Computing},
 pages = {86--95},
 title = {{A Practical Approach for Generating Failure Data for Assessing and Comparing Failure Prediction Algorithms}},
 url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=6974775},
 year = {2014},
 annotate = {
   This paper suggests that machine learning based failure prediction methods
   must be trained using known failure data, but those data are hard to find.
   This paper suggests a method for generating those data using software fault
   injection and simulated load.  The key takeaway for our work is that this
   helps establish the need for a load generator.
 }
}

@article{irrera2010,
 author = {Irrera, I. and Duraes, J. and Vieira, M. and Madeira, H.},
 doi = {10.1109/PRDC.2010.51},
 isbn = {978-1-4244-8975-6},
 journal = {2010 IEEE 16th Pacific Rim International Symposium on Dependable Computing},
 pages = {3--10},
 title = {{Towards Identifying the Best Variables for Failure Prediction Using Injection of Realistic Software Faults}},
 url = {http://dl.acm.org/citation.cfm?id=1935935.1935974},
 year = {2010},
 annotate = {
   The problem presented in this paper is that identifying the proper variables
   to conduct failure prediction is difficult.  The paper presents a
   methodology for identifying the variables that should be used to predict
   failure by injecting software faults.  The authors then conduct two
   experiments to test their approach.  The key takeaway for our work is that
   this paper helps establish the need for a load generator in failure
   prediction.
 }
}

@article{irrera2013,
 author = {Irrera, I. and Duraes, J. and Madeira, H. and Vieira, M.},
 doi = {10.1109/LADC.2013.24},
 isbn = {9780769549620},
 journal = {Proceedings - 6th Latin-American Symposium on Dependable Computing, LADC 2013},
 pages = {92--97},
 title = {{Assessing the impact of virtualization on the generation of failure prediction data}},
 year = {2013},
 annotate = {
   The problem this paper suggests is that in order to conduct online failure
   prediction using machine learning in real-time, one must train a machine
   learning algorithm with real failure data.  Unfortunately, production
   systems do not fail very often and injecting failures into production
   systems is unacceptable.  The paper suggests that virtualization is a cheap
   alternative for injecting faults and collecting failure data to train
   prediction models.  The authors compare failure data collected from live
   systems with failure data collected from virtualized systems.  This paper
   helps us establish that it's okay to virtualize our experiment.
 }
}

@article{gswfit,
 author={Duraes, J. and Madeira, H.},
 journal={Software Engineering, IEEE Transactions on},
 title={Emulation of Software Faults: A Field Data Study and a Practical Approach},
 year={2006},
 volume={32},
 number={11},
 pages={849-867},
 doi={10.1109/TSE.2006.113},
 ISSN={0098-5589},
 month={Nov},
 annotate = {
   This paper suggests that fault injection is used, but is not well
   understood.  The paper goes on to thoroughly analyze and formalize a
   technique for software fault injection.  The paper then conducts a field
   study to demonstrate how well the method works on real software.  The key
   takeaway here is that it reinforces why we are developing a load generator.
 }
}

@article{watanabe2012,
 author = {Watanabe, Y. and Otsuka, H. and Sonoda, M. and Kikuchi, S. and Matsumoto, Y.},
 doi = {10.1109/CloudCom.2012.6427566},
 isbn = {9781467345095},
 journal = {CloudCom 2012 - Proceedings: 2012 4th IEEE International Conference on Cloud Computing Technology and Science},
 pages = {504--511},
 title = {{Online failure prediction in cloud datacenters by real-time message pattern learning}},
 url = {http://www.scopus.com/inward/record.url?eid=2-s2.0-84874230901{\&}partnerID=40{\&}md5=da33be4c2acd9f17e2646ced46fa4120},
 year = {2012},
 annotate = {
   In this paper, it is suggested that nodes fail in cloud data centers and
   conventional machine learning techniques do not work well due to the fact
   that there is no guarantee as to the order in which reported error messages
   are received.  The paper then presents results from a case study conducted
   using the method presented.  The key takeaway here will be to compare and
   contrast our method with this one.
 }
}

@article{watanabe2014,
 author = {Watanabe, Y.},
 number = {1},
 pages = {66--71},
 title = {{Online Failure Prediction in Cloud Datacenters}},
 volume = {50},
 year = {2014},
 annotate = {
   This paper suggests that failure prediction in cloud data-centers is a
   difficult task.  It presents a new way of doing failure prediction in cloud
   data-centers and then reports results and performance metrics from an
   experiment conducted using the new method.  Our work will compare and
   contrast this method with ours.
 }
}

@article{sonoda2012,
 author = {Sonoda, M. and Watanabe, Y. and Matsumoto, Y.},
 doi = {10.1109/NOMS.2012.6211960},
 isbn = {1542-1201 VO  -},
 journal = {Network Operations and Management Symposium (NOMS), 2012 IEEE},
 number = {4},
 pages = {578--581},
 title = {{Prediction of failure occurrence time based on system log message pattern learning}},
 year = {2012},
 annotate = {
   This paper suggests that failure prediction in cloud data-centers is
   difficult because there is no guarantee on the order in which reported
   errors are received.  The paper reports results from an experiment conducted
   using the method presented.  This paper offers a comparison for our method.
 }
}

@article{irrera2013_2,
 author = {Irrera, I. and Pereira, C. and Vieira, M.},
 doi = {10.1109/LADC.2013.25},
 isbn = {978-1-4673-5746-3},
 journal = {2013 Sixth Latin-American Symposium on Dependable Computing},
 pages = {86--91},
 title = {{The Time Dimension in Predicting Failures: A Case Study}},
 url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=6542609},
 year = {2013},
 annotate = {
   This paper suggests that the time-dimension makes predicting failures using
   a Support Vector Machine difficult and provides a technique for accounting
   for this difficulty.  The authors then conduct a case study to test their
   method and report findings.  The key takeaway for our work is that it
   reinforces our reason for developing a load generator.
 }
}

@INPROCEEDINGS{avallone2004,
 author={Avallone, S. and Guadagno, S. and Emma, D. and Pescape, A. and Ventre, G.},
 booktitle={Quantitative Evaluation of Systems, 2004. QEST 2004. Proceedings.  First International Conference on the},
 title={{D-ITG distributed Internet traffic generator}},
 year={2004},
 pages={316-317},
 doi={10.1109/QEST.2004.1348045},
 month={Sept},
 annotate={
    This paper provides a new solution to traffic generation. The authors
    implemented a traffic generator that emulates various network protocols
    and the Inter Departure Time and Packet Size random variables for the
    traffic. The authors compare the performance of their software with other
    traffic generators and provide a brief analysis of the performances. This
    paper offers another comparison for our method.
 }
}

@INPROCEEDINGS{antichi2008,
 author={Antichi, G. and Di Pietro, A. and Ficara, D. and Giordano, S. and Procissi, G. and Vitucci, F.},
 booktitle={Digital System Design Architectures, Methods and Tools, 2008. DSD '08. 11th EUROMICRO Conference on},
 title={Design of a High Performance Traffic Generator on Network Processor},
 year={2008},
 pages={438-441},
 doi={10.1109/DSD.2008.36},
 month={Sept},
 annotate={
    It is suggested in this paper that the currently available, PC-based network
    traffic generators are not able to adequately replicate realistic traffic on
    high-speed networks. The authors present their solution of implementing the
    BRUTE traffic generator on an Intel Network Processor. They only present the
    proposed design and architecture of their traffic generator solution, leaving
    actual implementation and performance tests to future work. This paper offers
    inspiration for possible future iterations and eventual improvements of our
    method.
 }
}

@INPROCEEDINGS{vasic2012,
 author={Vasic, V. and Suznjevic, M. and Mikuc, M. and Matijasevic, M.},
 booktitle={Software, Telecommunications and Computer Networks (SoftCOM), 2012 20th International Conference on},
 title={Improving distributed traffic generation performance by using IMUNES network emulator},
 year={2012},
 pages={1-5},
 month={Sept},
 annotate={
   There is no specific problem stated in this paper except to improve on the
   authors' previously implemented network traffic generator. The authors do
   so by implementing the Integrated Multiprotocol Network Emulator/Simulator
   as the network emulator used. The authors then report on the results of
   experiments run using the methodology detailed. This paper will serve as
   a comparison for our method.
 }
}

@INPROCEEDINGS{molnar2013,
 author={Molnar, S. and Megyesi, P. and Szabo, G.},
 booktitle={Communications Workshops (ICC), 2013 IEEE International Conference on},
 title={How to validate traffic generators?},
 year={2013},
 pages={1340-1344},
 doi={10.1109/ICCW.2013.6649445},
 month={June},
 annotate={
   This paper is more of a survey of network traffic generators and does not
   provide a solution to a specific problem, but rather advocates that the
   community adopt a standardized validation method for traffic generating tools.
   This paper provides insight into a number of methods to validate our tool
   and gives insight into the numerous validation processes.
 }
}

@article{vishwanath2009,
  author = {Vishwanath, K. and Vahdat, A.},
  doi = {10.1109/TNET.2009.2020830},
  isbn = {1595933085},
  issn = {10636692},
  journal = {IEEE/ACM Transactions on Networking},
  keywords = {Burstiness,Modeling,Structural model,Traffic generator,Wavelet scaling},
  number = {3},
  pages = {712--725},
  title = {{Swing: Realistic and responsive network traffic generation}},
  volume = {17},
  year = {2009},
  annotate = {
    The problem this paper suggests is that traffic generators should accurately
    reflect real-world variances, distributions, bandwidth, and burstiness. The
    authors present their tool, Swing, which generates traffic based on characteristics
    observed from a given network's behavior. They present the results of their
    tool and discuss whether their tool fully achieves the goal introduced by
    the paper. This paper provides us with a method to compare and contrast our
    tool and more ways to analyze our results.
  }
}

@inproceedings{albrecht2009,
  author = {Albrecht, C. and Osterloh, C. and Pionteck, T. and Koch, R.},
  booktitle = {22nd European Conference on Modelling and Simulation.},
  isbn = {9780955301858},
  keywords = {packet flow models,synthetic workload generation,traffic generator},
  title = {{An Application-Oriented Synthetic Network Traffic Generator}},
  year = {2009},
  annotate = {
    This paper proposes that current traffic generators do not do a good job of
    testing network hardware in a realistic manner. The authors introduce their
    tool that generates multiple types of network traffic and varies the ammount
    and timing of the traffic based on models. They provide results from
    experiments conducted with their tool along with analysis and comparisons to
    other traffic generators available. This paper provides a comparison for our
    method.
  }
}

@article{zach2013,
  author = {Zach, P. and Pokorny, M. and Motycka, A.},
  isbn = {978-960-474-341-4},
  issn = {1790-5117},
  journal = {Recent Advances in Circuits, Systems, Telecommunications and Control},
  pages = {244--251},
  title = {{Design of Software Network Traffic Generator}},
  year = {2013},
  annotate = {
    The authors of this paper propose that network traffic generators fall into
    specific categories, each with a specific purpose. They attempt to create
    a hybrid solution which spans multiple categories. The authors conduct a
    case study using their tool and provide results and comparisons with other
    popular traffic generation tools. This paper will provide another method to
    compare and contrast with ours.
  }
}

@article{botta2012,
	author = {Botta, A. and Dainotti, A. and Pescap{\'{e}}, A.},
	issn = {13891286},
	journal = {Computer Networks},
	mendeley-groups = {Distributed Systems Project},
	number = {15},
	pages = {3531--3547},
	publisher = {Elsevier B.V.},
	title = {{A tool for the generation of realistic network workload for emerging networking scenarios}},
	volume = {56},
	year = {2012}
}

@Online{brasser15,
  title = {Script Connect-Mstsc - Open RDP Session with credentials},
  author = {Brasser, J.},
  organization = {},
  url = {https://gallery.technet.microsoft.com/scriptcenter/Connect-Mstsc-Open-RDP-2064b10b},
  urldate = {2016-02-27},
  year = {2015}
}

@Online{szeto12,
  title = {{Debug Assertion Failed: sockcore.cpp, line 623}},
  author = {Szeto, A.},
  organization = {Microsoft},
  url = {https://social.technet.microsoft.com/Forums/windowsserver/en-US/2f8fa5cf-3714-4eb3-a895-c30e2b26862d/debug-assertion-failed-sockcorecpp-line-623},
  urldate = {2016-02-27},
  year = {2012}
}

@Online{jordan16,
  title = {AFP-DC - GitHub},
  author = {Jordan, P. and Van Patten, D.},
  note = {https://github.com/paullj1/afp-dc/tree/master/Load},
  urldate = {2016-02-27},
  year = {2016}
}

@Online{mak12,
  title = {Capacity Planning for Active Directory Domain Services},
  author = {Makbuloğlu, S and Geelen, G},
  publisher = {TechNet},
  organization = {Microsoft},
  urldate = {2016-03-01},
  year = {2012}
}

@book{bijaoui2011,
	author = {Bijaoui, P},
	isbn = {9780080491851},
	pages = {473--474},
	publisher = {Elsevier Science},
	series = {HP Technologies},
	title = {{Microsoft Exchange Server 2003 Scalability with SP1 and SP2}},
	year = {2011}
}

@Online{suyanto2010,
	author = {Suyanto, H. and Tiwari, M.},
	title = {{Windows 2008 AD LDS Load Testing using ADTEST - Part 1 - TechNet Articles}},
	organization = {Microsoft},
	url = {http://social.technet.microsoft.com/wiki/contents/articles/1890.windows-2008-ad-lds-load-testing-using-adtest-part-1.aspx},
	urldate = {2016-03-03},
	year = {2010}
}

@Online{suyanto2010_2,
	author = {Suyanto, H. and Tiwari, M.},
	title = {{Windows 2008 AD LDS Load Testing using ADTEST - Part 2 - TechNet Articles}},
	organization = {Microsoft},
	url = {http://social.technet.microsoft.com/wiki/contents/articles/1891.windows-2008-ad-lds-load-testing-using-adtest-part-2.aspx},
	urldate = {2016-03-03},
	year = {2010}
}

@misc{morowczynski2014,
	author = {Morowczynski, Mark},
	title = {{How To Use the Active Directory Performance Testing Tool on Windows Server 2012 | Ask Premier Field Engineering (PFE) Platforms}},
	organization = {Microsoft},
	url = {https://blogs.technet.microsoft.com/askpfeplat/2014/02/09/how-to-use-the-active-directory-performance-testing-tool-on-windows-server-2012/},
	urldate = {2016-03-03},
	year = {2014}
}

@article{weigle2006,
author = {Weigle, M. and Adurthi, P. and Hernández-Campos, F. and Jeffay, K. and Smith, F.},
journal = {ACM SIGCOMM Computer Communication Review},
number = {3},
pages = {67--76},
title = {{Tmix: A Tool for Generating Realistic TCP Application Workloads in ns-2}},
volume = {36},
year = {2006}
}


text:
package code

func flipAndInvertImage(A [][]int) [][]int {
	for _, a := range A {
		left, right := 0, len(a)-1
		for left < right {
			if a[left] == a[right] {
				a[left] ^= 1
				a[right] ^= 1
			}
			left++
			right--
		}
		if left == right {
			a[left] ^= 1
		}
	}
	return A
}

repository: bigsoldier/leetcode-go

repo_name: bigsoldier/leetcode-go


text:
@article{Malkin1998,
author = {Malkin, Irad},
journal = {Kernos},
pages = {131--141},
title = {{The Middle Ground: Philoktetes in Italy}},
volume = {11},
year = {1998}
}
@book{Tsetskhladze2004,
address = {Oxford},
author = {Tsetskhladze, Gocha R. and {De Angelis}, Franco},
publisher = {Oxford University School of Archaeology},
title = {{The archaeology of Greek colonisation: essays dedicated to Sir John Boardman}},
year = {2004}
}
@article{Woolf1997,
abstract = {Abstract Revisionist studies of Roman imperialism and Romanization continue to show the traces of modern debates on imperialism and colonialism, in particular a tendency to analyse cultural change in terms of the interaction of two ethnic cultures. An analysis of the changing unities and diversities of cultures in Gaul (modern France), and of the transformation of Roman culture during and as a result of imperial expansion, suggests a new view of the nature and genesis of Roman imperial culture.},
annote = {doi: 10.1080/00438243.1997.9980352},
author = {Woolf, Greg},
journal = {World Archaeology},
month = {feb},
number = {3},
pages = {339--350},
publisher = {Routledge},
title = {{Beyond Romans and natives}},
volume = {28},
year = {1997}
}
@misc{Dietler1998,
abstract = {The Archaeology of Social Boundaries demonstrates that the search for social boundaries in material culture patterning can benefit from the study of both technological and stylistic qualities. Fourteen contributors examine an array of media -- from ceramics and personal ornaments to architecture and site structure -- in small-scale societies and apply methods from both sides of the Atlantic to explore how technical choices made in the creation of everyday objects can both reflect and define social boundaries. By uniting two disparate intellectual traditions, this book contributes to a growing archaeological theory of material culture.},
author = {Dietler, M. and Herbich, I.},
booktitle = {The Archaeology of Social Boundaries},
file = {:home/petra/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Dietler, Herbich - 1998 - Habitus, techniques, style An integrated approach to the social understanding of material culture and boundari.pdf:pdf},
isbn = {9781560987796},
pages = {232--263},
title = {{Habitus, techniques, style: An integrated approach to the social understanding of material culture and boundaries}},
year = {1998}
}
@book{Wallerstein1974,
address = {New York, London},
author = {Wallerstein, I.},
publisher = {Academic Press},
title = {{The Modern World-system. I, Capitalist Agriculture and the Origins of the European World-Economy in the Sixteenth Century}},
year = {1974}
}
@article{Sam2015,
author = {Sam, David L},
doi = {10.1016/B978-0-08-097086-8.24034-8},
file = {:home/petra/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Sam - 2015 - Acculturation.pdf:pdf},
isbn = {9780080970868},
journal = {International Encyclopedia of the Social {\&} Behavioral Sciences},
pages = {68--74},
title = {{Acculturation}},
url = {http://linkinghub.elsevier.com/retrieve/pii/B9780080970868240348},
volume = {1},
year = {2015}
}
@article{Malkin2004,
abstract = {Middle ground theory and networking in Sicily},
author = {Malkin, Irad},
file = {:home/petra/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Malkin - 2004 - Postcolonial Concepts and Ancient Greek Colonization.pdf:pdf},
journal = {Modern Language Quarterly},
number = {3},
pages = {341 -- 364},
title = {{Postcolonial Concepts and Ancient Greek Colonization}},
volume = {65},
year = {2004}
}
@article{Cicikova2011,
address = {Kazanlak},
annote = {PDF},
author = {{\v{C}}i{\v{c}}ikova, M},
pages = {116--121},
journal = {{Varia Thracica}},
title = {{Missing}},
year = {2011}
}
@book{Chichikova1978,
address = {Oxford},
author = {Chichikova, Maria and Dimitrov, Dimitur P. and Alexieva, Marguerite and Janouchova, Petra},
isbn = {0-86054-003-0},
keywords = {Seuthopolis,Thracians},
language = {eng},
publisher = {BAR Supplementary Series 38},
title = {{The Thracian city of Seuthopolis}},
year = {1978}
}


text:
require flask-restful.inc

PR = "${INC_PR}.1"

inherit python3native
DEPENDS += "python3-setuptools-native"
RDEPENDS_${PN} += "python3-aniso8601 python3-flask python3-six python3-tz"

repository: meta-debian/meta-debian-extra

repo_name: meta-debian/meta-debian-extra

branch_name: refs/heads/morty

gha_license_id: MIT

gha_language: BitBake


text:
DESCRIPTION = "USB DVB driver for DW210x/DW310x chipset"

DVBPROVIDER ?= "v4l-dvb"

RDEPENDS_${PN} = " \
	${DVBPROVIDER}-module-dvb-usb-dw2102 \
	firmware-dvb-usb-s660 \
	firmware-dvb-fe-ds3000 \
	"

PV = "1.0"
PR = "r0"

ALLOW_EMPTY_${PN} = "1"

gha_language: C


text:
DESCRIPTION = "UNIX Shell similar to the Korn shell"
HOMEPAGE="http://www.zsh.org"
SECTION = "base/shell"

LICENSE = "ZSH"
LIC_FILES_CHKSUM = "file://LICENCE;md5=ad234d4b46db63491c4a9789da4fb341"

DEPENDS = "ncurses libcap libpcre gdbm groff-native"

SRC_URI = "ftp://ftp.zsh.org/pub/${P}.tar.bz2"
SRC_URI[md5sum] = "8258967060b2654f30001a011946ac6a"
SRC_URI[sha256sum] = "054e0452afd9c742c9f1489465175e1d4d7db50d88b602d132551d850cf7a704"

FILES_${PN}-dbg += "\
    ${libdir}/${PN}/${PV}/${PN}/.debug/*.so \
    ${libdir}/${PN}/${PV}/${PN}/db/.debug/*.so \
    ${libdir}/${PN}/${PV}/${PN}/net/.debug/*.so \
    "

inherit autotools

EXTRA_OECONF = " \
    --bindir=${base_bindir} \
    --enable-etcdir=${sysconfdir} \
    --enable-fndir=${datadir}/${PN}/${PV}/functions \
    --enable-site-fndir=${datadir}/${PN}/site-functions \
    --enable-function-subdirs \
    --with-term-lib='ncursesw ncurses' \
    --with-tcsetpgrp \
    --enable-pcre \
    --enable-cap \
    --enable-multibyte \
    --enable-gdbm \
    --enable-dynamic \
    zsh_cv_shared_environ=yes \
    "

do_configure () {
    oe_runconf
}

pkg_postinst_${PN} () {
    touch $D${sysconfdir}/shells
    grep -q "bin/zsh" $D${sysconfdir}/shells || echo "/bin/zsh" >> $D${sysconfdir}/shells
}

pkg_postrm_${PN} () {
    if [ -e $D${sysconfdir}/shells ]; then
        sed -i -e '/\/bin\/zsh/d' $D${sysconfdir}/shells
    fi
}

repository: tworaz/oe-tworaz

repo_name: tworaz/oe-tworaz

gha_language: Shell


text:
// Package npm exposes a simple set of functions for running npm install
// and other npm scripts in a given project.
package npm

import (
	"github.com/clearblade/cbtest"
	"github.com/stretchr/testify/require"
)

// Use creates a new *NPMTransaction.
// Panics on failure.
func Use(t cbtest.T, dir string) *Transaction {
	t.Helper()
	tran, err := NewTransaction(t, dir, true)
	require.NoError(t, err)
	return tran
}

// UseE creates a new *NPMTransaction.
// Returns error on failure.
func UseE(t cbtest.T, dir string) (*Transaction, error) {
	t.Helper()
	return NewTransaction(t, dir, false)
}

repository: ClearBlade/cbtest

repo_name: ClearBlade/cbtest

gha_language: Go


text:
package flags

import (
	"fmt"
	"github.com/urfave/cli/v2"
	"os"
)

var (
	Flags []cli.Flag
)

func LoadFlags() error {
	cli.VersionPrinter = printVersion

	home, err := os.UserHomeDir()
	if err != nil {
		return err
	}

	configPath := fmt.Sprintf("%s/.%s.yaml", home, "trdeploy")
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		configPath = fmt.Sprintf("/etc/%s.yaml", "trdeploy")
	}

	Flags = []cli.Flag{}

	return nil
}

var TName = &cli.StringFlag{
	Name:  TableName,
	Usage: "table name",
	Required: true,
}

var ItemKey = &cli.StringFlag{
	Name:  Key,
	Usage: "key",
	Required: true,
}

var ItemAttr = &cli.StringFlag{
	Name:  ItemAttributes,
	Usage: "item attributes",
	Required: true,
}

var TableAttr = &cli.StringFlag{
	Name:  TableAttributes,
	Usage: "table attributes",
	Required: true,
}

var Pref = &cli.StringFlag{
	Name:  Prefix,
	Usage: "prefix",
}

repository: KseniyaRomanchik/dynamo

repo_name: KseniyaRomanchik/dynamo

branch_name: refs/heads/dev


text:
# we use a fixed SRCDATE, our patches don't allow a flexible SRCDATE controlled by the distro
SRCDATE = "20090130"

require libtuxtxt.bb

PN = "libtuxtxt"
PROVIDES += "libtuxtxt-enigma2"
RPROVIDES_${PN} += "libtuxtxt-enigma2"

OVERRIDES_append = ":libtuxtxt-enigma2"

SRC_URI_append = " \
	file://32bpp.diff \
	file://resize_framebuffer.diff \
	file://allow_different_demux.diff \
	file://fastclear.diff \
	"

repository: libo/openembedded

repo_name: libo/openembedded


text:
package pq

import (
	"testing"
)

func TestSimpleParseURL(t *testing.T) {
	expected := "host='hostname.remote'"
	str, err := ParseURL("postgres://hostname.remote")
	if err != nil {
		t.Fatal(err)
	}

	if str != expected {
		t.Fatalf("unexpected result from ParseURL:\n+ %v\n- %v", str, expected)
	}
}

func TestIPv6LoopbackParseURL(t *testing.T) {
	expected := "host='::1' port='1234'"
	str, err := ParseURL("postgres://[::1]:1234")
	if err != nil {
		t.Fatal(err)
	}

	if str != expected {
		t.Fatalf("unexpected result from ParseURL:\n+ %v\n- %v", str, expected)
	}
}

func TestFullParseURL(t *testing.T) {
	expected := `dbname='database' host='hostname.remote' password='top secret' port='1234' user='username'`
	str, err := ParseURL("postgres://username:top%20secret@hostname.remote:1234/database")
	if err != nil {
		t.Fatal(err)
	}

	if str != expected {
		t.Fatalf("unexpected result from ParseURL:\n+ %s\n- %s", str, expected)
	}
}

func TestInvalidProtocolParseURL(t *testing.T) {
	_, err := ParseURL("http://hostname.remote")
	switch err {
	case nil:
		t.Fatal("Expected an error from parsing invalid protocol")
	default:
		msg := "invalid connection protocol: http"
		if err.Error() != msg {
			t.Fatalf("Unexpected error message:\n+ %s\n- %s",
				err.Error(), msg)
		}
	}
}

func TestMinimalURL(t *testing.T) {
	cs, err := ParseURL("postgres://")
	if err != nil {
		t.Fatal(err)
	}

	if cs != "" {
		t.Fatalf("expected blank connection string, got: %q", cs)
	}
}

repository: lib/pq

repo_name: lib/pq


text:
@article{donhauser2014local,
  title={Local and long-range phase-amplitude coupling in a cortical spiking network model},
  author={Donhauser, Peter W and Baillet, Sylvain},
  journal={BMC neuroscience},
  volume={15},
  number={1},
  pages={P222},
  year={2014},
  publisher={BioMed Central}
}

repository: pwdonh/starter-academic

repo_name: pwdonh/starter-academic


text:
// Copyright The OpenTelemetry 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 mongodbreceiver // import "github.com/GoogleCloudPlatform/opentelemetry-operations-collector/receiver/mongodbreceiver"

import (
	"context"
	"os"
	"testing"

	"github.com/stretchr/testify/require"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/integration/mtest"
	"go.uber.org/zap"
)

func TestListDatabaseNames(t *testing.T) {
	mont := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
	defer mont.Close()

	mont.Run("list database names", func(mt *mtest.T) {
		// mocking out a listdatabase call
		mt.AddMockResponses(mtest.CreateSuccessResponse(
			primitive.E{
				Key: "databases",
				Value: []struct {
					Name string `bson:"name,omitempty"`
				}{
					{
						Name: "admin",
					},
				},
			}))
		driver := mt.Client
		client := &mongodbClient{
			Client: driver,
		}
		dbNames, err := client.ListDatabaseNames(context.Background(), bson.D{})
		require.NoError(t, err)
		require.Equal(t, dbNames[0], "admin")
	})

}

type commandString = string

const (
	dbStatsType      commandString = "dbStats"
	serverStatusType commandString = "serverStatus"
	topType          commandString = "top"
)

func TestRunCommands(t *testing.T) {
	mont := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
	defer mont.Close()

	loadedDbStats, err := loadDBStats()
	require.NoError(t, err)
	loadedServerStatus, err := loadServerStatus()
	require.NoError(t, err)
	loadedTop, err := loadTop()
	require.NoError(t, err)

	testCases := []struct {
		desc     string
		cmd      commandString
		response bson.D
		validate func(*testing.T, bson.M)
	}{
		{
			desc:     "dbStats success",
			cmd:      dbStatsType,
			response: loadedDbStats,
			validate: func(t *testing.T, m bson.M) {
				require.Equal(t, float64(16384), m["indexSize"])
			},
		},
		{
			desc:     "serverStatus success",
			cmd:      serverStatusType,
			response: loadedServerStatus,
			validate: func(t *testing.T, m bson.M) {
				require.Equal(t, int32(0), m["mem"].(bson.M)["mapped"])
			},
		},
		{
			desc:     "top success",
			cmd:      topType,
			response: loadedTop,
			validate: func(t *testing.T, m bson.M) {
				require.Equal(t, int32(540), m["totals"].(bson.M)["local.oplog.rs"].(bson.M)["commands"].(bson.M)["time"])
			},
		},
	}

	for _, tc := range testCases {
		mont.Run(tc.desc, func(mt *mtest.T) {
			mt.AddMockResponses(tc.response)
			driver := mt.Client
			client := mongodbClient{
				Client: driver,
				logger: zap.NewNop(),
			}
			var result bson.M
			switch tc.cmd {
			case serverStatusType:
				result, err = client.ServerStatus(context.Background(), "test")
			case dbStatsType:
				result, err = client.DBStats(context.Background(), "test")
			case topType:
				result, err = client.TopStats(context.Background())
			}
			require.NoError(t, err)
			if tc.validate != nil {
				tc.validate(t, result)
			}
		})
	}
}

func TestGetVersion(t *testing.T) {
	mont := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
	defer mont.Close()

	buildInfo, err := loadBuildInfo()
	require.NoError(t, err)

	mont.Run("test connection", func(mt *mtest.T) {
		mt.AddMockResponses(
			// retrieving build info
			buildInfo,
		)

		driver := mt.Client
		client := mongodbClient{
			Client: driver,
			logger: zap.NewNop(),
		}

		version, err := client.GetVersion(context.TODO())
		require.NoError(t, err)
		require.Equal(t, "4.4.10", version.String())
	})
}

func TestGetVersionFailures(t *testing.T) {
	mont := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
	defer mont.Close()

	malformedBuildInfo := bson.D{
		primitive.E{Key: "ok", Value: 1},
		primitive.E{Key: "version", Value: 1},
	}

	testCases := []struct {
		desc         string
		responses    []primitive.D
		partialError string
	}{
		{
			desc:         "Unable to run buildInfo",
			responses:    []primitive.D{mtest.CreateCommandErrorResponse(mtest.CommandError{})},
			partialError: "unable to get build info",
		},
		{
			desc:         "unable to parse version",
			responses:    []primitive.D{mtest.CreateSuccessResponse(), malformedBuildInfo},
			partialError: "unable to parse mongo version from server",
		},
	}

	for _, tc := range testCases {
		mont.Run(tc.desc, func(mt *mtest.T) {
			mt.AddMockResponses(tc.responses...)
			driver := mt.Client
			client := mongodbClient{
				Client: driver,
				logger: zap.NewNop(),
			}

			_, err := client.GetVersion(context.TODO())
			require.Error(t, err)
			require.Contains(t, err.Error(), tc.partialError)
		})
	}

}

func loadDBStats() (bson.D, error) {
	return loadTestFile("./testdata/dbstats.json")
}

func loadServerStatus() (bson.D, error) {
	return loadTestFile("./testdata/serverStatus.json")
}

func loadTop() (bson.D, error) {
	return loadTestFile("./testdata/top.json")
}

func loadBuildInfo() (bson.D, error) {
	return loadTestFile("./testdata/buildInfo.json")
}

func loadTestFile(filePath string) (bson.D, error) {
	var doc bson.D
	testFile, err := os.ReadFile(filePath)
	if err != nil {
		return nil, err
	}
	err = bson.UnmarshalExtJSON(testFile, true, &doc)
	if err != nil {
		return nil, err
	}
	return doc, nil
}


text:
DESCRIPTION = "nEo shr theme - a very fast, high contrast shr theme"
SECTION = "x11/data"
HOMEPAGE = "http://jmccloud.jm.funpic.de"
AUTHOR = "Jesus McCloud <bernd.pruenster@gmail.com"
RDEPENDS_${PN} = "phoneui-shr-theme-neo elementary-theme-neo e-wm-theme-illume-neo gtk-theme-neo gpe-theme-neo icon-theme-neo"
LICENSE = "unknown"

PV = "0.2"
PR = "r5"
PACKAGE_ARCH = "all"

ALLOW_EMPTY = "1"


text:
package model

import (
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/utils"

	"strings"
)

type CreateMetaCert struct {

	// 证书名称。
	Name string `json:"name"`
}

func (o CreateMetaCert) String() string {
	data, err := utils.Marshal(o)
	if err != nil {
		return "CreateMetaCert struct{}"
	}

	return strings.Join([]string{"CreateMetaCert", string(data)}, " ")
}

gha_license_id: NOASSERTION


text:
DESCRIPTION = "Task to add multimedia related sources into the SDK"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/COPYING.MIT;md5=3da9cfbcb788c80a0384361b4de20420"
PR = "r0"

inherit task
PACKAGE_ARCH = "${MACHINE_ARCH}"

MULTIMEDIA = ""

MULTIMEDIA_append_am37x-evm = " \
    av-examples-src \
"

MULTIMEDIA_append_am3517-evm = " \
    av-examples-src \
"

RDEPENDS_${PN} = "\
    ${MULTIMEDIA} \
"

repository: ejhayes/meta-arago

repo_name: ejhayes/meta-arago


text:
@article{Leroux-2020-Simulation,
    title = "Simulation of Preferential Flow in Snow With a 2‐D Non‐Equilibrium Richards Model and Evaluation Against Laboratory Data",
    author = "Leroux, Nicolas R.  and
      Marsh, Christopher B.  and
      Pomeroy, John W.",
    journal = "Water Resources Research, Volume 56, Issue 9",
    volume = "56",
    number = "9",
    year = "2020",
    publisher = "American Geophysical Union (AGU)",
    url = "https://aclanthology.org/G20-41003",
    doi = "10.1029/2020wr027466",
    abstract = "",
}

repository: gwf-uwaterloo/gwf-publications

repo_name: gwf-uwaterloo/gwf-publications

branch_name: refs/heads/main

gha_language: Python


text:
DESCRIPTION = "HFS file system utilities"
SECTION = "base"
LICENSE = "GPL"
PR = "r2"

inherit autotools pkgconfig

SRC_URI = "ftp://ftp.mars.org/pub/hfs/hfsutils-3.2.6.tar.gz \
	   file://hfsutils-3.2.6-errno.patch \
	   file://largerthan2gb.patch \
		"

do_configure () {
	oe_runconf --disable-x
}

do_compile () {
	oe_runmake
	cd hfsck; oe_runmake
}

do_install () {
	install -d ${D}/${bindir}
	install -m 755 hfsutil ${D}/${bindir}/hfsutil
	install -m 755 hfsck/hfsck ${D}/${bindir}/hfsck

	for util in hattrib hcd hcopy hdel hdir hformat \
		    his hmkdir hmount hpwd hrename hrmdir \
		    humount hvol; do
		ln -sf hfsutil ${D}/${bindir}/${util}
	done
}

SRC_URI[md5sum] = "fa572afd6da969e25c1455f728750ec4"
SRC_URI[sha256sum] = "bc9d22d6d252b920ec9cdf18e00b7655a6189b3f34f42e58d5bb152957289840"


text:
package migo

import (
	"fmt"
	"reflect"
	"strings"

	"github.com/pkg/errors"
)

type Key struct {
	Target Columns `json:"target"`
	Name   string  `json:"name"`
}

type Keys []Key

func (k Keys) Len() int {
	return len(k)
}

func (k Keys) Less(i, j int) bool {
	return k[i].Name < k[j].Name
}

func (k Keys) Swap(i, j int) {
	k[i], k[j] = k[j], k[i]
}

func NewKey(name string) Key {
	return Key{Name: name}
}

func targetList(t Table, keyTarget interface{}) (Columns, error) {
	m, ok := keyTarget.([]interface{})
	if !ok {
		return nil, fmt.Errorf("fail to convert []interface{} type from %s", keyTarget)
	}

	targets := Columns{}
	for _, v := range m {
		s, ok := v.(string)
		if !ok {
			return nil, fmt.Errorf("fail to convert string type from %s", v)
		}
		c, err := t.findColumnWithID(s)
		if err != nil {
			return nil, fmt.Errorf("fail to searching column in table %s", t.Name)
		}
		targets = append(targets, c)
	}

	return targets, nil
}

func definitonsID(key string) string {
	return fmt.Sprintf("#/definitions/%s", key)
}
func propertiesID(key string) string {
	return fmt.Sprintf("#/properties/$s", key)
}

func (k Key) isUpdatedFrom(target Key) (bool, error) {
	if k.Name != target.Name {
		return false, errors.New("the target key name is wrong")
	}
	return !reflect.DeepEqual(k, target), nil
}

func (k Key) queryAsPrimaryKey() string {
	s := []string{}
	for _, v := range k.Target {
		s = append(s, v.Name)
	}
	return fmt.Sprintf("PRIMARY KEY %s (%s)", k.Name, strings.Join(s, ","))
}
func (k Key) queryAsIndex() string {
	s := []string{}
	for _, v := range k.Target {
		s = append(s, v.Name)
	}
	return fmt.Sprintf("INDEX %s (%s)", k.Name, strings.Join(s, ","))
}

repository: meta-closure/migo

repo_name: meta-closure/migo


text:
@article{robinson2016automated,
 author = {Robinson, CG and Price, J and Milkie, D and Torrens, O and Perlman, E and Zheng, Z and Fetter, RD and Bock, DD},
 journal = {Microscopy and Microanalysis},
 number = {S3},
 pages = {1150--1151},
 publisher = {Cambridge University Press},
 title = {Automated infrastructure for high-throughput acquisition of serial section TEM image volumes},
 volume = {22},
 year = {2016}
}

repository: dmilkie/starter-academic

repo_name: dmilkie/starter-academic


text:
require barebox-utils.inc

SRCREV = "c787d0e619f42436fb25fc584c5d2a9d5903deda"

repository: bjorn-oivind/meta-barebox

repo_name: bjorn-oivind/meta-barebox


text:
# Packages supported
# sgx : SGX runtime package.

### common ###

require sgx-common_2.18.1.inc

# Packages required to build.
DEPENDS += "protobuf-native cppmicroservices-native curl protobuf cppmicroservices sgx-sdk sgx-sdk-cross"

### patch ###

SRC_URI += " \
    file://0031-add-sysroot-libdir-target.patch  \
    file://0032-cppmicroservices-target-build.patch \
    file://fix_link.patch \
"

### compile ###

# Build target(s)
EXTRA_OEMAKE += "psw_install_pkg"

do_compile:prepend () {
    export SGX_SDK="${RECIPE_SYSROOT}${sgxsdkpath}-cross"
    export PATH=$PATH:$SGX_SDK/bin:$SGX_SDK/bin/x64
}

### install ###

do_install () {
    # Package PSW installer
    install -d "${D}${sgxdirprefix}${sgxrootdir}/package"
    install -m 0755 "${RECIPE_SYSROOT}${sgxrootdir}/package/sgx_linux_x64_sdk_2.18.101.1.bin" "${D}${sgxdirprefix}${sgxrootdir}/package"
    install -m 0755 "${B}/linux/installer/bin/sgx_linux_x64_psw_2.18.101.1.bin" "${D}${sgxdirprefix}${sgxrootdir}/package"

    # Package PSW installer
}

### package ###

SYSROOT_DIRS += "${sgxrootdir}"
FILES:${PN}  += "${sgxrootdir}"

#Script or implement install on first boot.
pkg_postinst_ontarget:${PN} () {
    # Verify on target
    if [ -z "$D" ]; then

        # Install SDK (optional)
        if [ -e "${sgxrootdir}/package/sgx_linux_x64_sdk_2.18.101.1.bin" ]; then
            "${sgxrootdir}/package/sgx_linux_x64_sdk_2.18.101.1.bin" --prefix /opt/intel < /dev/null
        fi

        # Install PSW
        if [ -e "${sgxrootdir}/package/sgx_linux_x64_psw_2.18.101.1.bin" ]; then
            "${sgxrootdir}/package/sgx_linux_x64_psw_2.18.101.1.bin" < /dev/null &
            sleep 10
        fi

        # Install DCAP libraries (optional)
        if [ -f "${sgxrootdir}/package/sgx-dcap-libs.tar" ]; then
            tar xvf "${sgxrootdir}/package/sgx-dcap-libs.tar" -C "${sgxrootdir}/sgxpsw/aesm"
        fi

        # Remove install binaries
        echo rm -rf "${sgxrootdir}/package"

    fi
}

### ###

# Runtime dependencies
RDEPENDS:${PN} += "bash"

CVE_PRODUCT = "software_guard_extensions_platform"

repository: intel/meta-intel-sgx

repo_name: intel/meta-intel-sgx