text:
become more complex, their interfaces are also becoming harder to use. At the same time, more people are carrying hand-held computerized devices that can communicate. We envision a future in which people will use their handhelds to communicate with and control common appliances in their environment. This work describes the design of a specification language and the construction of an automatic interface generator, using lessons learned from analyzing manually created interfaces.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {864–865},
numpages = {2},
keywords = {appliances, pebbles, handheld computers, remote control, personal digital assistants (PDAs)},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506638,
author = {Wobbrock, Jacob O.},
title = {In Your Own Words: Using Full Sentences as Feedback},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506638},
doi = {10.1145/506443.506638},
abstract = {Many applications have cluttered dialogs that require users to make complicated settings. Some settings even determine the availability and state of other settings, creating interdependencies that can be hard to discern. Most afforadances, although they aid the use of individual widgets, provide no feedback about overall configurations. Here I present a technique for providing feedback in configuration tools using grammar-generated sentences that update instantly as the user acts. Experimental results confirm the technique has promise.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {866–867},
numpages = {2},
keywords = {configuration task, feedback, configuration tool, natural language, grammar, affordance, widget},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506639,
author = {Goldberg, Joseph and Hagman, Jennifer and Sazawal, Vibha},
title = {Doodling Our Way to Better Authentication},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506639},
doi = {10.1145/506443.506639},
abstract = {Password security often fails in practice because users select predictable passwords. We conducted a study to explore the use of hand-drawn doodle password ("passdoodle"). Our findings show that users could recall all visual elements of the doodle as well as they could recall alphanumeric passwords, but most could not perfectly redraw their selected doodles. Users perceive passdoodles as easier to remember than alphanumeric passwords; however, they prefer whichever authentication method they perceive to be more secure.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {868–869},
numpages = {2},
keywords = {authentication, passwords, passdoodles, user study},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506640,
author = {Fernandes, Gary and Holmes, Cassandra},
title = {Applying HCI to Music-Related Hardware},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506640},
doi = {10.1145/506443.506640},
abstract = {The application of usability techniques to the development of music-related hardware is rarely discussed in the HCI literature. This is in spite of the fact that such devices could potentially be improved by employing usability methods during their development. This paper documents a case study of an existing electric guitar pre-amplifier. The ease of use of its user interface was investigated using the traditional HCI methods of heuristic evaluation and usability testing. The user interface was susequently modified, and a follow-up usability test confirmed improvements to ease of use. These findings demonstrate that HCI methods can and should be used to enhance the usability of music-related hardware.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {870–871},
numpages = {2},
keywords = {heuristic evaluation, music-related hardware, usability test, usability},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506641,
author = {Werner, Korin},
title = {A Comparison of Information Visualization Methods},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506641},
doi = {10.1145/506443.506641},
abstract = {Large hierarchies of information (such as maps, graphs, amd web pages) that must be fit onto small areas are present everywhere. The size restriction prevents the user from viewing the entire structure at once, which causes the context of the information to be lost. Conversely, if the entire structure is visible all at once, the details are too small to read and specific information is lost to the user. The present research studies different visualization techniques that present detailed specific information from large hierarchies on a single screen, while preserving the information's context within the global structure. Results show that Internet Explorer supported superior user performance in both time and accuracy when compared to three other methods of information visualization.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {872–873},
numpages = {2},
keywords = {information visualization, fisheye, hyperbolic browser},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506642,
author = {Chandler, Corey D. and Lo, Gloria and Sinha, Anoop K.},
title = {Multimodal Theater: Extending Low Fidelity Paper Prototyping to Multimodal Applications},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506642},
doi = {10.1145/506443.506642},
abstract = {Low-fidelity paper prototyping has proven to be a useful technique for designing graphical user interfaces [1]. Wizard of Oz prototyping for other input modalities, such as speech, also has a long history [2]. Yet to surface are guidelines for low-fidelity prototyping of multimodal applications, those that use multiple and sometimes simultaneous combination of different input types. This paper describes our recent research in low fidelity, multimodal, paper prototyping and suggest guidelines to be used by future designers of multimodal applications.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {874–875},
numpages = {2},
keywords = {prototyping, Wizard of Oz, design methodologies, informal user interfaces, low-fidelity, multimodal},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506643,
author = {Pelaprat, Etienne and Shapiro, R. Benjamin},
title = {User Activity Histories},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506643},
doi = {10.1145/506443.506643},
abstract = {Current software interfaces fail to incorporate historical data from user interaction into their design. While some systems exhibit a minimalist use of history in the form of undo and redo, selective menu items, and other static elements, there has been a lack of use of history in the dynamic elements of interaction. We propose a more widespread use of historical data from user-software interaction to augment the desktop and application environment. We believe the use of historical data can improve the user's experience at many different levels. Our approach begins by assuming that everything the user is doing on the desktop is important to them, and that it will be important again in the future.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {876–877},
numpages = {2},
keywords = {human factors, graphical user interfaces, groupware, workflow management},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506644,
author = {Klemmer, Scott and Everitt, Katherine},
title = {Bridging Physical and Electronic Media for Distributed Design Collaboration},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506644},
doi = {10.1145/506443.506644},
abstract = {Research on distributed collaboration has predominantly focused on shared electronic media. We have found, as other researchers have, that users often have good reason to want to work with physical media. Yet they would still like to collaborate with each other. A fundamental tension exists in the design of systems to support remote collaboration when the interaction primitives are physical: physical objects live in one place. We have designed and implemented a remote collaboration system where users can still use physical objects. We introduce an interaction paradigm where objects that are physical in one space are electronic in the other space, and vice versa. Our distributed system is designed for two groups, with multiple users at each end. Our tangible approach is the first system to enable simultaneous, multi-input across locations. We have implemented this system as an extension to the Designers' Outpost[5].},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {878–879},
numpages = {2},
keywords = {CSCW, tangible, remote collaboration, shared workspace},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506646,
author = {Wixon, Dennis R. and Ramey, Judy and Holtzblatt, Karen and Beyer, Hugh and Hackos, JoAnn and Rosenbaum, Stephanie and Page, Colleen and Laakso, Sari A. and Laakso, Karri-Pekka},
title = {Usability in Practice: Field Methods Evolution and Revolution},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506646},
doi = {10.1145/506443.506646},
abstract = {Field Methods are a collection of tools and techniques for conducting studies of users, their tasks, and their work environments in the actual context of those environments. The promise of such methods is that they help teams design products that are both useful and usable by providing data about what people really do. Participants in this forum will address: the origins and framework of Contextual Designthe application of field methods to task analysisa review of ways to adapt these methods to practical constraintsa discount approach to field studies.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {880–884},
numpages = {5},
keywords = {user-centered design, consensus building, contextual design, user interface design, field research methods, iterative design, contextual inquiry},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506647,
author = {Redish, Janice (Ginny) and Bias, Randolph G. and Bailey, Robert and Molich, Rolf and Dumas, Joe and Spool, Jared M.},
title = {Usability in Practice: Formative Usability Evaluations - Evolution and Revolution},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506647},
doi = {10.1145/506443.506647},
abstract = {Formative evaluation is a collection of "find-and-fix" usability engineering methods, focused on identifying usability problems before a product is completed. In this forum, four experienced usability professionals will address different aspects of formative evaluations:which methods are most effective,how to maximize the chances of effecting change and implementing the usability recommendations,the importance of the usability professional's relationship with the product developer, andthe importance of developing a science of user interface design, to minimize the need for iterative evaluations.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {885–890},
numpages = {6},
keywords = {user-centered design, consensus building, user interface design, usability engineering, usability report, iterative design, usability methods, inspection methods},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506648,
author = {Rohn, Janice A. and Spool, Jared and Ektare, Mayuresh and Koyani, Sanjay and Muller, Michael and Redish, Janice (Ginny)},
title = {Usability in Practice: Alternatives to Formative Evaluations-Evolution and Revolution},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506648},
doi = {10.1145/506443.506648},
abstract = {The adoption of user experience methods within companies has followed a similar evolution over the past two decades. Typically organizations originally institute formative lab-based evaluations, and then add field studies and other user experience methods to their repertoire. This evolution typically occurs because the organization recognizes the need for more data on customer profiles, feature requirements, and task flows, along with the ability to iterate quickly among various design ideas and directions. These methods that fall outside of the categories of formative usability evaluations and field studies are addressed in this paper. Although there are a wide variety of methods within this 'alternative' category, a few representative samples will be discussed in more detail here. In actuality, these methods are not 'alternatives,' rather, they are additions to the toolkit of user experience methods that should be used in conjunction with formative usability studies and field studies.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {891–897},
numpages = {7},
keywords = {usability methods, participatory design, user-centered design, guidelines, user experience, usability engineering, error messages, inspection methods},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506649,
author = {Rosenbaum, Stephanie and Wilson, Chauncey E. and Jokela, Timo and Rohn, Janice A. and Smith, Trixi B. and Vredenburg, Karel},
title = {Usability in Practice: User Experience Lifecycle - Evolution and Revolution},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506649},
doi = {10.1145/506443.506649},
abstract = {The practice of usability and user-centered design must integrate with many other activities in the product development lifecycle. This integration requires political savvy, knowledge of a wide variety of methods, flexibility in using methods, inspiration, and innovation. The speakers and their colleagues have met these requirements and describe their experience fitting various methods into design and development efforts. This forum highlights their successes and setbacks.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {898–903},
numpages = {6},
keywords = {user experience, competitive analysis, usability, user-centered design, current state analysis},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506651,
author = {Muller, Michael J. and Millen, David R.},
title = {Workshop: Creating and Refining Knowledges, Identities, and Understandings in on-Line Communities},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506651},
doi = {10.1145/506443.506651},
abstract = {This two-day workshop examines the ways that on-line communities create and refine their shared resources, in-cluding both the formal and observable artifacts (docu-ments, chats, threads) and the less tangible conventions, roles, and identities in the community.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {905},
numpages = {1},
keywords = {CSCW, communities, communities of practice, online communities},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506652,
author = {Brinck, Tom and Hofer, Erik},
title = {Automatically Evaluating the Usability of Web Sites},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506652},
doi = {10.1145/506443.506652},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {906–907},
numpages = {2},
keywords = {instrumented browsers, web site usability, task analysis, HTML validation, automatic usability evaluation, web usability standards, website usage data},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506653,
author = {van Welie, Martijn and Mullet, Kevin and McInerney, Paul},
title = {Patterns in Practice: A Workshop for UI Designers},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506653},
doi = {10.1145/506443.506653},
abstract = {This one-day workshop focuses on how UI designers are using patterns today. The scope includes the two overlapping areas of concern to design practitioners: (1) writing valid and useful patterns and (2) using patterns effectively in a design assignment.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {908–909},
numpages = {2},
keywords = {user interfaces, patterns, design},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506654,
author = {Blackwell, Alan and Robinson, Peter and Roast, Chris and Green, Thomas},
title = {Cognitive Models of Programming-like Activity},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506654},
doi = {10.1145/506443.506654},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {910–911},
numpages = {2},
keywords = {abstraction, domestic computing, programming},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506655,
author = {Allanson, Jennifer and Wilson, Gillian M.},
title = {Physiological Computing},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506655},
doi = {10.1145/506443.506655},
abstract = {Applications involving the measurement of human physiological responses to environment are becoming increasingly popular in HCI. This is due in part to the increasing availability of low-cost, high-specification sensing technologies. Areas such HCI evaluation, affective computing and biofeedback-based brain-computer interaction are all benefiting from the rich data source physiological sensing technologies make available. However, guidelines on the gathering and analysis of these measurements are virtually non-existent, which makes it difficult for new researchers to practise in this area. This timely workshop will bring together both practising and potential researchers using this method to gather knowledge on the techniques, technologies and applications of physiological computing.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {912–913},
numpages = {2},
keywords = {HCI evaluation, affective computing, brain-computer interaction, biofeedback, physiological computing},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506656,
author = {Lai, Jennifer and Dahlb\"{a}ck, Nils and J\"{o}nsson, Arne},
title = {Robustness in Speech Based Interfaces: Sharing the Tricks of the Trade},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506656},
doi = {10.1145/506443.506656},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {915},
numpages = {1},
keywords = {speech-based interfaces, interaction design, robustness},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506657,
author = {Fussell, Susan R. and Kraut, Robert E. and Siegel, Jane and Brennan, Susan E.},
title = {Relationships among Speech, Vision, and Action in Collaborative Physical Tasks},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506657},
doi = {10.1145/506443.506657},
abstract = {This workshop focuses on the relationships among speech, gaze and action in collaborative physical tasks. We address three key challenges: characterizing the nature of collaborative physical tasks, understanding how people coordinate their activities during collaborative physical tasks, and designing technology to support these tasks.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {916–917},
numpages = {2},
keywords = {computer-supported collaborative work, conversational analysis, wearable computers, video mediated communication, empirical studies},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506658,
author = {Marsh, Stephen and Nowell, Lucy and Meech, John F. and Dautenhahn, Kerstin},
title = {The Philosophy and Design of Socially Adept Technologies},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506658},
doi = {10.1145/506443.506658},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {918–919},
numpages = {2},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506659,
author = {Berkun, Scott},
title = {Workshop: Teaching Interaction Design},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506659},
doi = {10.1145/506443.506659},
abstract = {A full day workshop focused on the practice and philoso-phies involved with teaching interaction design to students and professionals. The format involved teachers expressing their approaches to the challenges of design education, and group discussion and sharing of ideas and stories from their experiences.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {921},
numpages = {1},
keywords = {usability, interaction design, learning, user experience, ease of use, training, design education, web design},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506660,
author = {Laskowski, Sharon J. and Landay, James A. and Lister, Mike},
title = {Automatic Capture, Representation, and Analysis of User Behavior},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506660},
doi = {10.1145/506443.506660},
abstract = {The goal of this workshop is to explore the implications of automated capture and analysis of user behaviors on HCI and UE research.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {922–923},
numpages = {2},
keywords = {log analysis, automation, remote testing, usability, validation, evaluation},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506661,
author = {Monk, Andrew and Hassenzahl, Marc and Blythe, Mark and Reed, Darren},
title = {Funology: Designing Enjoyment},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506661},
doi = {10.1145/506443.506661},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {924–925},
numpages = {2},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506662,
author = {Instone, Keith and Chan, Lisa and Boersma, Peter and Olsen, George},
title = {HCI & IA: Information, Interaction, Interface and Usability Architects Share Deliverables},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506662},
doi = {10.1145/506443.506662},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {927},
numpages = {1},
keywords = {deliverables, information architecture, information design, interaction architecture, interface architecture, usability architecture},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506663,
author = {Lindgaard, Gitte and Millard, Nicola},
title = {The Business Value of HCI: How Can We Do Better?},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506663},
doi = {10.1145/506443.506663},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {928–929},
numpages = {2},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506664,
author = {Fujinuma, Mizue and Risden, Kirsten},
title = {It's a Global Economy out There: Usability Innovation for Global Marketplaces},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506664},
doi = {10.1145/506443.506664},
abstract = {We describe a workshop for usability researchers to share information about international and intercultural research methods.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {930},
numpages = {1},
keywords = {international, intercultural, research methods, usability},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506665,
author = {Kortuem, Gerd and Gellersen, Hans-Werner and Billinghurst, Mark},
title = {Mobile Ad Hoc Collaboration},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506665},
doi = {10.1145/506443.506665},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {931},
numpages = {1},
keywords = {PAN, spontaneous collaboration, ad-hoc networks, CSCW, MANET, mobile collaboration},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506666,
author = {Frishberg, Nancy and Dirks, Anna Marie and Benson, Calum and Nickell, Seth and Smith, Suzanna},
title = {Getting to Know You: Open Source Development Meets Usability},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506666},
doi = {10.1145/506443.506666},
abstract = {This workshop seeks to increase the likelihood that usabil-ity will become a core value in open source software de-velopment by creating a meeting ground of people with direct experience of both perspectives. Anticipated out-comes include tangible and immediate production of arti-cles and posters, as well as intangible and longer term re-search agenda, outreach efforts to increase the number of people with usability and interaction design expertise in-volved in all open source projects.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {932–933},
numpages = {2},
keywords = {computer supported cooperative work, open source software development},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506667,
author = {Burleson, Winslow and Selker, Ted},
title = {CHI2002: Creative Computing Workshop},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506667},
doi = {10.1145/506443.506667},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {934–935},
numpages = {2},
keywords = {creativity, captology, peak performance, context},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506668,
author = {Erickson, Thomas and Herring, Susan and Sack, Warren},
title = {Discourse Architectures: Designing and Visualizing Computer Mediated Conversation},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506668},
doi = {10.1145/506443.506668},
abstract = {The goal of this workshop is to examine the issue of coherence in computer-mediated (text-based) conversation (CMC), and how it can be visualized graphically. The premise underlying the workshop is that the understandings of coherence developed by designers and researchers can usefully inform one another. Analytical representations based on discourse research and/or theory might, suitably modified, serve as interface designs, and the interplay between graphical user interfaces and the achievement of coherence by users might advance research understandings.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {936–937},
numpages = {2},
keywords = {CMC, structure, coherence, methods, CSCW, conversation, computer mediated communication, analysis, design},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

@inproceedings{10.1145/506443.506669,
author = {Plaisant, Catherine and Druin, Allison and Hutchinson, Hilary},
title = {Technologies for Families},
year = {2002},
isbn = {1581134541},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/506443.506669},
doi = {10.1145/506443.506669},
abstract = {In this workshop, we propose to bring together researchers from industry and academia to discuss the design of new technologies for families. We will focus on both design techniques and the technologies themselves. Through discussions and brainstorming we hope to discover new ideas, which can be disseminated more broadly.},
booktitle = {CHI '02 Extended Abstracts on Human Factors in Computing Systems},
pages = {938–939},
numpages = {2},
keywords = {probe, home, disappearing computer, family, cooperative design, participatory design, user interface},
location = {Minneapolis, Minnesota, USA},
series = {CHI EA '02}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr

branch_name: refs/heads/main

extension: bib


text:
export class Post{
    constructor(
        public nome: string,
        public titulo: string,
        public subtitulo: string,
        public email: string,
        public mensagem: string,
        public arquivo?: string,
        public id?: string,
        public likes?: string
    ) {}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: ts


text:
import { isFunction } from 'lodash';
import type {
  BlurData, ChangeData, FocusData, MaskedInputProps, MaskedInputState,
} from './types';
import type {
  BlurEvent, FocusEvent, ChangeEvent, EnterPressEvent,
} from '../../src/MaskedInputBase/types';
import type { CustomEventHandler, SetState } from '../../commonTypes';
import { getValueToValidate } from './helpers';
import { maskValue } from '../../src/MaskedInputBase/helpers';

export const createChangeHandler = (
  props: MaskedInputProps,
  state: MaskedInputState,
  extraData: ChangeData,
): CustomEventHandler<ChangeEvent> => (ev) => {
  const { onChange, name, value: valueProp } = props;

  const { setValue } = extraData;

  if (isFunction(onChange)) {
    const customEvent = {
      ...ev,
      component: {
        name,
        inputValue: ev.component.inputValue,
        value: ev.component.value,
      },
    };

    onChange(customEvent as ChangeEvent);
  }

  if (valueProp === undefined) setValue(ev.component.value);
};

export const createBlurHandler = (
  props: MaskedInputProps,
  state: MaskedInputState,
  extraData: BlurData,
): CustomEventHandler<BlurEvent> => (ev) => {
  const { onBlur, name } = props;

  const {
    validateCurrent,
    setFocused,
    value,
    maskedInputRef,
    placeholderChar,
  } = extraData;

  const valueToValidate = getValueToValidate({
    value, maskedInputRef, placeholderChar,
  });

  const isValid = validateCurrent(valueToValidate);

  if (isFunction(onBlur)) {
    const customEvent = {
      ...ev,
      component: {
        name,
        value,
        isValid,
      },
    };

    onBlur(customEvent as BlurEvent);
  }

  setFocused(false);
};

export const createFocusHandler = (
  props: MaskedInputProps,
  state: MaskedInputState,
  extraData: FocusData,
): CustomEventHandler<FocusEvent> => (ev) => {
  const { onFocus, name } = props;

  const { setFocused, value } = extraData;

  if (isFunction(onFocus)) {
    const customEvent = {
      ...ev,
      component: {
        name,
        value,
      },
    };

    onFocus(customEvent as FocusEvent);
  }

  setFocused(true);
};

export const createKeyDownHandler = (
  props: MaskedInputProps,
) => (ev: EnterPressEvent) => {
  const { name, onEnterPress } = props;

  if (ev.key === 'Enter' && isFunction(onEnterPress)) {
    const event = {
      ...ev,
      component: {
        name,
        value: ev.component.value,
        inputValue: ev.currentTarget.value,
      },
    };
    onEnterPress(event);
  }
};

export const createResetHandler = ({
  props,
  setValue,
  value,
}: {
  props: MaskedInputProps,
  setValue: SetState<string>,
  value: string,
}) => () => {
  setValue(value);
  if (isFunction(props.onChange)) {
    const customEvent = {
      component: {
        name: props.name,
        value,
        inputValue: maskValue(value, props.mask, props.placeholderChar),
      },
    };
    props.onChange(customEvent);
  }
};

gha_license_id: MIT

gha_language: TypeScript


text:
/*
    Copyright (c) 2015, Christopher Nitta
    All rights reserved.

    All source material (source code, images, sounds, etc.) have been provided to
    University of California, Davis students of course ECS 160 for educational
    purposes. It may not be distributed beyond those enrolled in the course without
    prior permission from the copyright holder.

    All sound files, sound fonts, midi files, and images that have been included
    that were extracted from original Warcraft II by Blizzard Entertainment
    were found freely available via internet sources and have been labeld as
    abandonware. They have been included in this distribution for educational
    purposes only and this copyright notice does not attempt to claim any
    ownership of this material.
*/
#ifndef POSITION_H
#define POSITION_H
#include "GameDataTypes.h"
#include <vector>

class CPosition{
    protected:
        int DX;
        int DY;

        static int DTileWidth;
        static int DTileHeight;
        static int DHalfTileWidth;
        static int DHalfTileHeight;
        static std::vector< std::vector < EDirection > > DOctant;
        static std::vector< std::vector < EDirection > > DTileDirections;

        CPosition() = default;
        CPosition(int x, int y);
        CPosition(const CPosition &pos) = default;

        CPosition &operator=(const CPosition &pos) = default;

        bool operator==(const CPosition &pos) const;
        bool operator!=(const CPosition &pos) const;

        EDirection DirectionTo(const CPosition &pos) const;

        EDirection TileOctant() const;

        int DistanceSquared(const CPosition &pos);
        int Distance(const CPosition &pos);

    public:
        int X() const{
            return DX;
        };

        int X(int x){
            return DX = x;
        };

        int IncrementX(int x){
            DX += x;
            return DX;
        };

        int DecrementX(int x){
            DX -= x;
            return DX;
        };

        int Y() const{
            return DY;
        };

        int Y(int y){
            return DY = y;
        };

        int IncrementY(int y){
            DY += y;
            return DY;
        };

        int DecrementY(int y){
            DY -= y;
            return DY;
        };

        static void SetTileDimensions(int width, int height);

        static int TileWidth(){
            return DTileWidth;
        };

        static int TileHeight(){
            return DTileHeight;
        };

        static int HalfTileWidth(){
            return DHalfTileWidth;
        };

        static int HalfTileHeight(){
            return DHalfTileHeight;
        };

};

class CPixelPosition;

class CTilePosition : public CPosition{
    public:
        CTilePosition() = default;
        CTilePosition(int x, int y);
        CTilePosition(const CTilePosition &pos) = default;

        CTilePosition &operator=(const CTilePosition &pos) = default;

        bool operator==(const CTilePosition &pos) const;
        bool operator!=(const CTilePosition &pos) const;

        void SetFromPixel(const CPixelPosition &pos);
        void SetXFromPixel(int x);
        void SetYFromPixel(int y);

        EDirection AdjacentTileDirection(const CTilePosition &pos, int objsize = 1) const;
        int DistanceSquared(const CTilePosition &pos);
};

class CPixelPosition : public CPosition{
    protected:

    public:
        CPixelPosition() = default;
        CPixelPosition(int x, int y);
        CPixelPosition(const CPixelPosition &pos) = default;

        CPixelPosition &operator=(const CPixelPosition &pos) = default;

        bool operator==(const CPixelPosition &pos) const;
        bool operator!=(const CPixelPosition &pos) const;

        bool TileAligned() const{
            return ((DX % DTileWidth) == DHalfTileWidth) && ((DY % DTileHeight) == DHalfTileHeight);
        };

        void SetFromTile(const CTilePosition &pos);
        void SetXFromTile(int x);
        void SetYFromTile(int y);

        EDirection DirectionTo(const CPixelPosition &pos) const;
        EDirection TileOctant() const;
        CPixelPosition ClosestPosition(const CPixelPosition &objpos, int objsize) const;
        int DistanceSquared(const CPixelPosition &pos);
        int Distance(const CPixelPosition &pos);
};

#endif

extension: h


text:
package controllers_test

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"github.com/gin-gonic/gin"

	"github.com/GoPex/unleash/bindings"
	"github.com/GoPex/unleash/controllers"
	"github.com/GoPex/unleash/tests"
)

type handlerTest struct {
	jsonInputPath string
	handler       gin.HandlerFunc
}

var (
	testGithubPushEventJSON    = filepath.Join(tests.DataDirectory, "github_push_event.json")
	testBitbucketPushEventJSON = filepath.Join(tests.DataDirectory, "bitbucket_push_event.json")

	handlerTests = []handlerTest{
		{testGithubPushEventJSON, controllers.PostGithub},
		{testBitbucketPushEventJSON, controllers.PostBitbucket},
	}
)

// TestPostHandlers of events
func TestPostHandlers(t *testing.T) {
	for _, handlerTest := range handlerTests {
		body, err := os.Open(handlerTest.jsonInputPath)
		if err != nil {
			t.Fatalf("Unable to open %s to be send as the body of the POST request ! Cause: %s", testGithubPushEventJSON, err)
		}

		req, _ := http.NewRequest("POST", "/push", body)
		req.Header.Set("Content-Type", "application/json")
		w := httptest.NewRecorder()

		router := gin.New()
		router.POST("/push", handlerTest.handler)

		router.ServeHTTP(w, req)

		if w.Code != http.StatusOK {
			t.Errorf("Response code should be %s, was: %s", http.StatusOK, w.Code)
		}

		var eventResponse bindings.PushEventResponse
		if err := json.NewDecoder(w.Body).Decode(&eventResponse); err != nil {
			t.Error("Response body could not be parsed !")
		}

		if eventResponse.Status == "" || eventResponse.Status == "Aborted" {
			t.Errorf("Response Status should be Processing and was %s !", eventResponse.Status)
		}

		if eventResponse.Message == "" {
			t.Error("Reponse Message should not be empty !")
		}
	}
}

repository: ChengTiesheng/unleash

repo_name: ChengTiesheng/unleash

extension: go


text:
package boltprojection

import (
	"context"
	"time"

	"github.com/dogmatiq/dogma"
	"github.com/dogmatiq/projectionkit/internal/identity"
	"github.com/dogmatiq/projectionkit/internal/unboundhandler"
	"github.com/dogmatiq/projectionkit/resource"
	"go.etcd.io/bbolt"
)

// adaptor adapts a boltprojection.ProjectionMessageHandler to the
// dogma.ProjectionMessageHandler interface.
type adaptor struct {
	db      *bbolt.DB
	handler MessageHandler
	repo    *ResourceRepository
}

// New returns a new Dogma projection message handler by binding a
// BoltDB-specific projection handler to a BoltDB database.
//
// If db is nil the returned handler will return an error whenever an operation
// that requires the database is performed.
func New(
	db *bbolt.DB,
	h MessageHandler,
) dogma.ProjectionMessageHandler {
	if db == nil {
		return unboundhandler.New(h)
	}

	return &adaptor{
		db:      db,
		handler: h,
		repo: NewResourceRepository(
			db,
			identity.Key(h),
		),
	}
}

// Configure produces a configuration for this handler by calling methods on
// the configurer c.
func (a *adaptor) Configure(c dogma.ProjectionConfigurer) {
	a.handler.Configure(c)
}

// HandleEvent updates the projection to reflect the occurrence of an event.
func (a *adaptor) HandleEvent(
	ctx context.Context,
	r, c, n []byte,
	s dogma.ProjectionEventScope,
	m dogma.Message,
) (bool, error) {
	return a.repo.UpdateResourceVersionFn(
		ctx,
		r, c, n,
		func(ctx context.Context, tx *bbolt.Tx) error {
			return a.handler.HandleEvent(ctx, tx, s, m)
		},
	)
}

// ResourceVersion returns the version of the resource r.
func (a *adaptor) ResourceVersion(ctx context.Context, r []byte) ([]byte, error) {
	return a.repo.ResourceVersion(ctx, r)
}

// CloseResource informs the projection that the resource r will not be
// used in any future calls to HandleEvent().
func (a *adaptor) CloseResource(ctx context.Context, r []byte) error {
	return a.repo.DeleteResource(ctx, r)
}

// TimeoutHint returns a duration that is suitable for computing a deadline
// for the handling of the given message by this handler.
func (a *adaptor) TimeoutHint(m dogma.Message) time.Duration {
	return a.handler.TimeoutHint(m)
}

// Compact reduces the size of the projection's data.
func (a *adaptor) Compact(ctx context.Context, s dogma.ProjectionCompactScope) error {
	return a.handler.Compact(ctx, a.db, s)
}

// ResourceRepository returns a repository that can be used to manipulate the
// handler's resource versions.
func (a *adaptor) ResourceRepository() resource.Repository {
	return a.repo
}

repository: dogmatiq/projectionkit

repo_name: dogmatiq/projectionkit

gha_language: Go


text:
package main

import (
	"log"
	"os"
	"time"

	"github.com/jamesrr39/goutil/userextra"
	"github.com/jamesrr39/taskrunner-app/taskrunner"
	"github.com/jamesrr39/taskrunner-app/taskrunner-gtk/gui"
	"github.com/jamesrr39/taskrunner-app/taskrunnerdal"
	"github.com/jamesrr39/taskrunner-app/triggers"

	"github.com/alecthomas/kingpin"
	"github.com/mattn/go-gtk/gdk"
	"github.com/mattn/go-gtk/glib"
	"github.com/mattn/go-gtk/gtk"
)

var (
	taskrunnerDAL          *taskrunnerdal.TaskrunnerDAL
	taskrunnerApplication  *kingpin.Application
	jobLogMaxLines         *uint
	applicationMode        ApplicationMode
	headlessJobNameArg     *string
	headlessTriggerNameArg *string
)

type ApplicationMode int

const (
	ApplicationModeGUI ApplicationMode = iota
	ApplicationModeRunJobHeadless
)

func main() {
	taskrunnerApplication = kingpin.New("Taskrunner GUI", "gtk gui for taskrunner")
	parseApplicationFlags()
	kingpin.MustParse(taskrunnerApplication.Parse(os.Args[1:]))

	switch applicationMode {
	case ApplicationModeGUI:
		guiMain()
	case ApplicationModeRunJobHeadless:
		runJobHeadlessMain(taskrunnerDAL, *headlessJobNameArg, *headlessTriggerNameArg)
	}
}

func runJobHeadlessMain(taskrunnerDAL *taskrunnerdal.TaskrunnerDAL, jobName string, trigger string) {
	job, err := taskrunnerDAL.GetJobByName(jobName)
	if nil != err {
		log.Fatalf("Error finding job with name: '%s'. Error: %s\n", jobName, err)
	}

	jobRun := job.NewJobRun(taskrunner.TriggerType(trigger))
	err = taskrunnerDAL.JobRunsDAL.CreateAndRun(jobRun, nil)
	if nil != err {
		log.Fatalf("Error running job with name: '%s' (id %d, run Id %d).\nError: %s\n", jobName, job.Id, jobRun.Id, err)
	}
}

func guiMain() {

	glib.ThreadInit(nil)
	gdk.ThreadsInit()
	gdk.ThreadsEnter()
	gtk.Init(nil)

	udevDAL := triggers.NewUdevRulesDAL("/etc/udev/rules.d")
	taskrunnerGUI := gui.NewTaskrunnerGUI(taskrunnerDAL, udevDAL, gui.TaskrunnerGUIOptions{*jobLogMaxLines, "/opt/taskrunner"}) // todo mock
	taskrunnerGUI.RenderScene(taskrunnerGUI.NewHomeScene())

	gtk.Main()
}

func parseApplicationFlags() {
	taskrunnerDir := taskrunnerApplication.
		Flag("taskrunner-dir", "Directory the taskruner uses to store job configs and logs of job runs.").
		Default("~/.local/share/github.com/jamesrr39/taskrunner-app").
		String()

	jobLogMaxLines = taskrunnerApplication.Flag("job-log-max-lines", "maximum number of lines to display in the job output. Lines after that are not shown in the UI, but the UI indicates where the whole log file is instead").
		Default("10000").
		Uint()

	headlessJobNameArg = taskrunnerApplication.Flag("run-job", "job name to be run headlessly").String()
	headlessTriggerNameArg = taskrunnerApplication.Flag("trigger", "name of trigger to be recorded in the job run").String()

	taskrunnerApplication.Action(func(context *kingpin.ParseContext) error {
		if "" == *headlessJobNameArg {
			applicationMode = ApplicationModeGUI
		} else {
			applicationMode = ApplicationModeRunJobHeadless
		}

		expandedDir, err := userextra.ExpandUser(*taskrunnerDir)
		if nil != err {
			return err
		}

		taskrunnerDAL, err = taskrunnerdal.NewTaskrunnerDALAndEnsureDirectories(expandedDir, providesNow)
		if nil != err {
			return err
		}

		return nil
	})
}

func providesNow() time.Time {
	return time.Now()
}


text:
package containerruntimeconfig

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestUnionGraph(t *testing.T) {
	for _, c := range []struct {
		name   string
		unions []string // Each string represents as a pair of unionNode values
		result []string // Each string represents a set of unionNode values
	}{
		{name: "Empty", unions: []string{}, result: []string{}},
		{
			name:   "No unions", // With no Union calls, still behaves correctly for individual nodes
			unions: []string{},
			result: []string{"A", "B", "C"},
		},
		{
			name:   "Self-unions",
			unions: []string{"AA", "BB", "CC"},
			result: []string{"A", "B", "C"},
		},
		{
			name:   "Connected: common first element",
			unions: []string{"AB", "AC", "AD", "AE", "ab", "ac", "ad", "ae"},
			result: []string{"ABCDE", "abcde"},
		},
		{
			name:   "Connected: common second element",
			unions: []string{"BA", "CA", "DA", "EA", "ba", "ca", "da", "ea"},
			result: []string{"ABCDE", "abcde"},
		},
		{
			name:   "Connected: path",
			unions: []string{"AB", "BC", "CD", "DE", "ab", "bc", "cd", "de"},
			result: []string{"ABCDE", "abcde"},
		},
	} {
		t.Run(c.name, func(t *testing.T) {
			// Verify various rotations of the input to test the behavior is order-independent
			for unionOffset := 0; unionOffset == 0 || unionOffset < len(c.unions); unionOffset++ {
				for resultOffset := 0; resultOffset < len(c.result); resultOffset++ {
					// We could use t.Run() for each offset pair pass, but that would pollute the output too much for developers that
					// want to inspect other tests.
					t.Logf("Pass %d,%d", unionOffset, resultOffset)
					g := newUnionGraph()
					for i := 0; i < len(c.unions); i++ {
						u := c.unions[(unionOffset+i)%len(c.unions)]
						if len(u) != 2 {
							panic("Invalid unions element")
						}
						g.Union(u[0:1], u[1:2])
					}
					for i := 0; i < len(c.result); i++ {
						res := c.result[(resultOffset+i)%len(c.result)]
						expected := g.Find(res[0:1])
						require.Contains(t, res, expected)
						for j := 1; j < len(res); j++ {
							v := g.Find(res[j : j+1])
							assert.Equal(t, expected, v)
						}
						// Check that the root originally returned for res[0:1] did not change by querying the members of the set
						v := g.Find(res[0:1])
						assert.Equal(t, expected, v)
					}
				}
			}
		})
	}
}

repository: yprokule/machine-config-operator

repo_name: yprokule/machine-config-operator


text:
SUMMARY = "PolyOS Updater"
SECTION = "base"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://${COREBASE}/LICENSE;md5=4d92cd373abda3937c2bc47fbc49d690"

PROVIDES += "polyos-updater"

SRC_URI = "file://polyos-updater"
S = "${WORKDIR}"

do_install () {

	install -d ${D}${sbindir}
	install -m 0755 ${WORKDIR}/polyos-updater ${D}${sbindir}/
}

FILES_${PN} += "${sbindir}/polyos-updater"
RDEPENDS_${PN} = "wget tar bzip2 util-linux"

gha_language: BitBake

extension: bb


text:
package utils

import (
	"fmt"
	"testing"
	"time"

	"github.com/lukaszbudnik/migrator/types"
	"github.com/stretchr/testify/assert"
)

func TestContainsFound(t *testing.T) {

	var slice = []string{"abc", "def", "ghi"}

	for _, s := range slice {
		found := Contains(slice, &s)
		assert.True(t, found, fmt.Sprintf("String %#v not found in slice %#v", s, slice))
	}
}

func TestContainsNotFound(t *testing.T) {

	var slice = []string{"abc", "def", "ghi"}
	var other = []string{"", "xyz"}

	for _, s := range other {
		found := Contains(slice, &s)
		assert.False(t, found, fmt.Sprintf("String %#v found in slice %#v", s, slice))
	}
}

func TestTenantArrayToString(t *testing.T) {
	dbTenants := []string{"abcabc", "dedededededededededede", "opopopop"}
	expected := `Name
abcabc
dedededededededededede
opopopop`

	actual := TenantArrayToString(dbTenants)

	assert.Equal(t, expected, actual)
}

func TestMigrationArrayToString(t *testing.T) {

	m1 := types.Migration{Name: "201602220000.sql", SourceDir: "source", File: "source/201602220000.sql", MigrationType: types.MigrationTypeSingleSchema, CheckSum: "abc...123..."}
	m2 := types.Migration{Name: "201602220001.sql", SourceDir: "tenants", File: "tenants/201602220001.sql", MigrationType: types.MigrationTypeTenantSchema, CheckSum: "abc...123..."}
	m3 := types.Migration{Name: "201602220002.sql", SourceDir: "tenants", File: "tenants/201602220002.sql", MigrationType: types.MigrationTypeTenantSchema, CheckSum: "abc...123..."}
	var ms = []types.Migration{m1, m2, m3}

	expected := `SourceDir  | Name              | File                      | Type  | CheckSum
source     | 201602220000.sql  | source/201602220000.sql   | 1     | abc...123...
tenants    | 201602220001.sql  | tenants/201602220001.sql  | 2     | abc...123...
tenants    | 201602220002.sql  | tenants/201602220002.sql  | 2     | abc...123...`
	actual := MigrationArrayToString(ms)

	assert.Equal(t, expected, actual)
}

func TestMigrationArrayToStringEmpty(t *testing.T) {

	var ms = []types.Migration{}

	expected := `SourceDir  | Name  | File  | Type  | CheckSum`
	actual := MigrationArrayToString(ms)

	assert.Equal(t, expected, actual)
}

func TestMigrationDBArrayToString(t *testing.T) {
	m1 := types.Migration{Name: "201602220000.sql", SourceDir: "source", File: "source/201602220000.sql", MigrationType: types.MigrationTypeSingleSchema, CheckSum: "abc"}
	m2 := types.Migration{Name: "201602220001.sql", SourceDir: "tenants", File: "tenants/201602220001.sql", MigrationType: types.MigrationTypeTenantSchema, CheckSum: "def"}
	d1 := time.Date(2016, 02, 22, 16, 41, 1, 123, time.UTC)
	d2 := time.Date(2016, 02, 22, 16, 41, 2, 456, time.UTC)
	var ms = []types.MigrationDB{{Migration: m1, Schema: "source", Created: d1}, {Migration: m2, Schema: "abc", Created: d2}, {Migration: m2, Schema: "def", Created: d2}}

	expected := `SourceDir  | Name              | File                      | Schema  | Created                                  | Type  | CheckSum
source     | 201602220000.sql  | source/201602220000.sql   | source  | 2016-02-22 16:41:01.000000123 +0000 UTC  | 1     | abc
tenants    | 201602220001.sql  | tenants/201602220001.sql  | abc     | 2016-02-22 16:41:02.000000456 +0000 UTC  | 2     | def
tenants    | 201602220001.sql  | tenants/201602220001.sql  | def     | 2016-02-22 16:41:02.000000456 +0000 UTC  | 2     | def`
	actual := MigrationDBArrayToString(ms)

	assert.Equal(t, expected, actual)
}

func TestMigrationDBArrayToStringEmpty(t *testing.T) {
	var ms = []types.MigrationDB{}

	expected := `SourceDir  | Name  | File  | Schema  | Created  | Type  | CheckSum`
	actual := MigrationDBArrayToString(ms)

	assert.Equal(t, expected, actual)
}

repository: strivesy/migrator

repo_name: strivesy/migrator


text:
package binp

// Parse 4 native endian bytes from the buffer.
func (p *Parser) N32(d *uint32) *Parser {
	if p == nil || len(p.r) < p.off+4 {
		return nil
	}
	*d = NativeEndian.Uint32(p.r[p.off:])
	p.off += 4
	return p
}

// Parse 8 native endian bytes from the buffer.
func (p *Parser) N64(d *uint64) *Parser {
	if p == nil || len(p.r) < p.off+8 {
		return nil
	}
	*d = NativeEndian.Uint64(p.r[p.off:])
	p.off += 8
	return p
}

// Parse 2 native endian bytes from the buffer.
func (p *Parser) N16(d *uint16) *Parser {
	if p == nil || len(p.r) < p.off+2 {
		return nil
	}
	*d = NativeEndian.Uint16(p.r[p.off:])
	p.off += 2
	return p
}

// Parse a string with a 4 byte native endian length prefix to a []byte pointer.
func (p *Parser) N32Bytes(d *[]byte) *Parser {
	var v uint32
	return p.N32(&v).NBytes(int(v), d)
}

// Parse n bytes from the buffer to a string pointer.
func (p *Parser) NString(n int, d *string) *Parser {
	if p == nil || n > len(p.r[p.off:]) {
		return nil
	}
	bs := p.r[p.off : p.off+n]
	*d = string(bs)
	p.off += n
	return p
}

// Parse a string with a 4 byte native endian length prefix to a string pointer.
func (p *Parser) N32String(d *string) *Parser {
	var v uint32
	return p.N32(&v).NString(int(v), d)
}

// Parse a string with a 2 byte native endian length prefix to a string pointer.
func (p *Parser) N16String(d *string) *Parser {
	var v uint16
	return p.N16(&v).NString(int(v), d)
}

// Parse a string with a 1 byte length prefix to a string pointer.
func (p *Parser) N8String(d *string) *Parser {
	var v uint8
	return p.Byte(&v).NString(int(v), d)
}

repository: taruti/binp

repo_name: taruti/binp


text:
SUMMARY = "NanoPC-T4 kernel"
DESCRIPTION = "FriendlyElec NanoPC-T4 machine kernel"

LIC_FILES_CHKSUM = "file://LICENSES/preferred/GPL-2.0;md5=e6a75371ba4d16749254a51215d13f97"

LINUX_VERSION = "5.2.0"

DEPENDS += "coreutils-native"

FILESEXTRAPATHS_prepend := "${THISDIR}/files/5.2.0:"

SRC_URI = " \
    git://git.kernel.org/pub/scm/linux/kernel/git/mmind/linux-rockchip.git;protocol=git;branch=master \
    file://defconfig \
    file://mali.cfg \
    file://0000-mali-TX011-SW-99002-r14p0-01rel0.patch \
    file://0001-Mali-midgard-r19p0-fixes-for-4.13-kernels.patch \
    file://0002-Using-the-new-header-on-4.12-kernels-for-copy_-_user.patch \
    file://0003-Adapt-get_user_pages-calls-to-use-the-new-calling-pr.patch \
    file://0004-Don-t-be-TOO-severe-when-looking-for-the-IRQ-names.patch \
    file://0005-Added-the-new-compatible-list-mainly-used-by-Rockchi.patch \
    file://0006-gpu-arm-Midgard-setup_timer-timer_setup.patch \
    file://0007-drivers-gpu-Arm-Midgard-Replace-ACCESS_ONCE-by-READ_.patch \
    file://0009-GPU-ARM-Midgard-Adapt-to-the-new-mmap-call-checks.patch \
    file://0010-GPU-Mali-Midgard-remove-rcu_read_lock-references.patch \
    file://0011-mali-kbase-v4.20-to-v5.0-rc2-changes.patch \
    file://1001-drivers-Integrating-Mali-Midgard-video-and-gpu-drive.patch \
    file://1004-Remove-the-dependency-to-the-clk_mali-symbol.patch \
    file://1007-mali-Allow-to-compile-the-mali-driver-out-of-the-ker.patch \
    file://1008-Revert-mm-Remove-return-value-of-zap_vma_ptes.patch \
    file://1009-Revert-arm64-remove-unused-asm-compiler.h-header-fil.patch \
    file://1010-Mali-midgard-r14p0-01rel0-fixes-for-5.2.0-kernel.patch \
"

SRCREV = "0ecfebd2b52404ae0c54a878c872bb93363ada36"

require recipes-kernel/linux/linux-yocto.inc

PV = "${LINUX_VERSION}+git${SRCPV}"

S = "${WORKDIR}/git"

KCONFIG_MODE="--alldefconfig"

COMPATIBLE_MACHINE = "(nanopc-t4)"

FILES_${KERNEL_PACKAGE_NAME}-base += "${nonarch_base_libdir}/modules/${KERNEL_VERSION}/modules.builtin.modinfo"


text:
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//go:build all || mysql || mysqlfirewallrule
// +build all mysql mysqlfirewallrule

package controllers

import (
	"context"
	"testing"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	azurev1alpha1 "github.com/Azure/azure-service-operator/api/v1alpha1"
	"github.com/Azure/azure-service-operator/pkg/errhelp"
)

func TestMySQLFirewallRuleControllerNoResourceGroup(t *testing.T) {
	t.Parallel()
	defer PanicRecover(t)
	ctx := context.Background()

	// Add any setup steps that needs to be executed before each test
	rgName := GenerateTestResourceNameWithRandom("mysqlsrv-rg", 10)
	server := GenerateTestResourceNameWithRandom("mysqlsrv", 10)
	ruleName := GenerateTestResourceNameWithRandom("mysql-fw", 10)

	// Create the mySQLDB object and expect the Reconcile to be created
	ruleInstance := &azurev1alpha1.MySQLFirewallRule{
		ObjectMeta: metav1.ObjectMeta{
			Name:      ruleName,
			Namespace: "default",
		},
		Spec: azurev1alpha1.MySQLFirewallRuleSpec{
			Server:         server,
			ResourceGroup:  rgName,
			StartIPAddress: "0.0.0.0",
			EndIPAddress:   "0.0.0.0",
		},
	}

	EnsureInstanceWithResult(ctx, t, tc, ruleInstance, errhelp.ResourceGroupNotFoundErrorCode, false)
	EnsureDelete(ctx, t, tc, ruleInstance)
}

func TestMySQLFirewallRuleControllerNoServer(t *testing.T) {
	t.Parallel()
	defer PanicRecover(t)
	ctx := context.Background()

	// Add any setup steps that needs to be executed before each test
	server := GenerateTestResourceNameWithRandom("mysqlsrv-rg", 10)
	rgName := tc.resourceGroupName
	ruleName := GenerateTestResourceNameWithRandom("mysql-fw", 10)

	// Create the mySQLDB object and expect the Reconcile to be created
	ruleInstance := &azurev1alpha1.MySQLFirewallRule{
		ObjectMeta: metav1.ObjectMeta{
			Name:      ruleName,
			Namespace: "default",
		},
		Spec: azurev1alpha1.MySQLFirewallRuleSpec{
			Server:         server,
			ResourceGroup:  rgName,
			StartIPAddress: "0.0.0.0",
			EndIPAddress:   "0.0.0.0",
		},
	}
	EnsureInstanceWithResult(ctx, t, tc, ruleInstance, errhelp.ResourceNotFound, false)
	EnsureDelete(ctx, t, tc, ruleInstance)
}

repository: Azure/azure-service-operator

repo_name: Azure/azure-service-operator


text:
// ------------------------------------------------------------
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//  Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------

#region Using Directives

#endregion

// ReSharper disable once CheckNamespace

namespace Microsoft.AzureCat.Samples.DeviceActorService.Interfaces
{
    using System.Threading.Tasks;
    using Microsoft.AzureCat.Samples.PayloadEntities;
    using Microsoft.ServiceFabric.Actors;

    public interface IDeviceActor : IActor
    {
        Task ProcessEventAsync(Payload payload);
        Task SetData(Device data);
        Task<Device> GetData();
    }
}

extension: cs


text:
package reconcile_test

import (
	"context"

	"github.com/golang/mock/gomock"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	v1alpha3sets "github.com/solo-io/external-apis/pkg/api/istio/networking.istio.io/v1alpha3/sets"
	smh_core_types "github.com/solo-io/service-mesh-hub/pkg/api/core.smh.solo.io/v1alpha1/types"
	smh_discovery "github.com/solo-io/service-mesh-hub/pkg/api/discovery.smh.solo.io/v1alpha1"
	v1alpha1sets2 "github.com/solo-io/service-mesh-hub/pkg/api/discovery.smh.solo.io/v1alpha1/sets"
	types2 "github.com/solo-io/service-mesh-hub/pkg/api/discovery.smh.solo.io/v1alpha1/types"
	"github.com/solo-io/service-mesh-hub/pkg/api/networking.smh.solo.io/v1alpha1"
	v1alpha1sets "github.com/solo-io/service-mesh-hub/pkg/api/networking.smh.solo.io/v1alpha1/sets"
	"github.com/solo-io/service-mesh-hub/pkg/api/networking.smh.solo.io/v1alpha1/types"
	"github.com/solo-io/service-mesh-hub/pkg/mesh-networking/failover"
	"github.com/solo-io/service-mesh-hub/pkg/mesh-networking/failover/reconcile"
	"github.com/solo-io/service-mesh-hub/pkg/mesh-networking/failover/translation"
	mock_failover_service_translation "github.com/solo-io/service-mesh-hub/pkg/mesh-networking/failover/translation/mocks"
	mock_failover_service_validation "github.com/solo-io/service-mesh-hub/pkg/mesh-networking/failover/validation/mocks"
	v12 "github.com/solo-io/skv2/pkg/api/core.skv2.solo.io/v1"
	"istio.io/client-go/pkg/apis/networking/v1alpha3"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

var _ = Describe("Processor", func() {
	var (
		ctrl           *gomock.Controller
		ctx            context.Context
		mockValidator  *mock_failover_service_validation.MockFailoverServiceValidator
		mockTranslator *mock_failover_service_translation.MockFailoverServiceTranslator
		processor      reconcile.FailoverServiceProcessor
	)

	BeforeEach(func() {
		ctrl = gomock.NewController(GinkgoT())
		ctx = context.TODO()
		mockValidator = mock_failover_service_validation.NewMockFailoverServiceValidator(ctrl)
		mockTranslator = mock_failover_service_translation.NewMockFailoverServiceTranslator(ctrl)
		processor = reconcile.NewFailoverServiceProcessor(
			mockValidator, []translation.FailoverServiceTranslator{
				mockTranslator,
			})
	})

	AfterEach(func() {
		ctrl.Finish()
	})

	var buildInputSnapshot = func() failover.InputSnapshot {
		return failover.InputSnapshot{
			FailoverServices: v1alpha1sets.NewFailoverServiceSet(
				// Should be skipped because ObservedGeneration != Generation.
				&v1alpha1.FailoverService{
					ObjectMeta: v1.ObjectMeta{
						Name:       "fs1",
						Generation: 2,
					},
					Status: types.FailoverServiceStatus{
						ObservedGeneration: 1,
					},
				},
				// Should be skipped because not validated.
				&v1alpha1.FailoverService{
					ObjectMeta: v1.ObjectMeta{
						Name: "fs2",
					},
					Status: types.FailoverServiceStatus{
						ValidationStatus: &smh_core_types.Status{
							State: smh_core_types.Status_INVALID,
						},
					},
				},
				&v1alpha1.FailoverService{
					ObjectMeta: v1.ObjectMeta{
						Name:       "fs3",
						Generation: 1,
					},
					Spec: types.FailoverServiceSpec{
						Hostname: "service1.namespace1.cluster1",
						Port: &types.FailoverServiceSpec_Port{
							Port:     9080,
							Protocol: "http",
						},
						Meshes: []*v12.ObjectRef{
							{
								Name:      "mesh1",
								Namespace: "namespace1",
							},
						},
						FailoverServices: []*v12.ClusterObjectRef{
							{
								Name:        "service2",
								Namespace:   "namespace2",
								ClusterName: "cluster2",
							},
						},
					},
					Status: types.FailoverServiceStatus{
						ObservedGeneration: 1,
						ValidationStatus: &smh_core_types.Status{
							State: smh_core_types.Status_ACCEPTED,
						},
					},
				},
			),
			MeshServices: v1alpha1sets2.NewMeshServiceSet(
				&smh_discovery.MeshService{
					ObjectMeta: v1.ObjectMeta{
						Name:        "service2",
						Namespace:   "namespace2",
						ClusterName: "cluster2",
					},
					Spec: types2.MeshServiceSpec{
						KubeService: &types2.MeshServiceSpec_KubeService{
							Ref: &smh_core_types.ResourceRef{
								Name:      "service2",
								Namespace: "namespace2",
								Cluster:   "cluster2",
							},
						},
					},
				},
			),
			Meshes: v1alpha1sets2.NewMeshSet(
				&smh_discovery.Mesh{
					ObjectMeta: v1.ObjectMeta{
						Name:      "mesh1",
						Namespace: "namespace1",
					},
					Spec: types2.MeshSpec{
						Cluster: &smh_core_types.ResourceRef{Name: "cluster1"},
					},
				},
			),
		}
	}

	It("should process input snapshot", func() {
		inputSnapshot := buildInputSnapshot()
		mockValidator.EXPECT().Validate(inputSnapshot)
		expectedServiceEntries := v1alpha3sets.NewServiceEntrySet(&v1alpha3.ServiceEntry{ObjectMeta: v1.ObjectMeta{Name: "se1"}})
		expectedEnvoyFilters := v1alpha3sets.NewEnvoyFilterSet(&v1alpha3.EnvoyFilter{ObjectMeta: v1.ObjectMeta{Name: "dr1"}})
		mockTranslator.
			EXPECT().
			Translate(ctx, inputSnapshot.FailoverServices.List()[2], inputSnapshot.MeshServices.List(), inputSnapshot.Meshes).
			Return(failover.MeshOutputs{
				ServiceEntries: expectedServiceEntries,
				EnvoyFilters:   expectedEnvoyFilters,
			}, nil)
		expectedOutputFailoverService := *inputSnapshot.FailoverServices.List()[2]
		expectedOutputFailoverService.Status.TranslationStatus = &smh_core_types.Status{
			State: smh_core_types.Status_ACCEPTED,
		}
		outputSnapshot := processor.Process(ctx, inputSnapshot)
		Expect(outputSnapshot.MeshOutputs.ServiceEntries.List()).To(Equal(expectedServiceEntries.List()))
		Expect(outputSnapshot.MeshOutputs.EnvoyFilters.List()).To(Equal(expectedEnvoyFilters.List()))
		Expect(outputSnapshot.FailoverServices.List()).To(Equal([]*v1alpha1.FailoverService{
			inputSnapshot.FailoverServices.List()[0],
			inputSnapshot.FailoverServices.List()[1],
			&expectedOutputFailoverService,
		}))
	})

	It("should process input snapshot with errors", func() {
		translatorError := &types.FailoverServiceStatus_TranslatorError{
			TranslatorId: "mock-translator",
			ErrorMessage: "test-error",
		}
		inputSnapshot := buildInputSnapshot()
		mockValidator.EXPECT().Validate(inputSnapshot)
		mockTranslator.
			EXPECT().
			Translate(ctx, inputSnapshot.FailoverServices.List()[2], inputSnapshot.MeshServices.List(), inputSnapshot.Meshes).
			Return(failover.MeshOutputs{}, translatorError)
		expectedOutputFailoverService := *inputSnapshot.FailoverServices.List()[2]
		expectedOutputFailoverService.Status.TranslationStatus = &smh_core_types.Status{
			State: smh_core_types.Status_PROCESSING_ERROR,
		}
		expectedOutputFailoverService.Status.TranslatorErrors = []*types.FailoverServiceStatus_TranslatorError{translatorError}
		outputSnapshot := processor.Process(ctx, inputSnapshot)
		Expect(outputSnapshot.MeshOutputs.ServiceEntries.List()).To(BeEmpty())
		Expect(outputSnapshot.MeshOutputs.EnvoyFilters.List()).To(BeEmpty())
		Expect(outputSnapshot.FailoverServices.List()).To(Equal([]*v1alpha1.FailoverService{
			inputSnapshot.FailoverServices.List()[0],
			inputSnapshot.FailoverServices.List()[1],
			&expectedOutputFailoverService,
		}))
	})
})

repository: abrahamja/gloo-mesh

repo_name: abrahamja/gloo-mesh


text:
#pragma once

#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkObjectFactory.h>
#include <vtkCoordinate.h>
#include <vtkRendererCollection.h>

// Define interaction style
class customMouseInteractorStyle : public vtkInteractorStyleTrackballCamera
{
  public:
    static customMouseInteractorStyle* New();
    vtkTypeMacro(customMouseInteractorStyle, vtkInteractorStyleTrackballCamera);

    virtual void OnLeftButtonDown();

    double select_3D[3];

};

repository: biocubed/daVinciToolTrack

repo_name: biocubed/daVinciToolTrack


text:
SUMMARY = "A Qt5 library to write cross-platform clients for Matrix"
HOMEPAGE = "https://matrix.org/docs/projects/sdk/quotient"
LICENSE = "LGPL-2.1"
LIC_FILES_CHKSUM = "file://COPYING;md5=243b725d71bb5df4a1e5920b344b86ad"

SRC_URI = "gitsm://github.com/quotient-im/libQuotient.git;branch=0.6.x;protocol=https"
SRCREV = "a4e78956f105875625b572d8b98459ffa86fafe5"
PV = "0.6.4"
S = "${WORKDIR}/git"

DEPENDS = " \
    qtbase \
    qtmultimedia \
"

inherit cmake_qt5_extra

FILES_${PN}-dev += "${datadir}/ndk-modules"

branch_name: refs/heads/nilrt/master/hardknott


text:
package main

import (
	"context"
	"fmt"

	"github.com/zhs007/jccclient"
	jarviscrawlercore "github.com/zhs007/jccclient/pb"
)

func main() {
	cfg, err := jccclient.LoadConfig("./config.yaml")
	if err != nil {
		fmt.Printf("LoadConfig %v", err)

		return
	}

	mgr, err := jccclient.NewClientMgr(cfg)
	if err != nil {
		fmt.Printf("NewClientMgr %v", err)

		return
	}

	mgr.AddTask(&jccclient.Tags{
		Tag: "localhost",
	},
		&jccclient.Task{
			Callback: func(ctx context.Context, task *jccclient.Task, err error, reply *jarviscrawlercore.ReplyCrawler) {
				if err != nil {
					fmt.Printf("callback %v", err)

					return
				}

				ap, isok := (reply.CrawlerResult).(*jarviscrawlercore.ReplyCrawler_Geoip)
				if !isok {
					fmt.Printf("callback %v", jccclient.ErrNoReplyAnalyzePage)

					return
				}

				fmt.Printf("callback %v", ap.Geoip)
			},
			RetryNums: 3,
			GeoIP: &jccclient.TaskGeoIP{
				IP: "47.90.46.159",
			},
		})

	mgr.AddTask(&jccclient.Tags{
		Tag: "localhost",
	},
		&jccclient.Task{
			Callback: func(ctx context.Context, task *jccclient.Task, err error, reply *jarviscrawlercore.ReplyCrawler) {
				if err != nil {
					fmt.Printf("callback %v", err)

					return
				}

				ap, isok := (reply.CrawlerResult).(*jarviscrawlercore.ReplyCrawler_Geoip)
				if !isok {
					fmt.Printf("callback %v", jccclient.ErrNoReplyAnalyzePage)

					return
				}

				fmt.Printf("callback %v", ap.Geoip)
			},
			RetryNums: 3,
			GeoIP: &jccclient.TaskGeoIP{
				IP: "47.90.46.158",
			},
		})

	mgr.StartAllTasks(context.Background())

	// lst := []string{"47.90.46.159", "47.90.46.158"}

	// endchan := make(chan int)
	// tasknums := 0

	// for _, v := range lst {
	// 	cc := mgr.GetClient("localhost", "www.ipvoid.com")
	// 	if cc == nil {
	// 		fmt.Printf("GetClient %v", "localhost")

	// 		return
	// 	}

	// 	go func(client *jccclient.Client, ipaddr string) {
	// 		reply, err := client.GetGeoIP(context.Background(),
	// 			ipaddr,
	// 			"ipvoid")

	// 		if err != nil {
	// 			fmt.Printf("GetGeoIP %v", err)

	// 			// return
	// 		}

	// 		if reply != nil {
	// 			fmt.Printf("%v", reply)
	// 		}

	// 		endchan <- 1
	// 	}(cc, v)
	// }

	// for {
	// 	<-endchan
	// 	tasknums++
	// 	if tasknums == len(lst) {
	// 		break
	// 	}
	// }

	return
}


text:
if (TARGET Editor AND TARGET EditorPluginFileserve)

    # Make sure this project is built when the Editor is built
    add_dependencies(Editor EditorPluginFileserve)

endif()

repository: ezEngine/ezEngine

repo_name: ezEngine/ezEngine

branch_name: refs/heads/dev

extension: cmake