Authors : Ashwin Venkitaraman

Volume/Issue : Volume 9 - 2024, Issue 11 - November

Google Scholar : https://tinyurl.com/yzhshces

Scribd : https://tinyurl.com/356drxdd

DOI : https://doi.org/10.38124/ijisrt/IJISRT24NOV177

Abstract : Shift-Left Testing is a preventive approach in the SW development process of identifying and handling defects where testing is performed before the flow proceeds to the subsequent phases of SDLC. In most situations, testing is done after development, and this means that any defects get discovered later contributing to high costs and more time to complete the project. Essentially, Shift-Left Testing implies that testing should be conducted during the design or the coding stage and is beneficial due to the fact that in those stages of development, it is considerably less expensive to rectify problems that are detected. It uses integrated strategies including continuous integration, static code analysis and automated testing, in which the development and the test team work together from the start. Consequently, the approach results in enhanced quality of the software, their development time, and minimization of the post-release faults. Although Shift-Left Testing is changing many ways in software development for the better, it has some problems, for instance, changing organizational culture and has high demands to test automation frameworks.

Keywords : Shift-Level Testing, Early Bug Detection, Software Quality Assurance, Test Automation, Software Development Lifecycle (SDLC).

References :

1. Li, Z., Tan, L., Wang, X., Lu, S., Zhou, Y., & Zhai, C. (2006, October). Have things changed now? An empirical study of bug characteristics in modern open source software. In Proceedings of the 1st workshop on Architectural and system support for improving software dependability (pp. 25-33).
2. Regehr, J., Chen, Y., Cuoq, P., Eide, E., Ellison, C., & Yang, X. (2012, June). Test-case reduction for C compiler bugs. In Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation (pp. 335-346).
3. Pan, K., Kim, S., & Whitehead, E. J. (2009). Toward an understanding of bug fix patterns. Empirical Software Engineering, 14, 286-315.
4. Williams, C. C., & Hollingsworth, J. K. (2005). Automatic mining of source code repositories to improve bug finding techniques. IEEE Transactions on Software Engineering, 31(6), 466-480.
5. Yang, X., Chen, Y., Eide, E., & Regehr, J. (2011, June). Finding and understanding bugs in C compilers. In Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation (pp. 283-294).
6. Liblit, B., Aiken, A., Zheng, A. X., & Jordan, M. I. (2003). Bug isolation via remote program sampling. ACM Sigplan Notices, 38(5), 141-154.
7. Bader, J., Scott, A., Pradel, M., & Chandra, S. (2019). Getafix: Learning to fix bugs automatically. Proceedings of the ACM on Programming Languages, 3(OOPSLA), 1-27.
8. Jin, G., Song, L., Shi, X., Scherpelz, J., & Lu, S. (2012). Understanding and detecting real-world performance bugs. ACM SIGPLAN Notices, 47(6), 77-88.
9. Nama, Prathyusha. "AI-Powered Mobile Applications: Revolutionizing User Interaction Through Intelligent Features and Context-Aware Services." (2023).
10. Jang, J., Agrawal, A., & Brumley, D. (2012, May). ReDeBug: finding unpatched code clones in entire os distributions. In 2012 IEEE Symposium on Security and Privacy (pp. 48-62). IEEE.
11. Meszaros, G. (2007). xUnit test patterns: Refactoring test code. Pearson Education.
12. Herzig, K., Just, S., & Zeller, A. (2013, May). It's not a bug, it's a feature: how misclassification impacts bug prediction. In 2013 35th international conference on software engineering (ICSE) (pp. 392-401). IEEE.
13. Liblit, B. R. (2004). Cooperative bug isolation. University of California, Berkeley.
14. Pewny, J., Schuster, F., Bernhard, L., Holz, T., & Rossow, C. (2014, December). Leveraging semantic signatures for bug search in binary programs. In Proceedings of the 30th Annual Computer Security Applications Conference (pp. 406-415).
15. Sun, C., Le, V., & Su, Z. (2016, October). Finding compiler bugs via live code mutation. In Proceedings of the 2016 ACM SIGPLAN international conference on object-oriented programming, systems, languages, and applications (pp. 849-863).
16. Lu, S., Park, S., Seo, E., & Zhou, Y. (2008, March). Learning from mistakes: a comprehensive study on real world concurrency bug characteristics. In Proceedings of the 13th international conference on Architectural support for programming languages and operating systems (pp. 329-339).
17. Tufano, M., Watson, C., Bavota, G., Penta, M. D., White, M., & Poshyvanyk, D. (2019). An empirical study on learning bug-fixing patches in the wild via neural machine translation. ACM Transactions on Software Engineering and Methodology (TOSEM), 28(4), 1-29.
18. Hooimeijer, P., & Weimer, W. (2007, November). Modeling bug report quality. In Proceedings of the 22nd IEEE/ACM international conference on Automated software engineering (pp. 34-43).
19. Pewny, J., Garmany, B., Gawlik, R., Rossow, C., & Holz, T. (2015, May). Cross-architecture bug search in binary executables. In 2015 IEEE Symposium on Security and Privacy (pp. 709-724). IEEE.
20. Park, S. B., Hong, T., & Mitra, S. (2009). Post-silicon bug localization in processors using instruction footprint recording and analysis (IFRA). IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 28(10), 1545-1558.