Description:
BACKGROUND
Field of Invention
Embodiments of the present invention generally relate to a computer program testing and particularly to a system for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle.
Description of Related Art
Software testing is a crucial phase in the software development lifecycle (SDLC) for quality, reliability, and security before deployment. Traditionally, testing was conducted at the final stages of development, following a sequential approach in waterfall models. However, this late-stage testing often resulted in high costs, project delays, and lower software quality due to the late detection of defects. As software systems have grown more complex and time-sensitive, there has been an increasing emphasis on methodologies that integrate testing earlier in the development process, reducing risks and improving efficiency.
The advent of Agile and DevOps methodologies has revolutionized software development by promoting iterative cycles, collaboration, and continuous integration. In these environments, conventional late-stage testing approaches fail to keep up with the rapid pace of development. Organizations have thus adopted strategies such as test automation, continuous testing, and behavior-driven development (BDD) to enhance software quality while maintaining development speed. Despite these advancements, many testing frameworks still lack seamless integration into the development pipeline, which further leads to inefficiencies and difficulties in defect detection at early stages.
To address these challenges, shift-left testing methodologies have been introduced, encouraging testing at the earliest stages of SDLC. This approach involves proactive defect detection, close collaboration between developers and testers, and the use of automation to streamline testing. By embedding testing within Agile and DevOps practices, organizations can minimize late-stage defects, reduce costs, and improve product reliability. However, the implementation of shift-left testing comes with its own challenges, including the need for cultural adaptation, a skilled workforce, and optimized testing frameworks that integrate seamlessly into modern software development models.
There is thus a need for an improved and advanced system for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle that can administer the aforementioned limitations in a more efficient manner.
SUMMARY
Embodiments in accordance with the present invention provide a system for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle. The system comprising a data establishment unit adapted to install a computer language package on a computing device. The system further comprising a processor embedded in the computing device. The processor is configured to determine, using a timing circuit, an optimal test timing for the computer language package; execute, using an input unit, test cases in the determined optimal test timings for detecting defects in the computer language package; incorporate feedback from the executed test cases by integrating a process of debugging into development for eliminating the detected defects; perform audits and inspections, upon incorporation of the feedback and conducting the process of debugging, against the detected defects in the computer language package; and track a test coverage and the resolved detect in the computer language package.
Embodiments in accordance with the present invention further provide a method for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle. The method comprising steps of determining, using a timing circuit, an optimal test timing for a computer language package; executing, using an input unit, test cases in the determined optimal test timings for detecting defects in the computer language package; incorporating feedback from the executed test cases by integrating a processing of debugging into development for eliminating the detected defects; performing audits and inspections, upon incorporation of the feedback and conducting the process of debugging, against the detected defects in the computer language package; and tracking a test coverage and the resolved detect in the computer language package.
Embodiments of the present invention may provide a number of advantages depending on their particular configuration. First, embodiments of the present application may provide a system for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle.
Next, embodiments of the present application may provide a system that identifies defects early, reducing the cost and effort required to fix them compared to late-stage testing.
Next, embodiments of the present application may provide a system that enhances code quality, minimizes defects, and ensures robust, error-free computer language package releases.
Next, embodiments of the present application may provide a system that allows defects to be addressed in real-time for accelerating development cycles and enabling quicker computer language package deployment.
Next, embodiments of the present application may provide a system that fosters collaboration between developers, testers, and operations teams for seamless integration of testing into the development workflow.
Next, embodiments of the present application may provide a system that significantly reduces debugging and maintenance costs, optimizing resource utilization throughout the computer language package lifecycle.
These and other advantages will be apparent from the present application of the embodiments described herein.
The preceding is a simplified summary to provide an understanding of some embodiments of the present invention. This summary is neither an extensive nor exhaustive overview of the present invention and its various embodiments. The summary presents selected concepts of the embodiments of the present invention in a simplified form as an introduction to the more detailed description presented below. As will be appreciated, other embodiments of the present invention are possible utilizing, alone or in combination, one or more of the features set forth above or described in detail below.
BRIEF DESCRIPTION OF THE DRAWINGS
The above and still further features and advantages of embodiments of the present invention will become apparent upon consideration of the following detailed description of embodiments thereof, especially when taken in conjunction with the accompanying drawings, and wherein:
FIG. 1 illustrates a schematic block diagram of a system for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle, according to an embodiment of the present invention;
FIG. 2 illustrates a block diagram of a processor, according to an embodiment of the present invention; and
FIG. 3 depicts a flowchart of a method for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle, according to an embodiment of the present invention.
The headings used herein are for organizational purposes only and are not meant to be used to limit the scope of the description or the claims. As used throughout this application, the word "may" is used in a permissive sense (i.e., meaning having the potential to), rather than the mandatory sense (i.e., meaning must). Similarly, the words “include”, “including”, and “includes” mean including but not limited to. To facilitate understanding, like reference numerals have been used, where possible, to designate like elements common to the figures. Optional portions of the figures may be illustrated using dashed or dotted lines, unless the context of usage indicates otherwise.
DETAILED DESCRIPTION
The following description includes the preferred best mode of one embodiment of the present invention. It will be clear from this description of the invention that the invention is not limited to these illustrated embodiments but that the invention also includes a variety of modifications and embodiments thereto. Therefore, the present description should be seen as illustrative and not limiting. While the invention is susceptible to various modifications and alternative constructions, it should be understood, that there is no intention to limit the invention to the specific form disclosed, but, on the contrary, the invention is to cover all modifications, alternative constructions, and equivalents falling within the scope of the invention as defined in the claims.
In any embodiment described herein, the open-ended terms "comprising", "comprises”, and the like (which are synonymous with "including", "having” and "characterized by") may be replaced by the respective partially closed phrases "consisting essentially of", “consists essentially of", and the like or the respective closed phrases "consisting of", "consists of”, the like.
As used herein, the singular forms “a”, “an”, and “the” designate both the singular and the plural, unless expressly stated to designate the singular only.
FIG. 1 illustrates a schematic block diagram of a system for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle, according to an embodiment of the present invention. The system 100 may be adapted to streamline a process of a computer language package. The system 100 may be adapted to conduct a Shift Left Testing (SLT) strategy testing of the computer language package. After testing the computer language package, the system 100 may be adapted to provide a feedback on the testing, moreover, the system 100 may be adapted to incorporate the provided feedback in a process of debugging the computer language package for resolution of bugs and errors. Further, the system 100 may be adapted to track the resolved bugs and errors in the computer language package.
In an embodiment of the present invention, the Shift Left Testing (SLT) strategy may ensure higher code quality by integrating testing and debugging in the initial phases of development of the computer language package. The initial phases of development may be, but not limited to, an early requirement validation, an automated defect identification, a static and dynamic code analysis, and real-time feedback loops, and so forth. Embodiments of the present invention are intended to include or otherwise cover any initial phases of development of the computer language package, including known, related art, and/or later developed technologies. Further, the Shift Left Testing (SLT) strategy may be implemented within an Agile DevOps model to ensure continuous testing and integration across all iterations of the computer language package.
According to the embodiments of the present invention, the system 100 may incorporate non-limiting hardware components to enhance the processing speed and efficiency such as the system 100 may comprise a computing device 102, a data establishment unit 104, a processor 106, a timing circuit 108, and an input unit 110. In an embodiment of the present invention, the hardware components of the system 100 may be integrated with computer-executable instructions for overcoming the challenges and the limitations of the existing systems.
In an embodiment of the present invention, the computing device 102 may be adapted to upload the computer language package to the system 100. The computer language package may be, but not limited to, a software, a firmware, an Over the Air (OTA) update, an open-source code, a close-source code, and so forth. Embodiments of the present invention are intended to include or otherwise cover any type of the computer language package, including known, related art, and/or later developed technologies. The computing device 102 may be, but not limited to, a laptop, a mobile, and so forth. Embodiments of the present invention are intended to include or otherwise cover any type of the computing device 102, including known, related art, and/or later developed technologies.
In an embodiment of the present invention, the data establishment unit 104 may be adapted to receive the computer language package uploaded by the computing device 102. Further, the data establishment unit 104 may be adapted to decode, install, and execute the computer language package onto the computing device 102.
In an embodiment of the present invention, the processor 106 may be embedded in the computing device 102. The processor 106 may further be configured to execute computer-executable instructions to generate an output relating to the system 100. According to embodiments of the present invention, the processor 106 may be, but not limited to, a Programmable Logic Control (PLC) unit, a microprocessor, a development board, and so forth. Embodiments of the present invention are intended to include or otherwise cover any type of the processor 106 including known, related art, and/or later developed technologies. In an embodiment of the present invention, the processor 106 may further be explained in conjunction with FIG. 2.
In an embodiment of the present invention, the timing circuit 108 may be adapted to set a Time to Live (TTL) for every command that may be issued to the computer language package. For example, the computer language package may be issued a command of printing a report file, as the command may be issued, the timing circuit 108 may set the Time to Live (TTL) for the corresponding command as 10 seconds. Hence, the computer language package may now be having 10 seconds for initiating and executing the printing of the report file, after issuance of the command. However, if the computer language package may be unable to initiate and execute the printing of the report file within 10 seconds of the issuance of the command, then a Break of Operation (BO) may be issued. The Break of Operation (BO) may dequeue the issued command and may further release resources occupied, upon issuance of the command. Further, the timing circuit 108 may be adapted to determine an optimal test timing for the computer language package. The optimal test timing determined for the computer language package may ensure prevention of occurrence of Break of Operation (BO) in the testing of the computer language package.
In an embodiment of the present invention, the input unit 110 may be adapted to issue command(s) to the data establishment unit 104 and/or to the processor 106. The input unit 110 may further be adapted to execute test cases on the computer language package. The input unit 110 may be, but not limited to, a touch interface, a keyboard, a pointing device, and so forth. Embodiments of the present invention are intended to include or otherwise cover any type of the input unit 110, including known, related art, and/or later developed technologies.
In an exemplary embodiment of the present invention, the system 100 may receive a software code for an AI-powered recipe generation application. Upon receiving the software code, the computing device 102 may upload the software code into the system 100, such as the data establishment unit 104 may decode, install, and execute the software code for validation. The processor 106 may conduct various test cases to ensure functionality of the software code, including verifying whether the AI correctly generates recipes based on a given list of ingredients, ensuring compliance with dietary restrictions such as vegan or gluten-free options, and validating that AI-suggested recipes align with user preferences and regional cuisines. The timing circuit 108 may set an optimal test timing for various functionalities so that AI-generated recommendations are delivered within an acceptable response time, such as 5 seconds. If the AI fails to meet this timeframe, a Break of Operation (BO) may be triggered, logging the issue for debugging. The input unit 110 may facilitate user interactions such as manually entering ingredients, selecting preferences, and triggering test cases. By implementing the Shift Left Testing (SLT) strategy, the system 100 may ensure early defect detection and debugging to improve the overall reliability and efficiency of the AI-powered recipe generation application.
In another exemplary embodiment, the system 100 may receive a software code for an image beautification application. Upon uploading the software code, the data establishment unit 104 decodes and executes the package, followed by the processor 106 performing multiple test cases, including checking filter application accuracy for smooth facial enhancements without distortion, and validating real-time performance under different lighting conditions. The timing circuit 108 may be configured to set processing time limits, such as ensuring that an AI-based skin smoothing function completes within 3 seconds; otherwise, a Break of Operation (BO) is initiated to free up resources. The input unit 110 may allow testers to upload images, apply filters, and analyze outputs. The integration of the SLT strategy in the testing phase ensures higher quality and optimized performance before deployment. The above examples are provided for illustrative purposes only to explain the functioning of the system. The embodiments are not limited to these examples and may include other applications such as AI-driven recommendations, autonomous systems, or any computer language package that benefits from the Shift Left Testing (SLT) strategy.
FIG. 2 illustrates a block diagram of the processor 106, according to an embodiment of the present invention. The processor 106 may comprise the computer-executable instructions in form of programming modules such as a testing module 200, a feedback module 202, and an inspection module 204.
In an embodiment of the present invention, the testing module 200 may be configured to activate the timing circuit 108 to determine the optimal test timing for the computer language package. The testing module 200 may further be configured to activate the input unit 110 to execute the test cases on the computer language package. The test cases may be executed within the determined optimal test timing. The test cases may be developed and shared with developers in advance to guide the design process, reducing post-development defects. Further, the execution of the test cases may detect defects in the computer language package.
In an embodiment of the present invention, the test cases may be planned using an equation (1):
PlanSLT[T]=∑_(i=1)^n▒〖maxTime(p_i )-minTime(p_i )+alloc(Bdg)-cost(p_i)〗 --- (1)
Upon detection of the defects in the computer language package within the determined optimal test timing, the testing module 200 may transmit a first activation signal to the feedback module 202.
The feedback module 202 may be activated upon receipt of the first activation signal from the testing module 200. The feedback module 202 may be configured to incorporate feedback from the executed test cases. The incorporated feedback may include the defects detected in the computer language package. The feedback module 202 may further be configured to integrate a process of debugging into a development of the computer language package. The debugging process, once integrated, may eliminate the detected defects in the computer language package.
In an embodiment of the present invention, the elimination of detected defects may be planned using an equation (2):
CodeSLT[Q]=∑_(i=1)▒minTime (PlanSLT(i))+lim┬(i→count(P))⁡〖(P(i)+R(i)/n+getTime(p(i)))^i εPlanSLT[T]〗 --- (2)
Upon integration of the process of debugging and the elimination of the detected defects, the feedback module 202 may be configured to transmit a second activation signal to the inspection module 204.
The inspection module 204 may be activated upon receipt of the second activation signal from the feedback module 202. The inspection module 204 may be configured to perform audits and inspections on the computer language package. The audits and inspections may be further be conducted after incorporation of the feedback and conducting the process of debugging. Moreover, the audits and inspections conducted against the detected defects in the computer language package.
In an embodiment of the present invention, the audits and inspections against the detected defects may be planned using an equation (3):
TestSLT[B]=max┬(0≤x≤n)⁡〖(maxTime(p(x))+G(P(x)〗)+∑_(i=P1)^n▒〖(P_i (R_i )-C_x )+CodeSLT[Q_x]〗 --- (3)
Furthermore, the audits and inspections may be conducted throughout all phases of the computer language package to maximize defect detection and mitigation before deployment. Further, the inspection module 204 may be configured to track a test coverage and the resolved detect in the computer language package.
In an embodiment of the present invention, the test coverage may be planned using an equation (4):
P,C,R□(←┬(i=1)[ R(TestSLT(P_i ))*cost(P_i )-setValue(C_i ),diff(TestSLT[R_i ],)
TestSLT[R_(i+1) ]),min⁡(R(codeSLT[Q])[Q]) --- (4)
In an exemplary scenario, a small healthcare company may be developing a data management tool for patient records with a team of four developers and two testers. The project may have strict regulatory requirements to necessitate a focus on data accuracy and security. As per the Shift Left Testing (SLT) strategy, the testers may be involved from the start to ensure that all regulatory requirements were understood and incorporated into the design and testing process. Further, the team may perform security testing during the design phase, using tools like ZAP OWASP to identify and mitigate potential vulnerabilities. Furthermore, the team may conduct regular code reviews, with testers involved in reviewing test cases and scripts for comprehensive coverage. Moreover, upon execution of the Shift Left Testing (SLT) strategy as cited above, the data management tool may be delivered on schedule, passing all regulatory audits with minimal revisions. The early focus on compliance and security testing may ensure that the data management tool may have met stringent industry standards, earning trust from healthcare providers.
In another exemplary scenario, a small team of three developers and one tester may be tasked with creating an educational web application for language learning. The project may be completed within four months to align with the start of the academic year. As per the Shift Left Testing (SLT) strategy, the team may break down the application into modules, with tests created for each module as it was developed. This modular approach may allow for incremental testing and early detection of integration issues. Further, the tester involved in early user experience (UX) discussions may help to design intuitive interfaces and conduct usability tests with a small group of users during the development phase. Furthermore, the team may implement automated regression tests to ensure that new features did not break presented functionality as the application evolved. Moreover, upon execution of the Shift Left Testing (SLT) strategy as cited above, the educational web application may be launched on time and received positive feedback from educators and students for its ease of use and reliability. The early focus on usability and modular testing helped the small team deliver a polished educational web application within a tight deadline.
FIG. 3 depicts a flowchart of a method 300 for implementing the Shift Left Testing (SLT) strategy in the computer language package development lifecycle using the system 100, according to an embodiment of the present invention.
At step 302, the system 100 may determine the optimal test timing for the computer language package.
At step 304, the system 100 may execute the test cases in the determined optimal test timings for detecting the defects in the computer language package.
At step 306, the system 100 may incorporate the feedback from the executed test cases by integrating the process of debugging into the development for eliminating the detected defects.
At step 308, the system 100 may perform the audits and inspections against the detected defects in the computer language package.
At step 310, the system 100 may track a test coverage and the resolved detect in the computer language package.
While the invention has been described in connection with what is presently considered to be the most practical and various embodiments, it is to be understood that the invention is not to be limited to the disclosed embodiments, but on the contrary, is intended to cover various modifications and equivalent arrangements included within the scope of the appended claims.
This written description uses examples to disclose the invention, including the best mode, and also to enable any person skilled in the art to practice the invention, including making and using any devices or systems and performing any incorporated methods. The patentable scope of the invention is defined in the claims, and may include other examples that occur to those skilled in the art. Such other examples are intended to be within the scope of the claims if they have structural elements that do not differ from the literal language of the claims, or if they include equivalent structural elements within substantial differences from the literal languages of the claims. , Claims:CLAIMS
I/We Claim:
1. A system (100) for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle, the system (100) comprising:
a data establishment unit (104) adapted to install a computer language package on a computing device (102);
a processor (106) embedded in the computing device (102), characterized in that the processor (106) is configured to:
determine, using a timing circuit (108), an optimal test timing for the computer language package;
execute, using an input unit (110), test cases in the determined optimal test timings for detecting defects in the computer language package;
incorporate feedback from the executed test cases by integrating a process of debugging into development to eliminate the detected defects;
perform audits and inspections, upon incorporation of the feedback and conducting the process of debugging, against the detected defects in the computer language package; and
track a test coverage and the resolved detect in the computer language package.
2. The system (100) as claimed in claim 1, wherein the audits and inspections are conducted throughout all phases of the computer language package to maximize defect detection and mitigation before deployment.
3. The system (100) as claimed in claim 1, wherein the test cases are developed and shared with developers in advance to guide the design process, reducing post-development defects.
4. The system (100) as claimed in claim 1, wherein the Shift Left Testing (SLT) strategy ensures higher code quality by integrating testing and debugging in the initial phases of development, selected from an early requirement validation, an automated defect identification, a static and dynamic code analysis, and real-time feedback loops, or a combination thereof.
5. The system (100) as claimed in claim 1, wherein the Shift Left Testing (SLT) strategy is implemented within an Agile DevOps model to ensure continuous testing and integration across all iterations of the computer language package.
6. A method (300) for implementing a Shift Left Testing (SLT) strategy in a computer language package development lifecycle, the method (300) is characterized by steps of:
determining, using a timing circuit (108), an optimal test timing for a computer language package;
executing, using an input unit (110), test cases in the determined optimal test timings for detecting defects in the computer language package;
incorporating feedback from the executed test cases by integrating a process of debugging into development for eliminating the detected defects;
performing audits and inspections, upon incorporation of the feedback and conducting the process of debugging, against the detected defects in the computer language package; and
tracking a test coverage and the resolved detection in the computer language package.
7. The method (300) as claimed in claim 6, wherein the audits and inspections are conducted throughout all phases of the computer language package to maximize defect detection and mitigation before deployment.
8. The method (300) as claimed in claim 6, wherein the test cases are developed and shared with developers in advance to guide the design process, reducing post-development defects.
9. The method (300) as claimed in claim 6, wherein the Shift Left Testing (SLT) strategy ensures higher code quality by integrating testing and debugging in the initial phases of development, selected from an early requirement validation, an automated defect identification, a static and dynamic code analysis, and real-time feedback loops, or a combination thereof.
10. The method (300) as claimed in claim 6, wherein the Shift Left Testing (SLT) strategy is implemented within an Agile DevOps model to ensure continuous testing and integration across all iterations of the computer language package.
Date: March 26, 2025
Place: Noida

Nainsi Rastogi
Patent Agent (IN/PA-2372)
Agent for the Applicant