Giovanni Grano
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Research Subjects
Giovanni Grano has a total of 26 co-authors. Here are the top co-authors by number of shared publications:
Harald C. Gall
9 shared publicationsSebastiano Panichella
School of Engineering Zurich University of Applied Science Zurich Switzerland
6 shared publications- Fabio Palomba
University of Salerno
4 shared publications Rocco Oliveto
University of Molise, Italy
3 shared publications- Simone Scalabrino
University of Molise, Pesche (IS), Italy
3 shared publications Adelina Ciurumelea
University of Zurich, Department of Informatics, Switzerland
2 shared publications
Latest Publications
- 14 September 2020
- Published by Wiley in Journal of Software: Evolution and Process
- Vol. 33 (3) , e2316
Investigating the criticality of user‐reported issues through their relations with app rating
App quality impacts user experience and satisfaction. As a consequence, both app ratings and user feedback reported in app reviews are directly influenced by the user‐perceived app quality. Through an empirical study involving 210,517 reviews related to 317 Android apps, in this paper, we experiment with the combined usage of app rating and user reviews analysis (i) to investigate the most important factors influencing the perceived app quality, (ii) focusing on the topics discussed in user review that most relate with app rating. Besides, we investigate whether specific code quality metrics could be monitored to prevent the rising of negative user feedback (i.e., types of user review comments), connected with low ratings. Our study demonstrates that user comments reporting bugs are negatively correlated with the rating, while reviews reportingfeature requests do not. Interestingly, depending on the app category, we observed that different kinds of issues have rather different relationships with the rating and the user‐perceived quality of the app. In particular, we observe that for specific app categories (e.g., communication), some code quality factors have significant relationships with the raising of certain types of feedback, which, in turn, are negatively connected with app ratings.
- 14 September 2020
- Published by Wiley in Journal of Software: Evolution and Process
- Vol. 33 (3) , e2316
Investigating the criticality of user‐reported issues through their relations with app rating
App quality impacts user experience and satisfaction. As a consequence, both app ratings and user feedback reported in app reviews are directly influenced by the user‐perceived app quality. Through an empirical study involving 210,517 reviews related to 317 Android apps, in this paper, we experiment with the combined usage of app rating and user reviews analysis (i) to investigate the most important factors influencing the perceived app quality, (ii) focusing on the topics discussed in user review that most relate with app rating. Besides, we investigate whether specific code quality metrics could be monitored to prevent the rising of negative user feedback (i.e., types of user review comments), connected with low ratings. Our study demonstrates that user comments reporting bugs are negatively correlated with the rating, while reviews reportingfeature requests do not. Interestingly, depending on the app category, we observed that different kinds of issues have rather different relationships with the rating and the user‐perceived quality of the app. In particular, we observe that for specific app categories (e.g., communication), some code quality factors have significant relationships with the raising of certain types of feedback, which, in turn, are negatively connected with app ratings.
- Open Access
Testing with Fewer Resources: An Adaptive Approach to Performance-Aware Test Case Generation
Automated test case generation is an effective technique to yield high-coverage test suites. While the majority of research effort has been devoted to satisfying coverage criteria, a recent trend emerged towards optimizing other non-coverage aspects. In this regard, runtime and memory usage are two essential dimensions: less expensive tests reduce the resource demands for the generation process and later regression testing phases. This study shows that performance-aware test case generation requires solving two main challenges: providing a good approximation of resource usage with minimal overhead and avoiding detrimental effects on both final coverage and fault detection effectiveness. To tackle these challenges, we conceived a set of performance proxies -- inspired by previous work on performance testing -- that provide a reasonable estimation of the test execution costs (i.e., runtime and memory usage). Thus, we propose an adaptive strategy, called aDynaMOSA, which leverages these proxies by extending DynaMOSA, a state-of-the-art evolutionary algorithm in unit testing. Our empirical study -- involving 110 non-trivial Java classes -- reveals that our adaptive approach generates test suite with statistically significant improvements in runtime (-25%) and heap memory consumption (-15%) compared to DynaMOSA. Additionally, aDynaMOSA has comparable results to DynaMOSA over seven different coverage criteria and similar fault detection effectiveness. Our empirical investigation also highlights that the usage of performance proxies (i.e., without the adaptiveness) is not sufficient to generate more performant test cases without compromising the overall coverage.
Open AccessTesting with Fewer Resources: An Adaptive Approach to Performance-Aware Test Case Generation
Automated test case generation is an effective technique to yield high-coverage test suites. While the majority of research effort has been devoted to satisfying coverage criteria, a recent trend emerged towards optimizing other non-coverage aspects. In this regard, runtime and memory usage are two essential dimensions: less expensive tests reduce the resource demands for the generation process and later regression testing phases. This study shows that performance-aware test case generation requires solving two main challenges: providing a good approximation of resource usage with minimal overhead and avoiding detrimental effects on both final coverage and fault detection effectiveness. To tackle these challenges, we conceived a set of performance proxies -- inspired by previous work on performance testing -- that provide a reasonable estimation of the test execution costs (i.e., runtime and memory usage). Thus, we propose an adaptive strategy, called aDynaMOSA, which leverages these proxies by extending DynaMOSA, a state-of-the-art evolutionary algorithm in unit testing. Our empirical study -- involving 110 non-trivial Java classes -- reveals that our adaptive approach generates test suite with statistically significant improvements in runtime (-25%) and heap memory consumption (-15%) compared to DynaMOSA. Additionally, aDynaMOSA has comparable results to DynaMOSA over seven different coverage criteria and similar fault detection effectiveness. Our empirical investigation also highlights that the usage of performance proxies (i.e., without the adaptiveness) is not sufficient to generate more performant test cases without compromising the overall coverage.
- 11 October 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 47 (11) , 2332-2347
Testing with Fewer Resources: An Adaptive Approach to Performance-Aware Test Case Generation
- 11 October 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Transactions on Software Engineering
- Vol. 47 (11) , 2332-2347
Testing with Fewer Resources: An Adaptive Approach to Performance-Aware Test Case Generation
- Open Access
- 1 October 2019
- Published by Elsevier in Journal of Systems and Software
- Vol. 156, 312-327
Scented since the beginning: On the diffuseness of test smells in automatically generated test code
- 1 October 2019
- Published by Elsevier in Journal of Systems and Software
- Vol. 156, 312-327
Open AccessScented since the beginning: On the diffuseness of test smells in automatically generated test code
- Open Access
- 10 July 2019
- Published by Association for Computing Machinery (ACM)
- p. 419-423
A new dimension of test quality: assessing and generating higher quality unit test cases
- 10 July 2019
- Published by Association for Computing Machinery (ACM)
- p. 419-423
Open AccessA new dimension of test quality: assessing and generating higher quality unit test cases
- 1 July 2019
- Published by Elsevier in Science of Computer Programming
- Vol. 180, 1-15
A large-scale empirical exploration on refactoring activities in open source software projects
- 1 July 2019
- Published by Elsevier in Science of Computer Programming
- Vol. 180, 1-15
A large-scale empirical exploration on refactoring activities in open source software projects
- 1 May 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 121-125
On the Effectiveness of Manual and Automatic Unit Test Generation: Ten Years Later
Good unit tests play a paramount role when it comes to foster and evaluate software quality. However, writing effective tests is an extremely costly and time consuming practice. To reduce such a burden for developers, researchers devised ingenious techniques to automatically generate test suite for existing code bases. Nevertheless, how automatically generated test cases fare against manually written ones is an open research question. In 2008, Bacchelli et.al. conducted an initial case study comparing automatic and manually generated test suites. Since in the last ten years we have witnessed a huge amount of work on novel approaches and tools for automatic test generation, in this paper we revise their study using current tools as well as complementing their research method by evaluating these tools' ability in finding regressions. Preprint [\url{https://doi.org/10.5281/zenodo.2595232}], dataset [\url{https://doi.org/10.6084/m9.figshare.7628642}].
- 1 May 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 121-125
On the Effectiveness of Manual and Automatic Unit Test Generation: Ten Years Later
Good unit tests play a paramount role when it comes to foster and evaluate software quality. However, writing effective tests is an extremely costly and time consuming practice. To reduce such a burden for developers, researchers devised ingenious techniques to automatically generate test suite for existing code bases. Nevertheless, how automatically generated test cases fare against manually written ones is an open research question. In 2008, Bacchelli et.al. conducted an initial case study comparing automatic and manually generated test suites. Since in the last ten years we have witnessed a huge amount of work on novel approaches and tools for automatic test generation, in this paper we revise their study using current tools as well as complementing their research method by evaluating these tools' ability in finding regressions. Preprint [\url{https://doi.org/10.5281/zenodo.2595232}], dataset [\url{https://doi.org/10.6084/m9.figshare.7628642}].
- Open Access
- 8 March 2019
- Published by Wiley in Journal of Software: Evolution and Process
- Vol. 31 (9)
Branch coverage prediction in automated testing
Software testing is crucial in continuous integration (CI). Ideally, at every commit, all the test cases should be executed, and moreover, new test cases should be generated for the new source code. This is especially true in a Continuous Test Generation (CTG) environment, where the automatic generation of test cases is integrated into the continuous integration pipeline. In this context, developers want to achieve a certain minimum level of coverage for every software build. However, executing all the test cases and, moreover, generating new ones for all the classes at every commit is not feasible. As a consequence, developers have to select which subset of classes has to be tested and/or targeted by test‐case generation. We argue that knowing a priori the branch coverage that can be achieved with test‐data generation tools can help developers into taking informed decision about those issues. In this paper, we investigate the possibility to use source‐code metrics to predict the coverage achieved by test‐data generation tools. We use four different categories of source‐code features and assess the prediction on a large data set involving more than 3'000 Java classes. We compare different machine learning algorithms and conduct a fine‐grained feature analysis aimed at investigating the factors that most impact the prediction accuracy. Moreover, we extend our investigation to four different search budgets. Our evaluation shows that the best model achieves an average 0.15 and 0.21 MAE on nested cross‐validation over the different budgets, respectively, onEVOSUITEandRANDOOP. Finally, the discussion of the results demonstrate the relevance of coupling‐related features for the prediction accuracy.
- 8 March 2019
- Published by Wiley in Journal of Software: Evolution and Process
- Vol. 31 (9)
Open AccessBranch coverage prediction in automated testing
Software testing is crucial in continuous integration (CI). Ideally, at every commit, all the test cases should be executed, and moreover, new test cases should be generated for the new source code. This is especially true in a Continuous Test Generation (CTG) environment, where the automatic generation of test cases is integrated into the continuous integration pipeline. In this context, developers want to achieve a certain minimum level of coverage for every software build. However, executing all the test cases and, moreover, generating new ones for all the classes at every commit is not feasible. As a consequence, developers have to select which subset of classes has to be tested and/or targeted by test‐case generation. We argue that knowing a priori the branch coverage that can be achieved with test‐data generation tools can help developers into taking informed decision about those issues. In this paper, we investigate the possibility to use source‐code metrics to predict the coverage achieved by test‐data generation tools. We use four different categories of source‐code features and assess the prediction on a large data set involving more than 3'000 Java classes. We compare different machine learning algorithms and conduct a fine‐grained feature analysis aimed at investigating the factors that most impact the prediction accuracy. Moreover, we extend our investigation to four different search budgets. Our evaluation shows that the best model achieves an average 0.15 and 0.21 MAE on nested cross‐validation over the different budgets, respectively, onEVOSUITEandRANDOOP. Finally, the discussion of the results demonstrate the relevance of coupling‐related features for the prediction accuracy.
- Open Access
- 3 September 2018
- Published by Association for Computing Machinery (ACM)
- p. 868-871
OCELOT: a search-based test-data generation tool for C
- 3 September 2018
- Published by Association for Computing Machinery (ACM)
- p. 868-871
Open AccessOCELOT: a search-based test-data generation tool for C
- Open Access
- 28 May 2018
- Published by Association for Computing Machinery (ACM)
- p. 348-351
An empirical investigation on the readability of manual and generated test cases
- 28 May 2018
- Published by Association for Computing Machinery (ACM)
- p. 348-351
Open AccessAn empirical investigation on the readability of manual and generated test cases