text:
@string{PNAS =   {Proc Natl Acad Sci U S A}}

@Article{Ritchie:NAR:2015,
    author = {M. E. Ritchie and B. Phipson and D. Wu and Y. Hu and C. W. Law and W. Shi and G. K. Smyth},
    title = {{limma} powers differential expression analyses for {RNA}-sequencing and microarray studies},
    journal = {Nucleic Acids Res},
    year = {2015},
    volume = {43},
    number = {7},
    pages = {e47},
  }

@Article{Robinson:Bioinformatics:2010,
    author = {M. D. Robinson and D. J. McCarthy and G. K. Smyth},
    title = {{edgeR}: a {Bioconductor} package for differential expression
  analysis of digital gene expression data.},
    journal = {Bioinformatics},
    year = {2010},
    volume = {26},
    pages = {139-140},
  }

@Article{Liao:NAR:2013,
    title = {The {S}ubread aligner: fast, accurate and scalable read mapping by seed-and-vote},
    author = {Y. Liao and G. K. Smyth and W. Shi},
    journal = {Nucleic Acids Res},
    year = {2013},
    volume = {41},
    issue = {10},
    pages = {e108},
  }

@Article{Huber:NatureMethods:2015,
    author = {W. Huber and V. J. Carey and R. Gentleman and S. Anders and M. Carlson and B. S. Carvalho and H. C. Bravo and S. Davis and L. Gatto and T. Girke and R. Gottardo and F. Hahne and K. D. Hansen and R. A. Irizarry and M. Lawrence and M. I. Love and J. {MacDonald} and V. Obenchain and A. K. {Ole\'s} and A. K. and H. {Pag\`es} and A. Reyes and P. Shannon and G. K. Smyth and D. Tenenbaum and L. Waldron and  M. Morgan},
    title = {{O}rchestrating high-throughput genomic analysis with {B}ioconductor},
    journal = {Nature Methods},
    year = {2015},
    volume = {12},
    number = {2},
    pages = {115--121},
    url = {http://www.nature.com/nmeth/journal/v12/n2/full/nmeth.3252.html},
  }

@Article{Liao:Bioinformatics:2014,
  title={{featureCounts:} an efficient general-purpose program for assigning sequence reads to genomic features.},
  author={Y. Liao and G. K. Smyth and W. Shi},
  journal={Bioinformatics},
  volume={30},
  number={7},
  pages={923-30},
  year={2014}
}

@Article{Law:GenomeBiol:2014,
Author = 	 {C. W. Law and Y. Chen and W. Shi and G. K. Smyth},
Title = 	 {{Voom:} precision weights unlock linear model analysis tools for {RNA-seq} read counts.},
Journal = 	 {Genome Biology},
Year = 	 {2014},
Volume = 	 {15},
Number =  {},
Pages = 	 {R29}
}

@Article{RobinsonOshlack:GenomeBiol:2010,
Author = 	 {M. D. Robinson and A. Oshlack},
Title = 	 {A scaling normalization method for differential expression analysis of {RNA-seq data}},
Journal = 	 {Genome Biology},
Year = 	 {2010},
Volume = 	 {11},
Number =  {},
Pages = 	 {R25}
}

% Empirical Bayes
@Article{Smyth:SAGMB:2004,
Author = 	 {G. K. Smyth},
Title = 	 {Linear models and empirical {B}ayes methods for assessing differential expression in microarray experiments},
Journal = 	 {Stat Appl Genet Mol Biol},
Year = 	 {2004},
Volume = 	 {3},
Number = 	 {1},
Pages = 	 {Article 3}
}

@Article{Wu2012,
author = {D. Wu and G. K. Smyth},
issn = {1362-4962},
journal = {Nucleic Acids Res},
month = sep,
number = {17},
pages = {e133},
title = {{Camera: a competitive gene set test accounting for inter-gene correlation.}},
volume = {40},
year = {2012}
}

@Manual{R,
         author = {{R Development Core Team}},
	  title   = {R: A language and environment for statistical computing},
	    organization  = {R Foundation for Statistical Computing},
	    address = {Vienna},
	    year    = {2016},
	    url = {http://www.R-project.org}
}

@Article{Liu:NAR:2015,
    title = {{Why weight? Combining voom with estimates of sample quality improves power in RNA-seq analyses.}},
    author = {R. Liu and A. Z. Holik and S. Su and N. Jansz and K. Chen and H. S. Leong and M. E. Blewitt and M. L. {Asselin-Labat} and G. K. Smyth and M. E. Ritchie},
    year = {2015},
    journal = {Nucleic Acids Res},
    volume = {43},
    pages = {e97},
}

@Manual{Glimma:2016,
    title = {{Glimma: Interactive HTML graphics for RNA-seq data}},
    author = {S. Su and M. E. Ritchie},
    year = {2016},
    note = {R package version 1.1.1},
    url = {https://bioconductor.org/packages/devel/bioc/html/Glimma.html}
}

@Manual{orgMm:2016,
    title = {{Mus.musculus: Annotation package for the Mus.musculus object}},
    author = {{Bioconductor Core Team}},
    year = {2016},
    note = {R package version 1.3.1},
    url = {https://bioconductor.org/packages/release/data/annotation/html/Mus.musculus.html}
}

@Manual{orgHs:2016,
    title = {{Homo.sapiens: Annotation package for the Homo.sapiens object}},
    author = {{Bioconductor Core Team}},
    year = {2016},
    note = {R package version 1.3.1},
    url = {https://bioconductor.org/packages/release/data/annotation/html/Homo.sapiens.html}
}

@Article{Durinck:NatureProtocols:2009,
    title = {{Mapping identifiers for the integration of genomic datasets with the R/Bioconductor package biomaRt}},
    author = {S. Durinck and P. Spellman and E. Birney and W. Huber},
    year = {2009},
    journal = {Nature Protocols},
    volume = {4},
    pages = {1184--91},
}

@Article{Durinck:Bioinf:2005,
    title = {{BioMart and Bioconductor: a powerful link between biological databases and microarray data analysis}},
    author = {S. Durinck and Y. Moreau and A. Kasprzyk and S. Davis and B. {De Moor} and A. Brazma and W. Huber},
    year = {2005},
    journal = {Bioinformatics},
    volume = {21},
    pages = {3439--40},
}

@article{Sheridan:BMCCancer:2015,
author = {J. M. Sheridan and M. E. Ritchie and S. A. Best and K. Jiang and T. J. Beck and F. Vaillant and K. Liu and R. A. Dickins and G. K. Smyth and G. J. Lindeman and J. E. Visvader},
journal = {BMC Cancer},
number = {1},
pages = {221},
publisher = {BioMed Central},
title = {{A pooled shRNA screen for regulators of primary mammary stem and progenitor cells identifies roles for Asap1 and Prox1}},
volume = {15},
year = {2015}
}

@article{McCarthy:Bioinf:2009,
author = {D. J. McCarthy and G. K. Smyth},
journal = {Bioinformatics},
number = {},
pages = {765--71},
title = {{Testing significance relative to a fold-change threshold is a TREAT}},
volume = {25},
year = {2009}
}

@article{Lim:BreastCancerRes:2010,
author = {E. Lim and D. Wu and B. Pal and T. Bouras and M. L. {Asselin-Labat} and F. Vaillant and H. Yagita and G. J. Lindeman and G. K. Smyth and J. E. Visvader},
journal = {Breast Cancer Research},
number = {2},
pages = {R21},
title = {{Transcriptome analyses of mouse and human mammary cell subpopulations reveal multiple conserved genes and pathways.}},
volume = {12},
year = {2010}
}

@article{Subramanianetal:PNAS:2005,
   Author = {Subramanian, A. and Tamayo, P. and Mootha, V. K. and Mukherjee, S. and Ebert, B. L. and Gillette, M. A. and Paulovich, A. and Pomeroy, S. L. and Golub, T. R. and Lander, E. S. and Mesirov, J. P.},
   Title = {Gene set enrichment analysis: a knowledge-based approach for interpreting genome-wide expression profiles},
   Journal = PNAS,
   Volume = {102},
   Number = {43},
   Pages = {15545-50},
   Year = {2005}
}

@article{Liu:GenomicsData:2016,
    title = {Transcriptional profiling of the epigenetic regulator {S}mchd1.},
    author = {R. Liu and K. Chen and N. Jansz and M. E. Blewitt and M. E. Ritchie},
    year = {2016},
    journal = {Genomics Data},
    volume = {7},
    month = {},
    pages = {144-7}
}

@Manual{knitr2016,
    title = {knitr: A General-Purpose Package for Dynamic Report
      Generation in R},
    author = {Y. Xie},
    year = {2016},
    note = {R package version 1.12.3},
    url = {http://yihui.name/knitr/},
}

@Book{knitr2015,
    title = {Dynamic Documents with {R} and knitr},
    author = {Y. Xie},
    publisher = {Chapman and Hall/CRC},
    address = {Boca Raton, Florida},
    year = {2015},
    edition = {2nd},
    note = {ISBN 978-1498716963},
    url = {http://yihui.name/knitr/},
}

@InCollection{knitr2014,
    booktitle = {Implementing Reproducible Computational Research},
    editor = {V. Stodden and F. Leisch and R. D. Peng},
    title = {knitr: A Comprehensive Tool for Reproducible Research in
      {R}},
    author = {Y. Xie},
    publisher = {Chapman and Hall/CRC},
    year = {2014},
    note = {ISBN 978-1466561595},
    url = {http://www.crcpress.com/product/isbn/9781466561595},
}

 @Manual{gplots,
    title = {gplots: Various R Programming Tools for Plotting Data},
    author = {G. R. Warnes and B. Bolker and L. Bonebakker and R. Gentleman and W. Huber and A. Liaw and T. Lumley and M. Maechler and A. Magnusson and S. Moeller and M. Schwartz and B. Venables},
    year = {2016},
    note = {R package version 3.0.1},
    url = {https://CRAN.R-project.org/package=gplots},
  }

gha_language: TeX


text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for Galyardt at 2014-08-21 22:49:39 -0400

%% Saved with string encoding Unicode (UTF-8)

@incollection{Galyardt14mmm,
	Author = {April Galyardt},
	Booktitle = {Handbook of Mixed Membership Models},
	Date-Added = {2014-08-21 21:18:27 +0000},
	Date-Modified = {2014-08-21 21:18:27 +0000},
	Editor = {Edoardo M. Airoldi and David Blei and Erosheva, Elena and Fienberg, Stephen E.},
	Publisher = {Chapman and Hall},
	Title = {Interpreting Mixed Membership Models: Implications of Erosheva's Representation Theorem},
	Year = {2014},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QMi4uLy4uL1BhcGVyLU1NIGNoYXB0ZXIvR2FseWFyZHQtY2hhcHRlci03LjguMTMucGRm0hcLGBlXTlMuZGF0YU8RAeIAAAAAAeIAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAMm3i1VIKwAAAJ3/thtHYWx5YXJkdC1jaGFwdGVyLTcuOC4xMy5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7Y5zgBejQAAAAAAAAAAAAIAAgAACSAAAAAAAAAAAAAAAAAAAAAQUGFwZXItTU0gY2hhcHRlcgAQAAgAAMm3w5UAAAARAAgAAM4Als0AAAABABAAnf+2ABefWwANUdgAAJg6AAIAVU1hY2ludG9zaCBIRDpVc2VyczoAYWdhbHlhcmR0OgBEcm9wYm94OgBQYXBlci1NTSBjaGFwdGVyOgBHYWx5YXJkdC1jaGFwdGVyLTcuOC4xMy5wZGYAAA4AOAAbAEcAYQBsAHkAYQByAGQAdAAtAGMAaABhAHAAdABlAHIALQA3AC4AOAAuADEAMwAuAHAAZABmAA8AGgAMAE0AYQBjAGkAbgB0AG8AcwBoACAASABEABIARFVzZXJzL2FnYWx5YXJkdC9Ecm9wYm94L1BhcGVyLU1NIGNoYXB0ZXIvR2FseWFyZHQtY2hhcHRlci03LjguMTMucGRmABMAAS8AABUAAgAQ//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4AwwDIANACtgK4Ar0CyALRAt8C4wLqAvMC+AMFAwgDGgMdAyIAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAADJA==}}

@phdthesis{Galyardt12dis,
	Address = {Pittsburgh, PA 15213},
	Author = {April Galyardt},
	Date-Added = {2014-08-21 21:17:56 +0000},
	Date-Modified = {2014-08-22 02:49:38 +0000},
	Keywords = {mixed membership, Latent Dirichlet Allocation, cognitive diagnosis models, numerical estimation, psychometrics},
	Month = {July},
	School = {Carnegie Mellon University},
	Title = {Mixed Membership Distributions with Applications to Modeling Multiple Strategy Usage},
	Year = {2012},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QRC4uLy4uLy4uL0RvY3VtZW50cy9QdWJsaWNhdGlvbnMvMjAxMi1HYWx5YXJkdC1EaXNzZXJ0YXRpb24tRmluYWwucGRm0hcLGBlXTlMuZGF0YU8RAfoAAAAAAfoAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAMtppx9IKwAAAAuN+h8yMDEyLUdhbHlhcmR0LURpc3NlciMyNjgyNTgucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJoJYzMbb7wAAAAAAAAAAAAMAAwAACSAAAAAAAAAAAAAAAAAAAAAMUHVibGljYXRpb25zABAACAAAy2ntbwAAABEACAAAzMciPwAAAAEAEAALjfoABcifAAXIngAAuVcAAgBXTWFjaW50b3NoIEhEOlVzZXJzOgBhZ2FseWFyZHQ6AERvY3VtZW50czoAUHVibGljYXRpb25zOgAyMDEyLUdhbHlhcmR0LURpc3NlciMyNjgyNTgucGRmAAAOAEoAJAAyADAAMQAyAC0ARwBhAGwAeQBhAHIAZAB0AC0ARABpAHMAcwBlAHIAdABhAHQAaQBvAG4ALQBGAGkAbgBhAGwALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAEtVc2Vycy9hZ2FseWFyZHQvRG9jdW1lbnRzL1B1YmxpY2F0aW9ucy8yMDEyLUdhbHlhcmR0LURpc3NlcnRhdGlvbi1GaW5hbC5wZGYAABMAAS8AABUAAgAQ//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4A1QDaAOIC4ALiAucC8gL7AwkDDQMUAx0DIgMvAzIDRANHA0wAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAADTg==}}

@conference{Galyardt13smmc,
	Address = {Arnhem, Netherlands},
	Author = {April Galyardt and Ilya Goldin},
	Booktitle = {International Meeting of the Psychometric Society},
	Date-Added = {2014-08-21 21:17:50 +0000},
	Date-Modified = {2014-08-21 21:17:50 +0000},
	Keywords = {conf},
	Title = {Modeling Student Metacognitive Strategies in a Intelligent Tutoring System},
	Year = {2013}}

@article{Campbell02,
	Author = {Jamie I.D. Campbell and Shauna Austin},
	Date-Added = {2014-08-21 21:12:16 +0000},
	Date-Modified = {2014-08-21 21:13:22 +0000},
	Journal = {Memory \& Cognition},
	Keywords = {strategies, addition, response time},
	Number = {6},
	Pages = {988-994},
	Title = {Effects of response time deadlines on adults' strategy choices for simple addition},
	Volume = {30},
	Year = {2002}}

@article{Schubert13,
	Author = {Schubert, Christiane C and Denmark, T Kent and Crandall, Beth and Grome, Anna and Pappas, James},
	Date-Added = {2014-08-21 21:00:46 +0000},
	Date-Modified = {2014-08-21 21:00:46 +0000},
	Journal = {Annals of emergency medicine},
	Keywords = {expert/novice differences},
	Number = {1},
	Pages = {96--109},
	Publisher = {Elsevier},
	Title = {Characterizing novice-expert differences in macrocognition: an exploratory study of cognitive work in the emergency department},
	Volume = {61},
	Year = {2013},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QYS4uLy4uL1BhcGVyLVdoYXQncyBhIFN0cmF0ZWd5L1BhcGVycy1TdHJhdGVnaWVzL1JlYWQvU2NodWJlcnQgZXRhbCAoMjAxMikgLUVtZXJnZW5jeSBNZWRpY2luZS5wZGbSFwsYGVdOUy5kYXRhTxECVAAAAAACVAACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAybeLVUgrAAACeKY6H1NjaHViZXJ0IGV0YWwgKDIwMTIjMjc4QTdCNi5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ4p7bP6W1eAAAAAAAAAAAAAgAEAAAJIAAAAAAAAAAAAAAAAAAAAARSZWFkABAACAAAybfDlQAAABEACAAAz+mlngAAAAEAGAJ4pjoCeKY4ANZobAAXn1sADVHYAACYOgACAHlNYWNpbnRvc2ggSEQ6VXNlcnM6AGFnYWx5YXJkdDoARHJvcGJveDoAUGFwZXItV2hhdCdzIGEgU3RyYXRlZ3k6AFBhcGVycy1TdHJhdGVnaWVzOgBSZWFkOgBTY2h1YmVydCBldGFsICgyMDEyIzI3OEE3QjYucGRmAAAOAFoALABTAGMAaAB1AGIAZQByAHQAIABlAHQAYQBsACAAKAAyADAAMQAyACkAIAAtAEUAbQBlAHIAZwBlAG4AYwB5ACAATQBlAGQAaQBjAGkAbgBlAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgBzVXNlcnMvYWdhbHlhcmR0L0Ryb3Bib3gvUGFwZXItV2hhdCdzIGEgU3RyYXRlZ3kvUGFwZXJzLVN0cmF0ZWdpZXMvUmVhZC9TY2h1YmVydCBldGFsICgyMDEyKSAtRW1lcmdlbmN5IE1lZGljaW5lLnBkZgAAEwABLwAAFQACABD//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgDyAPcA/wNXA1kDXgNpA3IDgAOEA4sDlAOZA6YDqQO7A74DwwAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAPF}}

@article{Siegler87,
	Author = {Robert S. Siegler},
	Date-Added = {2014-08-21 21:00:35 +0000},
	Date-Modified = {2014-08-21 21:00:35 +0000},
	Journal = {Journal of Experimental Psychology: General},
	Keywords = {Multiple strategy use; mathematics education; strategies; learning sciences; psychology},
	Number = {3},
	Pages = {250-264},
	Title = {The perils of averaging data over strategies: An example from children's addition},
	Volume = {116},
	Year = {1987},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8Qby4uLy4uLy4uL0RvY3VtZW50cy9Kb3VybmFsLU5ld3MtQXJ0aWNsZXMvTGVhcm5pbmcgU2NpZW5jZXMsIExBLCBFRE0vU2llZ2xlci04Ny1NdWx0aXBsZSBBZGRpdGlvbiBTdHJhdGVnaWVzLnBkZtIXCxgZV05TLmRhdGFPEQJoAAAAAAJoAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADLaacfSCsAAAALnbIfU2llZ2xlci04Ny1NdWx0aXBsZSBBI0I5RTE1LnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAueFcjZ9odQREYgAAAAAAADAAQAAAkgAAAAAAAAAAAAAAAAAAAAGkxlYXJuaW5nIFNjaWVuY2VzLCBMQSwgRURNABAACAAAy2ntbwAAABEACAAAyNouxwAAAAEAFAALnbIAC5wCAAXInwAFyJ4AALlXAAIAfE1hY2ludG9zaCBIRDpVc2VyczoAYWdhbHlhcmR0OgBEb2N1bWVudHM6AEpvdXJuYWwtTmV3cy1BcnRpY2xlczoATGVhcm5pbmcgU2NpZW5jZXMsIExBLCBFRE06AFNpZWdsZXItODctTXVsdGlwbGUgQSNCOUUxNS5wZGYADgBYACsAUwBpAGUAZwBsAGUAcgAtADgANwAtAE0AdQBsAHQAaQBwAGwAZQAgAEEAZABkAGkAdABpAG8AbgAgAFMAdAByAGEAdABlAGcAaQBlAHMALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAHZVc2Vycy9hZ2FseWFyZHQvRG9jdW1lbnRzL0pvdXJuYWwtTmV3cy1BcnRpY2xlcy9MZWFybmluZyBTY2llbmNlcywgTEEsIEVETS9TaWVnbGVyLTg3LU11bHRpcGxlIEFkZGl0aW9uIFN0cmF0ZWdpZXMucGRmABMAAS8AABUAAgAQ//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4BAAEFAQ0DeQN7A4ADiwOUA6IDpgOtA7YDuwPIA8sD3QPgA+UAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAD5w==}}

@article{Chi81,
	Author = {Chi, Michelene T.H. and Feltovich, Paul J. and Glaser, Robert},
	Date-Added = {2014-08-21 21:00:27 +0000},
	Date-Modified = {2014-08-21 21:00:27 +0000},
	Journal = {Cognitive science},
	Keywords = {expert/novice differences},
	Number = {2},
	Pages = {121--152},
	Publisher = {Wiley Online Library},
	Title = {Categorization and representation of physics problems by experts and novices},
	Volume = {5},
	Year = {1981},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QZy4uLy4uL1BhcGVyLVdoYXQncyBhIFN0cmF0ZWd5L1BhcGVycy1TdHJhdGVnaWVzL1JlYWQvQ2hpLCBGZWx0b3ZpY2gsIEdsYXNlciAoMTk4MSktcGh5c2ljcyBwcm9ibGVtcy5wZGbSFwsYGVdOUy5kYXRhTxECZgAAAAACZgACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAybeLVUgrAAACeKY6H0NoaSwgRmVsdG92aWNoLCBHbGEjMjc4QTdDQy5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ4p8zP6ZB8AAAAAAAAAAAAAgAEAAAJIAAAAAAAAAAAAAAAAAAAAARSZWFkABAACAAAybfDlQAAABEACAAAz+nIvAAAAAEAGAJ4pjoCeKY4ANZobAAXn1sADVHYAACYOgACAHlNYWNpbnRvc2ggSEQ6VXNlcnM6AGFnYWx5YXJkdDoARHJvcGJveDoAUGFwZXItV2hhdCdzIGEgU3RyYXRlZ3k6AFBhcGVycy1TdHJhdGVnaWVzOgBSZWFkOgBDaGksIEZlbHRvdmljaCwgR2xhIzI3OEE3Q0MucGRmAAAOAGYAMgBDAGgAaQAsACAARgBlAGwAdABvAHYAaQBjAGgALAAgAEcAbABhAHMAZQByACAAKAAxADkAOAAxACkALQBwAGgAeQBzAGkAYwBzACAAcAByAG8AYgBsAGUAbQBzAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgB5VXNlcnMvYWdhbHlhcmR0L0Ryb3Bib3gvUGFwZXItV2hhdCdzIGEgU3RyYXRlZ3kvUGFwZXJzLVN0cmF0ZWdpZXMvUmVhZC9DaGksIEZlbHRvdmljaCwgR2xhc2VyICgxOTgxKS1waHlzaWNzIHByb2JsZW1zLnBkZgAAEwABLwAAFQACABD//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgD4AP0BBQNvA3EDdgOBA4oDmAOcA6MDrAOxA74DwQPTA9YD2wAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAPd}}

@incollection{Mislevy06Cog,
	Author = {Robert Mislevy},
	Booktitle = {Educational Assessment},
	Chapter = {8},
	Date-Added = {2014-08-21 20:58:59 +0000},
	Date-Modified = {2014-08-21 20:58:59 +0000},
	Editor = {Robert L. Brennan},
	Publisher = {American Council on Education and Praeger Publishers},
	Title = {Cognitive Psychology and Educational Assessment},
	Year = {2006},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QUy4uLy4uL1BhcGVyLVdoYXQncyBhIFN0cmF0ZWd5L1BhcGVycy1Nb2RlbHMvTWlzbGV2eSAoMjAwNiktQ29nIFBzeSAmIEFzc2Vzc21lbnQucGRm0hcLGBlXTlMuZGF0YU8RAjgAAAAAAjgAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAMm3i1VIKwAAAnimNh9NaXNsZXZ5ICgyMDA2KS1Db2cgIzI3QjBENEIucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACew1Lz+7ulQAAAAAAAAAAAAIAAwAACSAAAAAAAAAAAAAAAAAAAAANUGFwZXJzLU1vZGVscwAAEAAIAADJt8OVAAAAEQAIAADP7ybVAAAAAQAUAnimNgDWaGwAF59bAA1R2AAAmDoAAgBvTWFjaW50b3NoIEhEOlVzZXJzOgBhZ2FseWFyZHQ6AERyb3Bib3g6AFBhcGVyLVdoYXQncyBhIFN0cmF0ZWd5OgBQYXBlcnMtTW9kZWxzOgBNaXNsZXZ5ICgyMDA2KS1Db2cgIzI3QjBENEIucGRmAAAOAFAAJwBNAGkAcwBsAGUAdgB5ACAAKAAyADAAMAA2ACkALQBDAG8AZwAgAFAAcwB5ACAAJgAgAEEAcwBzAGUAcwBzAG0AZQBuAHQALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAGVVc2Vycy9hZ2FseWFyZHQvRHJvcGJveC9QYXBlci1XaGF0J3MgYSBTdHJhdGVneS9QYXBlcnMtTW9kZWxzL01pc2xldnkgKDIwMDYpLUNvZyBQc3kgJiBBc3Nlc3NtZW50LnBkZgAAEwABLwAAFQACABD//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgDkAOkA8QMtAy8DNAM/A0gDVgNaA2EDagNvA3wDfwORA5QDmQAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAOb}}

@article{Mislevy12,
	Author = {Robert J. Mislevy and John T. Behrens and Kristen E. {DiCerbo} and Roy Levy},
	Date-Added = {2014-03-27 15:22:33 +0000},
	Date-Modified = {2014-03-27 15:22:33 +0000},
	Journal = {Journal of Educational Data Mining},
	Number = {1},
	Title = {Design and Discovery in Educational Assessment: Evidence-Centered Design, Psychometrics, and Educational Data Mining},
	Volume = {4},
	Year = {2012},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QWC4uLy4uL1ByaXZhdGUtRVJTSDg5OTAvUmVhZGluZ0xpc3QvQ29waWVzX1VubWFya2VkX0Rpc3RyaWJ1dGUvUjEtTWlzbGV2eSBldGFsICgyMDEyKS5wZGbSFwsYGVdOUy5kYXRhTxECQAAAAAACQAACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAybeLVUgrAAACIbwqGlIxLU1pc2xldnkgZXRhbCAoMjAxMikucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhvEDPPjaUAAAAAAAAAAAAAgAEAAAJIAAAAAAAAAAAAAAAAAAAABpDb3BpZXNfVW5tYXJrZWRfRGlzdHJpYnV0ZQAQAAgAAMm3w5UAAAARAAgAAM8+fOQAAAABABgCIbwqAiG8JQCmuWsAF59bAA1R2AAAmDoAAgB9TWFjaW50b3NoIEhEOlVzZXJzOgBhZ2FseWFyZHQ6AERyb3Bib3g6AFByaXZhdGUtRVJTSDg5OTA6AFJlYWRpbmdMaXN0OgBDb3BpZXNfVW5tYXJrZWRfRGlzdHJpYnV0ZToAUjEtTWlzbGV2eSBldGFsICgyMDEyKS5wZGYAAA4ANgAaAFIAMQAtAE0AaQBzAGwAZQB2AHkAIABlAHQAYQBsACAAKAAyADAAMQAyACkALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAGpVc2Vycy9hZ2FseWFyZHQvRHJvcGJveC9Qcml2YXRlLUVSU0g4OTkwL1JlYWRpbmdMaXN0L0NvcGllc19Vbm1hcmtlZF9EaXN0cmlidXRlL1IxLU1pc2xldnkgZXRhbCAoMjAxMikucGRmABMAAS8AABUAAgAQ//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4A6QDuAPYDOgM8A0EDTANVA2MDZwNuA3cDfAOJA4wDngOhA6YAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAADqA==}}

@incollection{VanLehn08,
	Author = {Kurt VanLehn},
	Booktitle = {The future of assessment: Shaping teaching and learning.},
	Date-Added = {2014-03-27 14:52:29 +0000},
	Date-Modified = {2014-03-27 14:54:32 +0000},
	Editor = {C. Dwyer},
	Keywords = {intelligent tutoring systems},
	Pages = {113-138},
	Publisher = {Erbaum},
	Title = {Intelligent Tutoring Systems for Continuous, Embedded Assessment},
	Year = {2008},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QXS4uLy4uL05ldyBBcnRpY2xlcy9SZWFkL1ZhbkxlaG4oMjAwOCktIEludGVsbGlnZW50IHR1dG9yaW5nIHN5c3RlbXMgZm9yIGNvbnRpbnVvdXMsIGVtYmVkLnBkZtIXCxgZV05TLmRhdGFPEQJgAAAAAAJgAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADJt4tVSCsAAAE5yhcfVmFuTGVobigyMDA4KS0gSW50ZSMyMkY0MUFFLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAi9Brs9Zst0AAAAAAAAAAAACAAMAAAkgAAAAAAAAAAAAAAAAAAAABFJlYWQAEAAIAADJt8OVAAAAEQAIAADPWesdAAAAAQAUATnKFwAb8HgAF59bAA1R2AAAmDoAAgBbTWFjaW50b3NoIEhEOlVzZXJzOgBhZ2FseWFyZHQ6AERyb3Bib3g6AE5ldyBBcnRpY2xlczoAUmVhZDoAVmFuTGVobigyMDA4KS0gSW50ZSMyMkY0MUFFLnBkZgAADgCMAEUAVgBhAG4ATABlAGgAbgAoADIAMAAwADgAKQAtACAASQBuAHQAZQBsAGwAaQBnAGUAbgB0ACAAdAB1AHQAbwByAGkAbgBnACAAcwB5AHMAdABlAG0AcwAgAGYAbwByACAAYwBvAG4AdABpAG4AdQBvAHUAcwAsACAAZQBtAGIAZQBkAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgBvVXNlcnMvYWdhbHlhcmR0L0Ryb3Bib3gvTmV3IEFydGljbGVzL1JlYWQvVmFuTGVobigyMDA4KS0gSW50ZWxsaWdlbnQgdHV0b3Jpbmcgc3lzdGVtcyBmb3IgY29udGludW91cywgZW1iZWQucGRmAAATAAEvAAAVAAIAEP//AACABtIbHB0eWiRjbGFzc25hbWVYJGNsYXNzZXNdTlNNdXRhYmxlRGF0YaMdHyBWTlNEYXRhWE5TT2JqZWN00hscIiNcTlNEaWN0aW9uYXJ5oiIgXxAPTlNLZXllZEFyY2hpdmVy0SYnVHJvb3SAAQAIABEAGgAjAC0AMgA3AEAARgBNAFUAYABnAGoAbABuAHEAcwB1AHcAhACOAO4A8wD7A18DYQNmA3EDegOIA4wDkwOcA6EDrgOxA8MDxgPLAAAAAAAAAgEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAA80=}}

@article{Erosheva04,
	Author = {Elena Erosheva and Stephen E. Fienberg and John Lafferty},
	Date-Added = {2013-12-18 14:22:42 +0000},
	Date-Modified = {2013-12-18 14:25:57 +0000},
	Journal = {PNAS},
	Number = {Suppl.1},
	Pages = {5220-5227},
	Title = {Mixed-Membership Models of Scientific Publications},
	Volume = {101},
	Year = {2004},
	Bdsk-Url-1 = {http://www.pnas.org/cgi/content/full/101/suppl_1/5220}}

@incollection{Blei09,
	Author = {David Blei and John Lafferty},
	Booktitle = {Text Mining: Classification, Clustering, and Applications},
	Date-Added = {2013-12-18 14:09:12 +0000},
	Date-Modified = {2013-12-18 14:12:00 +0000},
	Editor = {A. Srivastava and M. Sahami},
	Publisher = {Chapman \& Hall/CRC},
	Series = {Data Mining and Knowledge Discovery Series},
	Title = {Topic Models},
	Year = {2009},
	Bdsk-Url-1 = {http://www.cs.princeton.edu/~blei/papers/BleiLafferty2009.pdf}}

@article{aleven_toward_2006,
	Author = {Aleven, V. and Mclaren, B. and Roll, I. and Koedinger, K.},
	Date-Added = {2013-12-05 22:14:42 +0000},
	Date-Modified = {2013-12-17 17:12:03 +0000},
	Issue = {2},
	Journal = {International Journal of Artificial Intelligence in Education},
	Pages = {101-128},
	Title = {Toward meta-cognitive tutoring: A model of help seeking with a Cognitive Tutor},
	Volume = {16},
	Year = {2006}}

@inproceedings{goldin_hints:_2013,
	Author = {Goldin, Ilya M. and Koedinger, Kenneth R. and Aleven, Vincent A. W. M. M.},
	Booktitle = {Proceedings of 6th International Conference on Educational Data Mining},
	Date-Added = {2013-12-05 22:14:42 +0000},
	Date-Modified = {2013-12-17 19:51:31 +0000},
	Editor = {{D'Mello}, Sidney K. and Calvo, Rafael A. and Olney, Andrew},
	Location = {Memphis, {TN}},
	Month = {July},
	Title = {Hints: You Can't Have Just One},
	Year = {2013},
	Bdsk-Url-1 = {http://www.educationaldatamining.org/EDM2013/papers/rn_paper_35.pdf}}

@inproceedings{goldin_learner_2012,
	Address = {Chania, Greece},
	Author = {Goldin, Ilya M. and Koedinger, Kenneth R. and Aleven, Vincent A. W. M. M.},
	Booktitle = {Proceedings of 5th International Conference on Educational Data Mining},
	Date-Added = {2013-12-05 22:14:42 +0000},
	Date-Modified = {2013-12-17 19:50:21 +0000},
	Editor = {Yacef, Kalina and Za{\"\i}ane, Osmar and Hershkovitz, Arnon and Yudelson, Michael and Stamper, John},
	Pages = {73-80},
	Title = {Learner Differences in Hint Processing},
	Year = {2012},
	Bdsk-Url-1 = {http://educationaldatamining.org/EDM2012/uploads/procs/Full_Papers/edm2012_full_6.pdf}}

@inproceedings{goldin_learner_2013,
	Address = {Memphis, {TN}},
	Author = {Goldin, Ilya M. and Carlson, Ryan},
	Booktitle = {Proceedings of 16th International Conference on Artificial Intelligence in Education},
	Date-Added = {2013-12-05 22:14:42 +0000},
	Date-Modified = {2013-12-17 17:14:16 +0000},
	Title = {Learner Differences and Hint Content},
	Year = {2013}}

@article{Girolami05,
	Abstract = {To provide a parsimonious generative representation of the sequential activity of a number of individuals within a population there is a necessary tradeoff between the definition of individual specific and global
representations. A linear-time algorithm is proposed that defines a distributed predictive model for finite state symbolic sequences which represent the traces of the activity of a number of individuals within a group. The algorithm is based on a straightforward generalization of latent Dirichlet allocation to time-invariant Markov chains of arbitrary order. The modelling assumption made is that the possibly heterogeneous behavior of individuals may be represented by a relatively small number of simple and common behavioral traits which may interleave randomly according to an individual-specific distribution. The results of an empirical study on three different application domains indicate that this modelling approach provides an efficient low-complexity and intuitively interpretable representation scheme which is reflected by improved prediction performance over comparable models.},
	Annote = {Builds a mixed-membership model where the basis profiles are markov chains of varying order.
Uses two types of estimation: Variational approximation, and "maximum a posteriori" (MAP)
Fits model on 3 different data sets of user-log data: actions in a word processor, sequences of calls to different geographic regions (UK), and finally web page browsing.

Compares models on "perplexity" which they define as the exponential of the negative-normalized log-likelihood.  (Might be a standard markov-chain goodness of fit measure, or it might be more standard to ML)
They use t-tests and non-parametric Wilcoxon Rank-Sum tests to test for significant differences in perplexity.

They call their model a "simplical mixture of markov chains" and cite Minka and Lafferty 2002.

For the zero^th order Markov model (when no memory is assumed in the markov process), then their model reduces to a multinomial LDA model.

They also claim that Hofmann's pLSA algorithm is equivalent to LDA when the MAP estimator is calculated through an iterative convergence method. Suggests that LDA is an improvement over pLSA because of the estimation method used.  Cites Lappalainen and Miskin (2000) on the weakness of MAP estimators.

For all the data sets, the mixed-membership model offers better results. Better on the goodness-of-fit measures and more interpretable results.  The differences were clearer on the bigger data sets with larger state-spaces.

Data Structure:  only 1 item per model - the sequences (J=1)
	many replications of each item (big R)

They offer some additional comments on computational algorithms and computational time.},
	Author = {Mark Girolami and Ata Kaban},
	Date-Added = {2013-06-25 19:41:00 +0000},
	Date-Modified = {2013-06-25 19:41:00 +0000},
	Journal = {Data Mining and Knowledge Discovery},
	Keywords = {Latent Dirichlet Allocation, markov chains, Mixture models, user profiling, mixed membership, variational approximation},
	Pages = {175-196},
	Title = {Sequential Activity Profiling: Latent Dirichlet Allocation of Markov Chains},
	Volume = {10},
	Year = {2005},
	Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8Qay4uLy4uLy4uL0RvY3VtZW50cy9Kb3VybmFsLU5ld3MtQXJ0aWNsZXMvTWl4ZWQgTWVtYmVyc2hpcC9HaXJvbGFtaSAmIEthYmFuICgyMDA1KS0gTERBIG9mIG1hcmtvdiBjaGFpbnMucGRm0hcLGBlXTlMuZGF0YU8RAlwAAAAAAlwAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAMtppx9IKwAAAAueSx9HaXJvbGFtaSAmIEthYmFuICgyMDAjQjlFNkEucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC55qyVXqE1BERiAAAAAAAAMABAAACSAAAAAAAAAAAAAAAAAAAAAQTWl4ZWQgTWVtYmVyc2hpcAAQAAgAAMtp7W8AAAARAAgAAMlWMGMAAAABABQAC55LAAucAgAFyJ8ABcieAAC5VwACAHJNYWNpbnRvc2ggSEQ6VXNlcnM6AGFnYWx5YXJkdDoARG9jdW1lbnRzOgBKb3VybmFsLU5ld3MtQXJ0aWNsZXM6AE1peGVkIE1lbWJlcnNoaXA6AEdpcm9sYW1pICYgS2FiYW4gKDIwMCNCOUU2QS5wZGYADgBkADEARwBpAHIAbwBsAGEAbQBpACAAJgAgAEsAYQBiAGEAbgAgACgAMgAwADAANQApAC0AIABMAEQAQQAgAG8AZgAgAG0AYQByAGsAbwB2ACAAYwBoAGEAaQBuAHMALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAHJVc2Vycy9hZ2FseWFyZHQvRG9jdW1lbnRzL0pvdXJuYWwtTmV3cy1BcnRpY2xlcy9NaXhlZCBNZW1iZXJzaGlwL0dpcm9sYW1pICYgS2FiYW4gKDIwMDUpLSBMREEgb2YgbWFya292IGNoYWlucy5wZGYAEwABLwAAFQACABD//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgD8AQEBCQNpA2sDcAN7A4QDkgOWA50DpgOrA7gDuwPNA9AD1QAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAPX}}

repository: rbotafogo/galaaz

license_type: permissive

repo_name: rbotafogo/galaaz

branch_name: refs/heads/master

gha_language: HTML

extension: bib


text:
// Copyright 2015 Bobby Powers. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package slackfs

import (
	"fmt"
	"sync"

	"github.com/bpowers/slack"
)

type User struct {
	slack.User
	mu   sync.Mutex
	conn *FSConn
}

func NewUser(su slack.User, conn *FSConn) *User {
	u := new(User)
	u.User = su
	u.conn = conn

	return u
}

type userIdNode struct {
	AttrNode
}

func newUserId(parent *DirNode) (INode, error) {
	name := "id"
	n := new(userIdNode)
	if err := n.AttrNode.Node.Init(parent, name, nil); err != nil {
		return nil, fmt.Errorf("node.Init('%s': %s", name, err)
	}
	n.Update()
	n.mode = 0444
	return n, nil
}

func (n *userIdNode) Update() {
	val := n.parent.priv.(*User).Id + "\n"
	n.updateCommon(val)
}

type userNameNode struct {
	AttrNode
}

func newUserName(parent *DirNode) (INode, error) {
	name := "name"
	n := new(userNameNode)
	if err := n.AttrNode.Node.Init(parent, name, nil); err != nil {
		return nil, fmt.Errorf("node.Init('%s': %s", name, err)
	}
	n.Update()
	n.mode = 0444
	return n, nil
}

func (n *userNameNode) Update() {
	val := n.parent.priv.(*User).Name + "\n"
	n.updateCommon(val)
}

type userPresenceNode struct {
	AttrNode
}

func newUserPresence(parent *DirNode) (INode, error) {
	name := "presence"
	n := new(userPresenceNode)
	if err := n.AttrNode.Node.Init(parent, name, nil); err != nil {
		return nil, fmt.Errorf("node.Init('%s': %s", name, err)
	}
	n.Update()
	n.mode = 0444
	return n, nil
}

func (n *userPresenceNode) Update() {
	val := n.parent.priv.(*User).Presence + "\n"
	n.updateCommon(val)
}

type userIsBotNode struct {
	AttrNode
}

func newUserIsBot(parent *DirNode) (INode, error) {
	name := "is-bot"
	n := new(userIsBotNode)
	if err := n.AttrNode.Node.Init(parent, name, nil); err != nil {
		return nil, fmt.Errorf("node.Init('%s': %s", name, err)
	}
	n.Update()
	n.mode = 0444
	return n, nil
}

func (n *userIsBotNode) Update() {
	var val string
	if n.parent.priv.(*User).IsBot {
		val = "true\n"
	} else {
		val = "false\n"
	}
	n.updateCommon(val)
}

var userAttrs = []AttrFactory{
	newUserId,
	newUserName,
	newUserPresence,
	newUserIsBot,
}

func NewUserDir(parent *DirNode, id string, priv interface{}) (*DirNode, error) {
	if _, ok := priv.(*User); !ok {
		return nil, fmt.Errorf("NewUserDir called w non-user: %#v", priv)
	}

	dir, err := NewDirNode(parent, id, priv)
	if err != nil {
		return nil, fmt.Errorf("NewDirNode: %s", err)
	}

	for _, attrFactory := range userAttrs {
		n, err := attrFactory(dir)
		if err != nil {
			return nil, fmt.Errorf("attrFactory: %s", err)
		}
		dir.addChild(n)
	}

	return dir, nil
}

license: MIT

repository: bpowers/slackfs

repo_name: bpowers/slackfs

extension: go


text:
DESCRIPTION="status-led is setting the status LED after boot."
SECTION="tools"

LICENSE = "TQSSLA_V1.0.2"
LIC_FILES_CHKSUM = "file://${WORKDIR}/LICENSE;md5=5a77156d011829e57ffe26e62f07ff2d"
SRC_DISTRIBUTE_LICENSES += "TQSSLA_V1.0.2"

SRC_URI = " \
	file://LICENSE \
	file://${BPN} \
	file://${BPN}.service \
"

inherit systemd

SYSTEMD_SERVICE:${PN} = "${BPN}.service"

S = "${WORKDIR}"

do_install() {
	install -d ${D}${bindir}
	install -d ${D}${systemd_unitdir}/system

	install -m 0755 status-led			${D}${bindir}
	install -m 0644 status-led.service	${D}${systemd_unitdir}/system
}

COMPATIBLE_MACHINE = "em"

repository: tq-systems/meta-emos

repo_name: tq-systems/meta-emos

extension: bb


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

import (
	"sync"
	"time"
)

type DiscoveryConfig struct {
	DiscoveryCacheExpirationTimeStub        func() time.Duration
	discoveryCacheExpirationTimeMutex       sync.RWMutex
	discoveryCacheExpirationTimeArgsForCall []struct{}
	discoveryCacheExpirationTimeReturns     struct {
		result1 time.Duration
	}
	discoveryCacheExpirationTimeReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	DiscoveryGossipMaxAttemptsStub        func() int
	discoveryGossipMaxAttemptsMutex       sync.RWMutex
	discoveryGossipMaxAttemptsArgsForCall []struct{}
	discoveryGossipMaxAttemptsReturns     struct {
		result1 int
	}
	discoveryGossipMaxAttemptsReturnsOnCall map[int]struct {
		result1 int
	}
	DiscoveryGossipTimeoutStub        func() time.Duration
	discoveryGossipTimeoutMutex       sync.RWMutex
	discoveryGossipTimeoutArgsForCall []struct{}
	discoveryGossipTimeoutReturns     struct {
		result1 time.Duration
	}
	discoveryGossipTimeoutReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	DiscoveryGossipMaxPeersStub        func() int
	discoveryGossipMaxPeersMutex       sync.RWMutex
	discoveryGossipMaxPeersArgsForCall []struct{}
	discoveryGossipMaxPeersReturns     struct {
		result1 int
	}
	discoveryGossipMaxPeersReturnsOnCall map[int]struct {
		result1 int
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *DiscoveryConfig) DiscoveryCacheExpirationTime() time.Duration {
	fake.discoveryCacheExpirationTimeMutex.Lock()
	ret, specificReturn := fake.discoveryCacheExpirationTimeReturnsOnCall[len(fake.discoveryCacheExpirationTimeArgsForCall)]
	fake.discoveryCacheExpirationTimeArgsForCall = append(fake.discoveryCacheExpirationTimeArgsForCall, struct{}{})
	fake.recordInvocation("DiscoveryCacheExpirationTime", []interface{}{})
	fake.discoveryCacheExpirationTimeMutex.Unlock()
	if fake.DiscoveryCacheExpirationTimeStub != nil {
		return fake.DiscoveryCacheExpirationTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.discoveryCacheExpirationTimeReturns.result1
}

func (fake *DiscoveryConfig) DiscoveryCacheExpirationTimeCallCount() int {
	fake.discoveryCacheExpirationTimeMutex.RLock()
	defer fake.discoveryCacheExpirationTimeMutex.RUnlock()
	return len(fake.discoveryCacheExpirationTimeArgsForCall)
}

func (fake *DiscoveryConfig) DiscoveryCacheExpirationTimeReturns(result1 time.Duration) {
	fake.DiscoveryCacheExpirationTimeStub = nil
	fake.discoveryCacheExpirationTimeReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryCacheExpirationTimeReturnsOnCall(i int, result1 time.Duration) {
	fake.DiscoveryCacheExpirationTimeStub = nil
	if fake.discoveryCacheExpirationTimeReturnsOnCall == nil {
		fake.discoveryCacheExpirationTimeReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.discoveryCacheExpirationTimeReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxAttempts() int {
	fake.discoveryGossipMaxAttemptsMutex.Lock()
	ret, specificReturn := fake.discoveryGossipMaxAttemptsReturnsOnCall[len(fake.discoveryGossipMaxAttemptsArgsForCall)]
	fake.discoveryGossipMaxAttemptsArgsForCall = append(fake.discoveryGossipMaxAttemptsArgsForCall, struct{}{})
	fake.recordInvocation("DiscoveryGossipMaxAttempts", []interface{}{})
	fake.discoveryGossipMaxAttemptsMutex.Unlock()
	if fake.DiscoveryGossipMaxAttemptsStub != nil {
		return fake.DiscoveryGossipMaxAttemptsStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.discoveryGossipMaxAttemptsReturns.result1
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxAttemptsCallCount() int {
	fake.discoveryGossipMaxAttemptsMutex.RLock()
	defer fake.discoveryGossipMaxAttemptsMutex.RUnlock()
	return len(fake.discoveryGossipMaxAttemptsArgsForCall)
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxAttemptsReturns(result1 int) {
	fake.DiscoveryGossipMaxAttemptsStub = nil
	fake.discoveryGossipMaxAttemptsReturns = struct {
		result1 int
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxAttemptsReturnsOnCall(i int, result1 int) {
	fake.DiscoveryGossipMaxAttemptsStub = nil
	if fake.discoveryGossipMaxAttemptsReturnsOnCall == nil {
		fake.discoveryGossipMaxAttemptsReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.discoveryGossipMaxAttemptsReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryGossipTimeout() time.Duration {
	fake.discoveryGossipTimeoutMutex.Lock()
	ret, specificReturn := fake.discoveryGossipTimeoutReturnsOnCall[len(fake.discoveryGossipTimeoutArgsForCall)]
	fake.discoveryGossipTimeoutArgsForCall = append(fake.discoveryGossipTimeoutArgsForCall, struct{}{})
	fake.recordInvocation("DiscoveryGossipTimeout", []interface{}{})
	fake.discoveryGossipTimeoutMutex.Unlock()
	if fake.DiscoveryGossipTimeoutStub != nil {
		return fake.DiscoveryGossipTimeoutStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.discoveryGossipTimeoutReturns.result1
}

func (fake *DiscoveryConfig) DiscoveryGossipTimeoutCallCount() int {
	fake.discoveryGossipTimeoutMutex.RLock()
	defer fake.discoveryGossipTimeoutMutex.RUnlock()
	return len(fake.discoveryGossipTimeoutArgsForCall)
}

func (fake *DiscoveryConfig) DiscoveryGossipTimeoutReturns(result1 time.Duration) {
	fake.DiscoveryGossipTimeoutStub = nil
	fake.discoveryGossipTimeoutReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryGossipTimeoutReturnsOnCall(i int, result1 time.Duration) {
	fake.DiscoveryGossipTimeoutStub = nil
	if fake.discoveryGossipTimeoutReturnsOnCall == nil {
		fake.discoveryGossipTimeoutReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.discoveryGossipTimeoutReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxPeers() int {
	fake.discoveryGossipMaxPeersMutex.Lock()
	ret, specificReturn := fake.discoveryGossipMaxPeersReturnsOnCall[len(fake.discoveryGossipMaxPeersArgsForCall)]
	fake.discoveryGossipMaxPeersArgsForCall = append(fake.discoveryGossipMaxPeersArgsForCall, struct{}{})
	fake.recordInvocation("DiscoveryGossipMaxPeers", []interface{}{})
	fake.discoveryGossipMaxPeersMutex.Unlock()
	if fake.DiscoveryGossipMaxPeersStub != nil {
		return fake.DiscoveryGossipMaxPeersStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.discoveryGossipMaxPeersReturns.result1
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxPeersCallCount() int {
	fake.discoveryGossipMaxPeersMutex.RLock()
	defer fake.discoveryGossipMaxPeersMutex.RUnlock()
	return len(fake.discoveryGossipMaxPeersArgsForCall)
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxPeersReturns(result1 int) {
	fake.DiscoveryGossipMaxPeersStub = nil
	fake.discoveryGossipMaxPeersReturns = struct {
		result1 int
	}{result1}
}

func (fake *DiscoveryConfig) DiscoveryGossipMaxPeersReturnsOnCall(i int, result1 int) {
	fake.DiscoveryGossipMaxPeersStub = nil
	if fake.discoveryGossipMaxPeersReturnsOnCall == nil {
		fake.discoveryGossipMaxPeersReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.discoveryGossipMaxPeersReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *DiscoveryConfig) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.discoveryCacheExpirationTimeMutex.RLock()
	defer fake.discoveryCacheExpirationTimeMutex.RUnlock()
	fake.discoveryGossipMaxAttemptsMutex.RLock()
	defer fake.discoveryGossipMaxAttemptsMutex.RUnlock()
	fake.discoveryGossipTimeoutMutex.RLock()
	defer fake.discoveryGossipTimeoutMutex.RUnlock()
	fake.discoveryGossipMaxPeersMutex.RLock()
	defer fake.discoveryGossipMaxPeersMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *DiscoveryConfig) 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)
}

repository: Kashori/sidetree-fabric

repo_name: Kashori/sidetree-fabric

branch_name: refs/heads/main


text:
package model

import (
	"context"
	"io"
	"strings"
	"testing"
	"time"

	"github.com/evergreen-ci/logkeeper/env"
	"github.com/evergreen-ci/logkeeper/testutil"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gopkg.in/mgo.v2/bson"
)

func TestNewTestID(t *testing.T) {
	assert.True(t, strings.HasPrefix(NewTestID(time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)), "1174efedab186000"))
}

func TestTestID(t *testing.T) {
	t.Run("ObjectID", func(t *testing.T) {
		startTime := time.Date(2009, time.November, 10, 23, 0, 0, 1, time.UTC)
		objectID := bson.NewObjectIdWithTime(startTime)
		newID := objectID.Hex()
		assert.True(t, startTime.Equal(testIDTimestamp(newID).Add(time.Nanosecond)))
	})

	t.Run("TestID", func(t *testing.T) {
		startTime := time.Date(2009, time.November, 10, 23, 0, 0, 1, time.UTC)
		newID := NewTestID(startTime)
		assert.True(t, startTime.Equal(testIDTimestamp(newID)))
	})
}

func TestUploadTestMetadata(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	defer testutil.SetBucket(t, "")()
	test := Test{
		ID:            "62dba0159041307f697e6ccc",
		Name:          "test0",
		BuildID:       "5a75f537726934e4b62833ab6d5dca41",
		TaskID:        "t0",
		TaskExecution: 1,
		Phase:         "phase0",
		Command:       "command0",
	}
	expectedData, err := test.toJSON()
	require.NoError(t, err)
	require.NoError(t, test.UploadTestMetadata(ctx))

	r, err := env.Bucket().Get(ctx, "/builds/5a75f537726934e4b62833ab6d5dca41/tests/62dba0159041307f697e6ccc/metadata.json")
	require.NoError(t, err)
	data, err := io.ReadAll(r)
	require.NoError(t, err)
	assert.Equal(t, expectedData, data)
}

func TestTestKey(t *testing.T) {
	test := Test{
		ID:            "test0",
		Name:          "name",
		BuildID:       "build0",
		TaskID:        "t0",
		TaskExecution: 1,
		Phase:         "phase0",
		Command:       "command0",
	}
	assert.Equal(t, "builds/build0/tests/test0/metadata.json", test.key())
}

func TestTestToJSON(t *testing.T) {
	test := Test{
		ID:            "test0",
		Name:          "name",
		BuildID:       "build0",
		TaskID:        "t0",
		TaskExecution: 1,
		Phase:         "phase0",
		Command:       "command0",
	}
	data, err := test.toJSON()
	require.NoError(t, err)
	assert.JSONEq(t, `{"id":"test0","name":"name","build_id":"build0","task_id":"t0","execution":1,"phase":"phase0","command":"command0"}`, string(data))
}

func TestCheckTestMetadata(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	defer testutil.SetBucket(t, "../testdata/simple")()

	for _, test := range []struct {
		name     string
		buildID  string
		testID   string
		expected bool
	}{
		{
			name:     "BuildExists",
			buildID:  "5a75f537726934e4b62833ab6d5dca41",
			expected: true,
		},
		{
			name:     "TestExists",
			buildID:  "5a75f537726934e4b62833ab6d5dca41",
			testID:   "17046404de18d0000000000000000000",
			expected: true,
		},
		{
			name:     "BuildDNE",
			buildID:  "DNE",
			expected: false,
		},
		{
			name:     "BuildExistsTestDNE",
			buildID:  "5a75f537726934e4b62833ab6d5dca41",
			testID:   "DNE",
			expected: false,
		},
		{
			name:     "BuildDNETestDNE",
			buildID:  "DNE",
			testID:   "DNE",
			expected: false,
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			actual, err := CheckTestMetadata(ctx, test.buildID, test.testID)
			require.NoError(t, err)
			assert.Equal(t, test.expected, actual)
		})
	}
}

func TestFindTestByID(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	defer testutil.SetBucket(t, "../testdata/simple")()
	t.Run("Exists", func(t *testing.T) {
		expected := &Test{
			ID:            "17046404de18d0000000000000000000",
			BuildID:       "5a75f537726934e4b62833ab6d5dca41",
			Name:          "geo_max:CheckReplOplogs",
			TaskID:        "mongodb_mongo_master_enterprise_rhel_80_64_bit_multiversion_all_feature_flags_retryable_writes_downgrade_last_continuous_2_enterprise_f98b3361fbab4e02683325cc0e6ebaa69d6af1df_22_07_22_11_24_37",
			TaskExecution: 1,
			Phase:         "phase0",
			Command:       "command0",
		}
		actual, err := FindTestByID(ctx, "5a75f537726934e4b62833ab6d5dca41", "17046404de18d0000000000000000000")
		require.NoError(t, err)
		assert.Equal(t, expected, actual)
	})
	t.Run("BuildDNE", func(t *testing.T) {
		test, err := FindTestByID(ctx, "DNE", "17046404de18d0000000000000000000")
		require.NoError(t, err)
		assert.Nil(t, test)
	})
	t.Run("TestDNE", func(t *testing.T) {
		test, err := FindTestByID(ctx, "5a75f537726934e4b62833ab6d5dca41", "DNE")
		require.NoError(t, err)
		assert.Nil(t, test)
	})
}

func TestFindTestsForBuild(t *testing.T) {
	defer testutil.SetBucket(t, "../testdata/between")()

	expected := []Test{
		{
			ID:            "0de0b6b3bf4ac6400000000000000000",
			BuildID:       "5a75f537726934e4b62833ab6d5dca41",
			Name:          "geo_max:CheckReplOplogs",
			TaskID:        "Task",
			TaskExecution: 1,
			Command:       "command0",
			Phase:         "phase0",
		},
		{
			ID:            "0de0b6b3cb3688400000000000000000",
			BuildID:       "5a75f537726934e4b62833ab6d5dca41",
			Name:          "geo_max:CheckReplOplogs2",
			TaskID:        "Task",
			TaskExecution: 2,
			Command:       "command1",
			Phase:         "phase1",
		},
	}
	testResponse, err := FindTestsForBuild(context.Background(), "5a75f537726934e4b62833ab6d5dca41")
	require.NoError(t, err)
	assert.Equal(t, expected, testResponse)
}

func TestTestExecutionWindow(t *testing.T) {
	t.Run("NoLaterTest", func(t *testing.T) {
		startTime := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
		allTestIDs := []string{
			NewTestID(startTime),
		}
		tr, err := testExecutionWindow(allTestIDs, allTestIDs[0])
		assert.NoError(t, err)
		assert.True(t, tr.StartAt.Equal(startTime))
		assert.True(t, tr.EndAt.Equal(TimeRangeMax))
	})

	t.Run("LaterTest", func(t *testing.T) {
		startTime := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
		allTestIDs := []string{
			NewTestID(startTime),
			NewTestID(startTime.Add(time.Hour)),
		}
		tr, err := testExecutionWindow(allTestIDs, allTestIDs[0])
		assert.NoError(t, err)
		assert.True(t, tr.StartAt.Equal(startTime))
		assert.True(t, tr.EndAt.Equal(startTime.Add(time.Hour)))
	})

	t.Run("NanosecondsTruncated", func(t *testing.T) {
		startTime := time.Date(2009, time.November, 10, 23, 0, 0, 1000001, time.UTC)
		allTestIDs := []string{
			NewTestID(startTime),
		}
		tr, err := testExecutionWindow(allTestIDs, allTestIDs[0])
		assert.NoError(t, err)
		assert.True(t, tr.StartAt.Equal(time.Date(2009, time.November, 10, 23, 0, 0, 1000000, time.UTC)))
		assert.True(t, tr.EndAt.Equal(TimeRangeMax))
	})

	t.Run("NoTestID", func(t *testing.T) {
		allTestIDs := []string{
			NewTestID(time.Time{}),
		}
		tr, err := testExecutionWindow(allTestIDs, "")
		assert.NoError(t, err)
		assert.True(t, tr.StartAt.Equal(TimeRangeMin))
		assert.True(t, tr.EndAt.Equal(TimeRangeMax))
	})

	t.Run("NonExistentTestID", func(t *testing.T) {
		allTestIDs := []string{
			NewTestID(time.Time{}),
		}
		_, err := testExecutionWindow(allTestIDs, "DNE")
		assert.Error(t, err)
	})
}

func TestParseTestIDs(t *testing.T) {
	for name, testCase := range map[string]struct {
		keys          []string
		expectedIDs   []string
		errorExpected bool
	}{
		"EmptyList": {
			keys:        []string{},
			expectedIDs: []string{},
		},
		"NoMetadata": {
			keys:        []string{"key1", "key2"},
			expectedIDs: []string{},
		},
		"MalformedMetadata": {
			keys:          []string{"asdfgh/tests/0de0b6b3Bf4ac6400000000000000000/metadata.json"},
			errorExpected: true,
		},
		"MetadataAndLogChunk": {
			keys: []string{
				"builds/asdfgh/tests/0de0b6b3Bf4ac6400000000000000000/metadata.json",
				"builds/asdfgh/tests/0de0b6b3Bf4ac6400000000000000000/1000000000301000000_1000000000302000000_2",
			},
			expectedIDs: []string{"0de0b6b3Bf4ac6400000000000000000"},
		},
		"Sorted": {
			keys: []string{
				"builds/asdfgh/tests/0de0b6b3cb3688400000000000000000/metadata.json",
				"builds/asdfgh/tests/0de0b6b3Bf4ac6400000000000000000/metadata.json",
			},
			expectedIDs: []string{"0de0b6b3Bf4ac6400000000000000000", "0de0b6b3cb3688400000000000000000"},
		},
	} {
		t.Run(name, func(t *testing.T) {
			testIDs, err := parseTestIDs(testCase.keys)
			if testCase.errorExpected {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
				assert.ElementsMatch(t, testCase.expectedIDs, testIDs)
			}
		})
	}
}

repository: evergreen-ci/logkeeper

repo_name: evergreen-ci/logkeeper

gha_license_id: NOASSERTION

gha_language: Go


text:
@book{lumley2011complex,
  title={Complex surveys: a guide to analysis using R},
  author={Lumley, Thomas},
  volume={565},
  year={2011},
  publisher={John Wiley \& Sons}
}

repository: sociedat/survey-docs

repo_name: sociedat/survey-docs


text:
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://inc/rk_mpi.h;beginline=4;endline=14;md5=acbba394ae5639b0c786f60c1f48e3d6"

SRC_URI = "git://${EXTRA}/mpp;protocol=file;usehead=1"
SRCREV = "${AUTOREV}"
S = "${WORKDIR}/git"

inherit pkgconfig cmake

EXTRA_OECMAKE = "     \
    -DRKPLATFORM=ON   \
    -DHAVE_DRM=ON     \
"

CFLAGS += "-D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64"

PACKAGES = "${PN}-demos ${PN}-dbg ${PN}-staticdev ${PN}-dev ${PN} ${PN}-vpu"
FILES_${PN}-vpu = "${libdir}/lib*vpu${SOLIBS}"
FILES_${PN} = "${libdir}/lib*mpp${SOLIBS}"
FILES_${PN}-dev = "${libdir}/lib*${SOLIBSDEV} ${includedir} ${libdir}/pkgconfig"
FILES_${PN}-demos = "${bindir}/*"
SECTION_${PN}-dev = "devel"
FILES_${PN}-staticdev = "${libdir}/*.a"
SECTION_${PN}-staticdev = "devel"

repository: ponmadasamy/meta-dealcore

repo_name: ponmadasamy/meta-dealcore


text:
package s3

import (
	"bytes"
	"fmt"
	"log"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/service/s3"
	keyStorageLocal "github.com/madappgang/identifo/configuration/key_storage/local"
	keyStorageS3 "github.com/madappgang/identifo/configuration/key_storage/s3"
	s3Storage "github.com/madappgang/identifo/external_services/storage/s3"
	ijwt "github.com/madappgang/identifo/jwt"
	"github.com/madappgang/identifo/model"
	"gopkg.in/yaml.v2"
)

// ConfigurationStorage is a server configuration storage in S3.
type ConfigurationStorage struct {
	Client           *s3.S3
	Bucket           string
	ObjectName       string
	UpdateChan       chan interface{}
	updateChanClosed bool
	keyStorage       model.KeyStorage
}

// NewConfigurationStorage creates new server config storage in S3.
func NewConfigurationStorage(settings model.ConfigurationStorageSettings) (*ConfigurationStorage, error) {
	s3client, err := s3Storage.NewS3Client(settings.Region)
	if err != nil {
		return nil, err
	}

	var keyStorage model.KeyStorage

	switch settings.KeyStorage.Type {
	case model.KeyStorageTypeLocal:
		keyStorage, err = keyStorageLocal.NewKeyStorage(settings.KeyStorage)
	case model.KeyStorageTypeS3:
		keyStorage, err = keyStorageS3.NewKeyStorage(settings.KeyStorage)
	default:
		return nil, fmt.Errorf("Unknown key storage type: %s", settings.KeyStorage.Type)
	}
	if err != nil {
		return nil, err
	}

	cs := &ConfigurationStorage{
		Client:     s3client,
		Bucket:     settings.Bucket,
		ObjectName: settings.SettingsKey,
		keyStorage: keyStorage,
		UpdateChan: make(chan interface{}, 1),
	}
	return cs, nil
}

// LoadServerSettings loads server configuration from S3.
func (cs *ConfigurationStorage) LoadServerSettings(settings *model.ServerSettings) error {
	getObjInput := &s3.GetObjectInput{
		Bucket: aws.String(cs.Bucket),
		Key:    aws.String(cs.ObjectName),
	}

	resp, err := cs.Client.GetObject(getObjInput)
	if err != nil {
		return fmt.Errorf("Cannot get object from S3: %s", err)
	}
	defer resp.Body.Close()

	if err = yaml.NewDecoder(resp.Body).Decode(settings); err != nil {
		return fmt.Errorf("Cannot decode S3 response: %s", err)
	}

	if settings.ConfigurationStorage.Type != model.ConfigurationStorageTypeS3 {
		return fmt.Errorf("Configuration file from S3 specifies configuration type %s", settings.ConfigurationStorage.Type)
	}

	return nil
}

// InsertConfig puts new configuration into the storage.
func (cs *ConfigurationStorage) InsertConfig(key string, value interface{}) error {
	log.Println("Putting new config to S3...")

	valueBytes, err := yaml.Marshal(value)
	if err != nil {
		return fmt.Errorf("Cannot marshal settings value: %s", err)
	}

	_, err = cs.Client.PutObject(&s3.PutObjectInput{
		Bucket:        aws.String(cs.Bucket),
		Key:           aws.String(cs.ObjectName),
		ACL:           aws.String("private"),
		StorageClass:  aws.String(s3.ObjectStorageClassStandard),
		Body:          bytes.NewReader(valueBytes),
		ContentLength: aws.Int64(int64(len(valueBytes))),
		ContentType:   aws.String("application/x-yaml"),
	})

	if err == nil {
		log.Println("Successfully put new configuration to S3")
	}

	// Indicate config update. To prevent writing to a closed channel, make a check.
	go func() {
		if cs.updateChanClosed {
			log.Println("Attempted to write to closed UpdateChan")
			return
		}
		cs.UpdateChan <- struct{}{}
	}()

	return err
}

// InsertKeys inserts new public and private keys to the S3 bucket.
func (cs *ConfigurationStorage) InsertKeys(keys *model.JWTKeys) error {
	if err := cs.keyStorage.InsertKeys(keys); err != nil {
		return err
	}
	return nil
}

// LoadKeys loads public and private keys from the key storage.
func (cs *ConfigurationStorage) LoadKeys(alg ijwt.TokenSignatureAlgorithm) (*model.JWTKeys, error) {
	return cs.keyStorage.LoadKeys(alg)
}

// GetUpdateChan returns update channel.
func (cs *ConfigurationStorage) GetUpdateChan() chan interface{} {
	return cs.UpdateChan
}

// CloseUpdateChan closes update channel.
func (cs *ConfigurationStorage) CloseUpdateChan() {
	close(cs.UpdateChan)
	cs.updateChanClosed = true
}

repository: sokolovstas/identifo

repo_name: sokolovstas/identifo

gha_license_id: MIT


text:
package model

// Specifies an item in the agenda of the meeting. Some resolutions are submitted to the vote of the security holders, some are presented for information only.
type Resolution2 struct {

	// Numbering of the resolution as specified by the issuer or  its agent.
	IssuerLabel *Max35Text `xml:"IssrLabl"`

	// Free text description of the resolution.
	Description *Max1025Text `xml:"Desc,omitempty"`

	// Abbreviated description of the resolution.
	Title *Max350Text `xml:"Titl,omitempty"`

	// Indicates whether a resolution is ordinary, extraordinary or special.
	Type *ResolutionType1Code `xml:"Tp"`

	// Indicates whether the resolution is listed for information or for voting.
	ForInformationOnly *YesNoIndicator `xml:"ForInfOnly"`

	// Indicates whether the resolution is active or withdrawn.
	Status *ResolutionStatus1Code `xml:"Sts"`

	// Indicates whether the resolution has been submitted by the security holder.
	SubmittedBySecurityHolder *YesNoIndicator `xml:"SubmittdBySctyHldr"`

	// Vote options allowed at the resolution level. When specified, it supersedes the vote options given for the meeting.
	VoteInstructionType []*VoteInstruction2Code `xml:"VoteInstrTp,omitempty"`

	// Indicates how the management of the issuing company wishes the security holders to vote.
	ManagementRecommendation *VoteInstruction1Code `xml:"MgmtRcmmndtn,omitempty"`

	// Indicates how the notifying party recommends that the security holders vote.
	NotifyingPartyRecommendation *VoteInstruction1Code `xml:"NtifngPtyRcmmndtn,omitempty"`
}

func (r *Resolution2) SetIssuerLabel(value string) {
	r.IssuerLabel = (*Max35Text)(&value)
}

func (r *Resolution2) SetDescription(value string) {
	r.Description = (*Max1025Text)(&value)
}

func (r *Resolution2) SetTitle(value string) {
	r.Title = (*Max350Text)(&value)
}

func (r *Resolution2) SetType(value string) {
	r.Type = (*ResolutionType1Code)(&value)
}

func (r *Resolution2) SetForInformationOnly(value string) {
	r.ForInformationOnly = (*YesNoIndicator)(&value)
}

func (r *Resolution2) SetStatus(value string) {
	r.Status = (*ResolutionStatus1Code)(&value)
}

func (r *Resolution2) SetSubmittedBySecurityHolder(value string) {
	r.SubmittedBySecurityHolder = (*YesNoIndicator)(&value)
}

func (r *Resolution2) AddVoteInstructionType(value string) {
	r.VoteInstructionType = append(r.VoteInstructionType, (*VoteInstruction2Code)(&value))
}

func (r *Resolution2) SetManagementRecommendation(value string) {
	r.ManagementRecommendation = (*VoteInstruction1Code)(&value)
}

func (r *Resolution2) SetNotifyingPartyRecommendation(value string) {
	r.NotifyingPartyRecommendation = (*VoteInstruction1Code)(&value)
}