Patent Publication Number: US-9892015-B2

Title: Integration and automation of build and test in a customized computing system

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
     The present application is based on and claims the benefit of U.S. provisional patent application Ser. No. 62/133,765, filed Mar. 16, 2015, the content of which is hereby incorporated by reference in its entirety. 
    
    
     BACKGROUND 
     Computing systems are currently in wide use. Many different types of computing systems may be deployed at a given organization, in order to perform processes, workflows, and tasks at the organization. 
     Such computing systems are often enterprise computing systems that are originally manufactured by a computing system manufacturer. They can be customized, and sometimes heavily customized, prior to being deployed at the end user organization. 
     During the process of customizing a base computing system to meet the needs of an end user organization, developers often perform incremental customizations, and then build and test the system to determine whether those customizations work properly. In order to build and test customizations on code, developers currently perform complex, and therefore time consuming and error prone, procedures to set up build and test environments. Test code is often separately, and manually, generated, and is not integrated into the build systems. 
     In addition, it is also quite common for a first developer team to generate the customizations or other developments with respect to the base computing system, and for another team to generate and conduct the test and validation of those customizations. This adds to the complex nature of such systems. 
     The discussion above is merely provided for general background information and is not intended to be used as an aid in determining the scope of the claimed subject matter. 
     SUMMARY 
     A user interaction is detected which indicates that the user wishes to build and test a customized computing system. A build system is automatically generated to build models in the customized system. Test code is automatically generated and included as part of source code for the build. When a build is triggered, the build is generated and automatically tested. Build and test execution results are surfaced for user visualization. 
     This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter. The claimed subject matter is not limited to implementations that solve any or all disadvantages noted in the background. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a block diagram of one example of an automatic build and test architecture. 
         FIG. 2  is a block diagram showing a build computing system and a test computing system in more detail. 
         FIGS. 3A and 3B  (collectively referred to herein as  FIG. 3 ) illustrate a flow diagram that shows one example of the operation of the architecture shown in  FIG. 1  in building and testing a customized computing system. 
         FIG. 4  is a block diagram of one example of the architecture shown in  FIG. 1 , deployed in a cloud computing architecture. 
         FIGS. 5-7  show examples of mobile devices that can be used in the architectures shown in the previous figures. 
         FIG. 8  is a block diagram showing one example of a computing environment that can be used in the architectures shown in the previous figures. 
     
    
    
     DETAILED DESCRIPTION 
       FIG. 1  is a block diagram of one example of an automated build and test architecture  100 . Architecture  100  illustratively includes development system  102 , build and test automation system  104 , source management system  106 , task recorder  108 , and lifecycle management system  110 . In the example shown in  FIG. 1 , any of systems  102 ,  104  and  110  (and possibly others) illustratively generate user interface displays  112  with user input mechanisms  114 . Developer  116  illustratively interacts with user input mechanisms  114  in order to control and manipulate any or all of the systems shown. 
     In one example, developer  116  interacts with user input mechanisms  114  to control and manipulate development system  102  in order to customize a base computer system to obtain a customized system  118 . The customized system  118  is illustratively provided to build and test automation system  104  where a build can automatically be generated, and where tests can automatically be run on that build. The results can then illustratively be surfaced for visualization by developer  116 . 
       FIG. 1  also shows that, in one example, when system  104  builds customized system  118 , the build can be deployed in a test (or other) environment with source versioning that is provided by source management system  106 . This is indicated generally by  120 . A testing user  122  illustratively provides test inputs  124  to generate tests on the build that is deployed in the test environment  120 . Task recorder  108  illustratively records the test inputs, and code can automatically be generated to encode the test inputs so that they can automatically be run against later builds, in the test environment. 
     Before describing the overall operation of architecture  100 , a number of the items in each of the systems in architecture  100  will first be described. Lifecycle management system  110  illustratively includes a set of servers or processors  126 , as well as base system  128 , customizations  130 , and it can include other items  132 . Developer  116  illustratively logs into (or otherwise accesses) system  110  to have access to base system  128  and his or her customizations  130 . 
     Development system  102  illustratively includes a set of development tools and functionality  134 , one or more processors or servers  136 , user interface component  138 , and it can include other items  140 . Development tools and functionality  104  illustratively generate user input mechanisms that allow user  116  to perform development functions or customizations with respect to a base system  128 , to generate a set of customizations  130  that are applied to the base system  128  in order to obtain customized system  118 . 
     Build and test automation system  104  illustratively includes one or more processors or servers  142 , build and test control system  144 , test computing system  146 , build computing system  148 , user interface component  150 , result visualization component  152 , and it can include other items  154 . Result visualization system  152  can illustratively include build result component  156 , test result component  158 , and other items  160 . Build and test control system  144  illustratively receives the customized system  118  and one or more inputs from developer  116  indicating that the developer wishes to build and test customized system  118 . Build and test control system  144  then controls build computing system  148  to generate a build for customized system  118 . It also controls test computing system  146  to generate automated tests for that build. Result visualization system  152  illustratively generates a visualization of the build results and test results, that can be surfaced as user interface displays  112  (or otherwise) for developer  116 . System  104  illustratively has access to source management system  106  which, itself, includes version control system  162 , source repository  164 , and it can include other items  166 . It automatically performs version control and source control on the customized system  118 , for build and test automation system  104 . 
       FIG. 2  is a block diagram showing one example of build computing system  148  and test computing system  146  in more detail. In the example shown in  FIG. 2 , build computing system  148  illustratively includes a template virtual hard disk (template VHD)  170  that includes a set of build components that can be used and easily configured to automatically generate a build. Thus, it illustratively includes build agent component  172 , controller component  174 , build script  176 , virtual machine (VM) setup component  178 , and it can include other items  180 . Build computing system  148  also illustratively includes compiler component  182 , best practice checker component  184 , form adapter generator  186 , build package generator  188 , source control connection component  190 , build execution configuration system  192 , and it can include a variety of other build functionality  194 . Build execution configuration system  192  illustratively includes a build definition component  196 , build controller setup component  198 , build agent setup component  200 , build scheduling component  202 , and it can include other items  204 . 
     Test computing system  146  illustratively includes test discovery component  206 , test configuration component  208 , test execution component  210 , result feedback component  212 , test code generator component  214 , one or more task recorder test cases  216 , and it can include other test functionality  218 . Before describing the operation of systems  146  and  148  in more detail, a brief description of some of the components will first be described. 
     Template VHD  170  illustratively includes the set of basic build components  172 - 178  for creating and managing a build machine. These components are illustratively configured through the corresponding components in configuration system  192 . Build agent component  172  can illustratively generate build agents, while build controller component  174  illustratively generates a build controller. Build script  176  illustratively includes a set of scripted tasks that can be interpreted and executed by the build agents generated using build agent component  172  to generate the build. 
     Build definition component  196  illustratively generates user interface displays with user input mechanisms that allow the developer to configure a particular build. Build controller setup component  198  illustratively generates displays with user input mechanisms that allow the developer to configure the build controller component  174 , and build agent setup component  200  illustratively does the same to allow the developer to configure the build agents  172 . Once generated, the build controller controls the build agents to interpret and execute the tasks represented by build script  176 . 
     Virtual machine setup component  178  illustratively provisions and sets up virtual machines either on-premise or in a remote (e.g., cloud) environment for use as a build machine. Once the virtual machine is set up, source control connection component  190  illustratively connects it to source management system  106 , and build scheduling component  202  illustratively schedules periodic (or intermittent) builds. For instance, it can schedule daily build and test execution, or execution on a different interval. 
     Compiler component  182  illustratively and automatically compiles the code for the build and best practice checker  184  checks it against a set of best practices that can be stored locally or retrieved remotely, etc. Build package generator  188  illustratively generates a build package. 
     Test configuration component  208  illustratively generates user interface displays with user input mechanisms that allow the developer to configure various tests or test components. Test code generator component  214  illustratively receives a task recorder input from task recorder  108  (shown in  FIG. 1 ) that records the test inputs provided by testing user  122 . These may be a set of actions against user interface displays, or other inputs in which testing user  122  is testing the build in test environment  120 . Test code generator component  214  automatically generates test code that will repeat those testing inputs against this build or a subsequent build. In doing so, it stores the code as task recorder test cases  216 . Test discovery component  206  discovers those test cases and can provide them, as well as any other test cases integrated into the source code, to test execution component  210  that runs the tests. Result feedback component  212  illustratively generates a test result visualization that can be surfaced using result visualization system  152  (shown in in  FIG. 1 ) for developer  116 . 
       FIGS. 3A and 3B  (collectively referred to herein as  FIG. 3 ) show a flow diagram illustrating one example of the operation of architecture  100  in automatically generating a build and testing that build.  FIGS. 1-3  will now be described in conjunction with one another. 
     In one example, build and test control system  144  in  FIG. 1  detects a developer input from developer  116  indicating that the developer wishes to download a set of pre-configured build and test components. This is indicated by block  250  in  FIG. 3 . It then illustratively downloads (such as from lifecycle management system  110  or another source) the template virtual hard disk  170  that includes the pre-configured components  172 - 178 . Downloading the pre-configured build and test components is indicated by block  252 . Components  172 - 178  then automatically setup a development environment. This is indicated by block  254 . For instance, component  178  illustratively provisions and configures virtual machines. This is indicated by blocks  256  and  258 , respectively. The development environment can be set up in other ways as well, as indicated by block  260 . 
     The developer  114  can then provide inputs to migrate the system to be customized (e.g., the base system  128 ) into the development environment that has just been set up. This is indicated by block  262 . The developer can then configure version control as indicated by block  264 . This can be done by identifying a server where version control is to be performed, as indicated by block  266 . Source control connection component  190  then connects the development environment that has just been setup to the identified server. This is indicated by block  268 . Configuring version controls can be performed in other ways as well, as indicated by block  270 . 
     Developer  116  then accesses the pre-configured build components  172 - 178  to setup a build environment, or build machine. This is indicated by block  272  in  FIG. 3 . For instance, VM setup component  178  provisions a virtual machine and configures the virtual machine as a build machine. This is indicated by blocks  274  and  276 , respectively. Developer  116  can also access build agent component  172  and build controller component  174  to generate the controllers and agents used in the build machine. Accessing other build components is indicated by block  278 . 
     Developer  116  then uses source control connection component  190  to connect the build virtual machine to the source management system  106 . This is indicated by block  280 . Developer  116  can also use build scheduling component  202  to schedule the build execution frequency. This is indicated by block  282 . Other operations can be formed as indicated by block  284 . 
     Build execution and configuration system  192  then automatically sets up the build controllers. By automatically it is meant that this is done without substantially any other input by the user, except perhaps to initiate the process. It can automatically obtain pre-configured build script  176 . It can generate the build controller and the build agents. Automatically setting up the build components is indicated by block  286 . Obtaining the pre-configured build script is indicated by block  288 , and setting up the build controller and build agents is indicated by blocks  290  and  292 , respectively. It can perform other operations in setting up the build component as well, and this is indicated by block  294 . The configuration system  192  illustratively provides a set of configuration tools that can be used to set up a build definition, the build controller and build agents. Developer  116  can also illustratively use test configuration component  208  to integrate any already-coded tests, into the source code for the build. This is indicated by block  296 . 
     At some point, developer  116  uses development system  102  to provide customizations or development inputs to generate customized system  188 . This is indicated by block  298 . Also, at some point (and illustratively based upon the build frequency that developer  116  provided to build scheduling component  202 ) a build will be triggered. In one example, builds are triggered at the end of each day, although they can be triggered in other ways as well, such as when changes are saved, etc. Determining that a build has been triggered is indicated by block  300 . 
     In response, build computing system  148  automatically generates a build based on the customized system  118 . This is indicated by block  302 . A build visualization is illustratively generated by build result component  156  in result visualization system  152 . It can be surfaced for developer  116  by system  152  as well. Generating the build visualization is indicated by block  304 . 
     Test execution component  210  also illustratively and automatically performs tests that are generated by test code generator component  214 . Performing tests is indicated by block  306 . Performing them automatically is indicated by block  308 . 
     It may also be that a testing user  122  provides additional test inputs  124  to conduct additional tests on the build. If so, task recorder  108  illustratively records the test inputs. Test code generator component  214  illustratively, automatically generates code from the recorded test inputs so that those tests can also be run against this or subsequent builds automatically. Providing manual tests and recording them with task recorder  108  is indicated by block  310 . Performing tests can include other items as well, and this is indicated by block  312 . 
     Test result component  158  then illustratively generates a test result visualization. This is indicated by block  314 . The test result visualization can also be surfaced by visualization system  152  for developer  116 . 
     After the build and testing is completed, if testing user  122  has provided additional manual test inputs  124 , then code generator  214  illustratively generates test code from the task recording made for those inputs. This is indicated by block  316 . The new test code is then fed back to source management system  106 , where it is integrated into the source repository  164  for the customized system  118 . Feeding the test code back for later automation, and integrating it into the source is indicated by blocks  318  and  320 , respectively. 
     If the build and test execution have not been successful, as indicated by block  322 , then processing illustratively reverts back to block  298  where developer  116  can provide additional development inputs or customizations in order to remedy the errors in generating the build and executing tests. However, if, at block  322 , it is determined that the build and test execution were performed successfully, then this is indicated to source management system  106 . Version control system  162  performs versioning for the build and source code. This is indicated by block  324 . The specific version can then be promoted for staging or pre-production, or for further validation. This is indicated by block  326 . 
     It can thus be seen that the present system provides a number of significant advantages. It provides a mechanism to build customized models (e.g., models developed by an independent software vendor) but does not require detailed knowledge of setting up a build system. It also advantageously provides robust build automation for building the customized models, and the build automation system can be plugged with various standard build scripts or other build mechanisms to perform builds in various ways. It also advantageously simplifies the configuration of unattended test execution for any changes or customizations made to the code. 
     In addition, a build can automatically be generated without access to a development environment. Instead, the task-based command script (or build script  172 ) can be used to trigger a build on any machine with the prerequisite build components  172 - 178  installed. Further, a developer can advantageously obtain a pre-created template with a build agent, a build controller, and build script  176  already pre-configured and set up. This can be used in an on-premise system or a cloud deployment. Automated test generation can be used to generate test cases against intermittent builds (such as nightly builds) and manual tests can be integrated (using the task recorder and generating test code from the recording, as test cases) into the source. Thus, those test cases can later be executed automatically, once a build is performed successfully. The developer can also easily obtain configuration tools to connect the build machine to the source management system for versioning and source repository management. The build automatically compiles models, checks the compiled system against best practices, builds various reporting definition files, compiles labels, generates form adapters, performs a nightly build and generates a build package, all with very little developer interaction. 
     The present discussion has mentioned processors and servers. In one embodiment, the processors and servers include computer processors with associated memory and timing circuitry, not separately shown. They are functional parts of the systems or devices to which they belong and are activated by, and facilitate the functionality of the other components or items in those systems. 
     Also, a number of user interface displays have been discussed. They can take a wide variety of different forms and can have a wide variety of different user actuatable input mechanisms disposed thereon. For instance, the user actuatable input mechanisms can be text boxes, check boxes, icons, links, drop-down menus, search boxes, etc. They can also be actuated in a wide variety of different ways. For instance, they can be actuated using a point and click device (such as a track ball or mouse). They can be actuated using hardware buttons, switches, a joystick or keyboard, thumb switches or thumb pads, etc. They can also be actuated using a virtual keyboard or other virtual actuators. In addition, where the screen on which they are displayed is a touch sensitive screen, they can be actuated using touch gestures. Also, where the device that displays them has speech recognition components, they can be actuated using speech commands. 
     A number of data stores have also been discussed. It will be noted they can each be broken into multiple data stores. All can be local to the systems accessing them, all can be remote, or some can be local while others are remote. All of these configurations are contemplated herein. 
     Also, the figures show a number of blocks with functionality ascribed to each block. It will be noted that fewer blocks can be used so the functionality is performed by fewer components. Also, more blocks can be used with the functionality distributed among more components. 
       FIG. 4  is a block diagram of architecture  100 , shown in  FIG. 1 , except that its elements are disposed in a cloud computing architecture  500 . Cloud computing provides computation, software, data access, and storage services that do not require end-user knowledge of the physical location or configuration of the system that delivers the services. In various embodiments, cloud computing delivers the services over a wide area network, such as the internet, using appropriate protocols. For instance, cloud computing providers deliver applications over a wide area network and they can be accessed through a web browser or any other computing component. Software or components of architecture  100  as well as the corresponding data, can be stored on servers at a remote location. The computing resources in a cloud computing environment can be consolidated at a remote data center location or they can be dispersed. Cloud computing infrastructures can deliver services through shared data centers, even though they appear as a single point of access for the user. Thus, the components and functions described herein can be provided from a service provider at a remote location using a cloud computing architecture. Alternatively, they can be provided from a conventional server, or they can be installed on client devices directly, or in other ways. 
     The description is intended to include both public cloud computing and private cloud computing. Cloud computing (both public and private) provides substantially seamless pooling of resources, as well as a reduced need to manage and configure underlying hardware infrastructure. 
     A public cloud is managed by a vendor and typically supports multiple consumers using the same infrastructure. Also, a public cloud, as opposed to a private cloud, can free up the end users from managing the hardware. A private cloud may be managed by the organization itself and the infrastructure is typically not shared with other organizations. The organization still maintains the hardware to some extent, such as installations and repairs, etc. 
     In the example shown in  FIG. 4 , some items are similar to those shown in  FIG. 1  and they are similarly numbered.  FIG. 4  specifically shows that systems  102 ,  104 ,  106  and  110  can be is located in cloud  502  (which can be public, private, or a combination where portions are public while others are private). Therefore, user  112  uses a user device  504  and testing user  122  uses a testing user device  506  to access those systems through cloud  502 . 
       FIG. 4  also depicts another example of a cloud architecture.  FIG. 4  shows that it is also contemplated that some elements of architecture  100  can be disposed in cloud  502  while others are not. By way of example, various data stores  508  that are used in architecture  100  can be disposed outside of cloud  502 , and accessed through cloud  502 . In another example, development system  102 , or other systems or components can be outside of cloud  502 . Regardless of where they are located, they can be accessed directly by device  504 , through a network (either a wide area network or a local area network), they can be hosted at a remote site by a service, or they can be provided as a service through a cloud or accessed by a connection service that resides in the cloud. All of these architectures are contemplated herein. 
     It will also be noted that architecture  100 , or portions of it, can be disposed on a wide variety of different devices. Some of those devices include servers, desktop computers, laptop computers, tablet computers, or other mobile devices, such as palm top computers, cell phones, smart phones, multimedia players, personal digital assistants, etc. 
       FIG. 5  is a simplified block diagram of one illustrative example of a handheld or mobile computing device that can be used as a user&#39;s or client&#39;s hand held device  16 , in which the present system (or parts of it) can be deployed.  FIGS. 6-7  are examples of handheld or mobile devices. 
       FIG. 5  provides a general block diagram of the components of a client device  16  that can run components of architecture  100  or that interacts with architecture  100 , or both. In the device  16 , a communications link  13  is provided that allows the handheld device to communicate with other computing devices and under some embodiments provides a channel for receiving information automatically, such as by scanning. Examples of communications link  13  include an infrared port, a serial/USB port, a cable network port such as an Ethernet port, and a wireless network port allowing communication though one or more communication protocols including General Packet Radio Service (GPRS), LTE, HSPA, HSPA+ and other 3G and 4G radio protocols, 1Xrtt, and Short Message Service, which are wireless services used to provide cellular access to a network, as well as Wi-Fi protocols, and Bluetooth protocol, which provide local wireless connections to networks. 
     Under other embodiments, applications or systems are received on a removable Secure Digital (SD) card that is connected to a SD card interface  15 . SD card interface  15  and communication links  13  communicate with a processor  17  (which can also embody processors  126 ,  136  or  142  from  FIG. 1  or those in other devices) along a bus  19  that is also connected to memory  21  and input/output (I/O) components  23 , as well as clock  25  and location system  27 . 
     I/O components  23 , in one embodiment, are provided to facilitate input and output operations. I/O components  23  for various embodiments of the device  16  can include input components such as buttons, touch sensors, multi-touch sensors, optical or video sensors, voice sensors, touch screens, proximity sensors, microphones, tilt sensors, and gravity switches and output components such as a display device, a speaker, and or a printer port. Other I/O components  23  can be used as well. 
     Clock  25  illustratively comprises a real time clock component that outputs a time and date. It can also, illustratively, provide timing functions for processor  17 . 
     Location system  27  illustratively includes a component that outputs a current geographical location of device  16 . This can include, for instance, a global positioning system (GPS) receiver, a LORAN system, a dead reckoning system, a cellular triangulation system, or other positioning system. It can also include, for example, mapping software or navigation software that generates desired maps, navigation routes and other geographic functions. 
     Memory  21  stores operating system  29 , network settings  31 , applications  33 , application configuration settings  35 , data store  37 , communication drivers  39 , and communication configuration settings  41 . Memory  21  can include all types of tangible volatile and non-volatile computer-readable memory devices. It can also include computer storage media (described below). Memory  21  stores computer readable instructions that, when executed by processor  17 , cause the processor to perform computer-implemented steps or functions according to the instructions. Similarly, device  16  can have a client system  24  which can run various applications or embody parts or all of architecture  100 . Processor  17  can be activated by other components to facilitate their functionality as well. 
     Examples of the network settings  31  include things such as proxy information, Internet connection information, and mappings. Application configuration settings  35  include settings that tailor the application for a specific enterprise or user. Communication configuration settings  41  provide parameters for communicating with other computers and include items such as GPRS parameters, SMS parameters, connection user names and passwords. 
     Applications  33  can be applications that have previously been stored on the device  16  or applications that are installed during use, although these can be part of operating system  29 , or hosted external to device  16 , as well. 
       FIG. 6  shows one embodiment in which device  16  is a tablet computer  600 . In  FIG. 6 , computer  600  is shown with user interface display screen  602 . Screen  602  can be a touch screen (so touch gestures from a user&#39;s finger can be used to interact with the application) or a pen-enabled interface that receives inputs from a pen or stylus. It can also use an on-screen virtual keyboard. Of course, it might also be attached to a keyboard or other user input device through a suitable attachment mechanism, such as a wireless link or USB port, for instance. Computer  600  can also illustratively receive voice inputs as well. 
     Additional examples of devices  16  can be used as well. The device can be a feature phone, smart phone or mobile phone. The phone can include a set of keypads for dialing phone numbers, a display capable of displaying images including application images, icons, web pages, photographs, and video, and control buttons for selecting items shown on the display. The phone can include an antenna for receiving cellular phone signals such as General Packet Radio Service (GPRS) and 1Xrtt, and Short Message Service (SMS) signals. In some examples, the phone can also include a Secure Digital (SD) card slot that accepts a SD card. 
     The mobile device can also be a personal digital assistant or a multimedia player or a tablet computing device, etc. (hereinafter referred to as a PDA). The PDA can include an inductive screen that senses the position of a stylus (or other pointers, such as a user&#39;s finger) when the stylus is positioned over the screen. This allows the user to select, highlight, and move items on the screen as well as draw and write. The PDA can also include a number of user input keys or buttons which allow the user to scroll through menu options or other display options which are displayed on the display, and allow the user to change applications or select user input functions, without contacting the display. The PDA can include an internal antenna and an infrared transmitter/receiver that allow for wireless communication with other computers as well as connection ports that allow for hardware connections to other computing devices. Such hardware connections are typically made through a cradle that connects to the other computer through a serial or USB port. As such, these connections are non-network connections. 
       FIG. 7  shows that the phone is a smart phone  71 . Smart phone  71  has a touch sensitive display  73  that displays icons or tiles or other user input mechanisms  75 . Mechanisms  75  can be used by a user to run applications, make calls, perform data transfer operations, etc. In general, smart phone  71  is built on a mobile operating system and offers more advanced computing capability and connectivity than a feature phone. 
     Note that other forms of the devices  16  are possible. 
       FIG. 8  is one embodiment of a computing environment in which architecture  100 , or parts of it, (for example) can be deployed. With reference to  FIG. 8 , an exemplary system for implementing some embodiments includes a general-purpose computing device in the form of a computer  810 . Components of computer  810  may include, but are not limited to, a processing unit  820  (which can comprise processor  126 ,  136  or  142 , or other processors in other devices or systems shown above), a system memory  830 , and a system bus  821  that couples various system components including the system memory to the processing unit  820 . The system bus  821  may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus. Memory and programs described with respect to  FIG. 1  can be deployed in corresponding portions of  FIG. 8 . 
     Computer  810  typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer  810  and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media is different from, and does not include, a modulated data signal or carrier wave. It includes hardware storage media including both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computer  810 . Communication media typically embodies computer readable instructions, data structures, program modules or other data in a transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media. 
     The system memory  830  includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM)  831  and random access memory (RAM)  832 . A basic input/output system  833  (BIOS), containing the basic routines that help to transfer information between elements within computer  810 , such as during start-up, is typically stored in ROM  831 . RAM  832  typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit  820 . By way of example, and not limitation,  FIG. 8  illustrates operating system  834 , application programs  835 , other program modules  836 , and program data  837 . 
     The computer  810  may also include other removable/non-removable volatile/nonvolatile computer storage media. By way of example only,  FIG. 8  illustrates a hard disk drive  841  that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive  851  that reads from or writes to a removable, nonvolatile magnetic disk  852 , and an optical disk drive  855  that reads from or writes to a removable, nonvolatile optical disk  856  such as a CD ROM or other optical media. Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive  841  is typically connected to the system bus  821  through a non-removable memory interface such as interface  840 , and magnetic disk drive  851  and optical disk drive  855  are typically connected to the system bus  821  by a removable memory interface, such as interface  850 . 
     Alternatively, or in addition, the functionality described herein can be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that can be used include Field-programmable Gate Arrays (FPGAs), Program-specific Integrated Circuits (ASICs), Program-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc. 
     The drives and their associated computer storage media discussed above and illustrated in  FIG. 8 , provide storage of computer readable instructions, data structures, program modules and other data for the computer  810 . In  FIG. 8 , for example, hard disk drive  841  is illustrated as storing operating system  844 , application programs  845 , other program modules  846 , and program data  847 . Note that these components can either be the same as or different from operating system  834 , application programs  835 , other program modules  836 , and program data  837 . Operating system  844 , application programs  845 , other program modules  846 , and program data  847  are given different numbers here to illustrate that, at a minimum, they are different copies. 
     A user may enter commands and information into the computer  810  through input devices such as a keyboard  862 , a microphone  863 , and a pointing device  861 , such as a mouse, trackball or touch pad. Other input devices (not shown) may include a joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit  820  through a user input interface  860  that is coupled to the system bus, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB). A visual display  891  or other type of display device is also connected to the system bus  821  via an interface, such as a video interface  890 . In addition to the monitor, computers may also include other peripheral output devices such as speakers  897  and printer  896 , which may be connected through an output peripheral interface  895 . 
     The computer  810  is operated in a networked environment using logical connections to one or more remote computers, such as a remote computer  880 . The remote computer  880  may be a personal computer, a hand-held device, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer  810 . The logical connections depicted in  FIG. 8  include a local area network (LAN)  871  and a wide area network (WAN)  873 , but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet. 
     When used in a LAN networking environment, the computer  810  is connected to the LAN  871  through a network interface or adapter  870 . When used in a WAN networking environment, the computer  810  typically includes a modem  872  or other means for establishing communications over the WAN  873 , such as the Internet. The modem  872 , which may be internal or external, may be connected to the system bus  821  via the user input interface  860 , or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer  810 , or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,  FIG. 8  illustrates remote application programs  885  as residing on remote computer  880 . It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used. 
     It should also be noted that the different embodiments described herein can be combined in different ways. That is, parts of one or more embodiments can be combined with parts of one or more other embodiments. All of this is contemplated herein. 
     Example 1 is a computing system, comprising: 
     a user interface component that detects a developer input to download, to a development system, a pre-configured set of build components; 
     a build and test automation system that automatically downloads the set of pre-configured build components to the development system in response to the detected developer input, automatically sets up a development environment in the development system, and automatically migrates a computing system to be customized to the development environment; and 
     a build and test control system that automatically accesses the set of pre-configured build components to set up a build environment on the development system. 
     Example 2 is the computing system of any or all previous examples wherein the build and test automation system provisions a set of development environment virtual machines in the development environment, and configures the set of development environment virtual machines as development environment machines. 
     Example 3 is the computing system of any or all previous examples wherein the user interface component detects the developer input as a developer input to download a set of pre-configured test components. 
     Example 4 is the computing system of any or all previous examples wherein the build and test automation system comprises: a test computing system that automatically downloads a set of pre-configured test components. 
     Example 5 is the computing system of any or all previous examples wherein the build test and automation system comprises: 
     a build execution and configuration system that automatically sets up the build environment. 
     Example 6 is the computing system of any or all previous examples wherein the build execution and configuration system automatically provisions build environment virtual machines and configures the virtual machines as build environment virtual machines. 
     Example 7 is the computing system of any or all previous examples wherein the build execution and configuration system comprises: 
     a build definition component that pre-configures a build script; 
     a build controller set-up component that generates a build controller; and 
     a build agent set-up component that generates a set of build agents controlled by the build controller to execute the build script. 
     Example 8 is the computing system of any or all previous examples and further comprising: 
     a test computing system that integrates the test components into the build environment. 
     Example 9 is the computing system of any or all previous examples wherein the user interface component detects developer customizations to the computing system to be customized to obtain a customized computing system, wherein the build computing system builds the customized co putting system, and further comprising: 
     a task recorder that records tasks performed by the built customized computing system to obtain a task recording. 
     Example 10 is the computing system of any or all previous examples and further comprising: 
     a test code generator component that generates test code for the tasks from the task recording, and integrates the test code into source code for the customized computing system. 
     Example 11 is a computer implemented method, comprising: 
     detecting a developer input to download, to a development system, a pre-configured set of build components; 
     automatically downloading the set of pre-configured build components to the development system in response to the detected developer input; 
     automatically setting up a development environment in the development system; 
     automatically migrating a computing system to be customized to the development environment; and 
     automatically accessing the set of pre-configured build components to set up a build environment on the development system. 
     Example 12 is the computer implemented method of claim wherein automatically setting up a development environment comprises: 
     provisioning a set of development environment virtual machines in the development environment; and 
     configuring the set of development environment virtual machines as development environment machines. 
     Example 13 is the computer implemented method of any or all previous examples wherein detecting further comprises: 
     detecting the developer input to download a set of pre-configured test components. 
     Example 14 is the computer implemented method of any or all previous examples wherein automatically downloading comprises: 
     automatically downloading a set of pre-configured test components. 
     Example 15 is the computer implemented method of any or all previous examples and further comprising: 
     automatically setting up the build environment. 
     Example 16 is the computer implemented method of any or all previous examples wherein automatically setting up the build environment comprises: 
     automatically provisioning build environment virtual machines; and 
     automatically configuring the virtual machines as build environment virtual machines. 
     Example 17 is the computer implemented method of any or all previous examples wherein automatically setting up the build environment comprises: 
     pre-configuring a build script; 
     generating a build controller; and 
     generating a set of build agents controlled by the build controller to execute the build script. 
     Example 18 is the computer implemented method of any or all previous examples and further comprising: 
     integrating the test components into the build environment. 
     Example 19 is the computer implemented method of any or all previous examples and further comprising: 
     detecting developer customizations to the computing system to be customized to obtain a customized computing system; 
     building the customized computing system; 
     recording tasks performed by the built customized computing system to obtain a task recording; 
     generating test code for the tasks from the task recording; and 
     integrating the test code into source code for the customized computing system. 
     Example 20 is a computing system, comprising: 
     a user interface component that detects a developer input to download, to a development system, a pre-configured set of build components; 
     a build system that automatically downloads the set of pre-configured build components to the development system in response to the detected developer input, automatically sets up a development environment in the development system, and automatically migrates a computing system to be customized to the development environment; 
     a build and test control system that automatically accesses the set of pre-configured build components to set up a build environment on the development system; and 
     a test computing system that automatically downloads a set of pre-configured test components in response to the developer input. 
     Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.