STQA Mini Project Report
Uploaded by
Pranav SonarSTQA Mini Project Report
Uploaded by
Pranav SonarA PRELIMINARY REPORT ON
Software Testing and Quality Assurance Mini Project
SUBMITTED TO THE SAVITRIBAI PHULE PUNE UNIVERSITY, PUNE IN THE PARTIAL
FULFILLMENT OF THE REQUIREMENTS FOR THE ACADEMIC OF
FOURTH YEAR OF COMPUTER ENGINEERING
SUBMITTED BY
Pranav Sonar BBCO20106
DEPARTMENT OF COMPUTER ENGINEERING
DR. D.Y. PATIL INSTITUTE OF ENGINEERING, MANAGEMENT & RESEARCH
AKURDI, PUNE 411044
1|Page
SAVITRIBAI PHULE PUNE UNIVERSITY
AY 2023 -2024
CERTIFICATE
This is to certify that the Mini Project report of
Software Testing and Quality Assurance
Submitted by
Pranav Sonar BBCO20106
is a bonafied student of this institute and the work has been carried out by them under the supervision of M/r
Amol Dhakne and it is approved for the partial fulfillment of the requirement of Savitribai Phule Pune
University, for the award of the Fourth-year degree of Computer Engineering.
M/[Link] Dhakne M/s. P. P. Shevatekar
Guide Head
Department of Computer Engineering Department of Computer Engineering
Place: Pune
Date:
2|Page
ABSTRACT
Unit Testing of software applications is done during the development (coding) of an application. The objective of
Unit Testing is to isolate a section of code and verify its correctness. In procedural programming a unit may be an
individual function or procedure. The goal of Unit Testing is to isolate each part of the program and show that the
individual parts are correct. Unit Testing is usually performed by the developer.
Bug taxonomies help in providing fast and effective feedback so that they can easily identify possible reasons for
failure of the software. Using bug taxonomy, a large number of potential bugs can be grouped into few categories.
Whenever a new bug is reported, using bug taxonomy, a tester can easily analyze and put that bug into any of these
categories. At the end of testing, Testers can understand the type of categories of bugs that frequently occurred and
thereby in successive rounds of testing he can focus on writing more test cases that would help to detect such bugs.
In addition, test leaders can guide their testers to focus on such frequently occurring bugs.
In integration Testing, individual software modules are integrated logically and tested as a group. A typical software
project consists of multiple software modules, coded by different programmers. integration Testing focuses on
checking data communication amongst these modules.
Keyword: Unit Testing, Integration Testing, Bug, Test Cases, Test Suite, Junit
3|Page
ACKNOWLEDGEMENT
First and foremost, I would like to thank my guide for this Mini Project, M/r. Amol Dhakne for the valuable
guidance and advice. She inspired us greatly to work in this seminar. Her willingness to motivate us contributed
tremendously to our work. I also would like to thank her for showing me some examples that related to the topic of
my Mini Project.
Apart from our efforts, the success of any seminar depends largely on the encouragement and guidelines of many
others. So, we take this opportunity to express my gratitude to M/s. P. P. Shevatekar, Head of the Department of
Computer Engineering, Dr. D Y Patil Institute of Engineering, Management and Research, Akurdi has been
instrumental in the successful completion of this seminar work.
The guidance and support received from all the members who contributed and who are contributing to this seminar
work were vital for the success of the seminar. I am grateful for their constant support and help.
Pranav Sonar
Student Name
(B.E. COMPUTER ENGG.)
4|Page
TABLE OF CONTENT
Sr No. Content Page No.
1 Introduction 6
1.1. Introduction 6
1.2. Problem Statement 7
1.3. Objectives 7
2 Methodology 8
3 Implementation 9-22
4 Conclusion 23
5|Page
CHAPTER 1: INTRODUCTION
1.1. INTRODUCTION
Sorting is a fundamental operation in computer science and plays a crucial role in numerous applications,
from data processing to information retrieval and beyond. Two commonly used sorting algorithms, Merge Sort and
Multithreaded Merge Sort, have garnered attention due to their efficiency and adaptability to varying data sizes. In
this context, this study aims to investigate and compare the performance of these two sorting algorithms while
considering best-case and worst-case scenarios.
Merge Sort is celebrated for its time complexity of O(n log n) and its reliability in achieving this efficiency
across a wide range of input data. It follows a divide-and-conquer approach, breaking down the sorting task into
smaller, more manageable subproblems and then merging the results to create a fully sorted list. This algorithm's
consistent performance has made it a preferred choice for sorting large datasets.
Multithreaded Merge Sort, on the other hand, builds upon the foundation of Merge Sort by harnessing the
power of multithreading. In a multi-core processor environment, this algorithm parallelizes the sorting process,
potentially leading to speed enhancements. However, the performance of Multithreaded Merge Sort can be influenced
by the context in which it is applied, particularly in scenarios where thread synchronization overhead becomes a
factor.
To gain a comprehensive understanding of the relative strengths and weaknesses of these sorting algorithms,
we conduct experiments that encompass both best-case and worst-case scenarios. In the best-case scenario, we
examine the performance when the input data is already sorted, while the worst-case scenario investigates the
challenges associated with sorting input data in reverse order. The outcomes of these experiments provide insights
into the practical applicability of these sorting methods under various conditions.
The findings from this study can help guide decisions when selecting sorting algorithms for specific use cases,
taking into account the trade-offs between algorithmic efficiency and performance optimization. Sorting is a critical
operation in many real-world applications, and understanding the nuances of these sorting algorithms in different
scenarios is essential for making informed choices in algorithm selection and implementation.
6|Page
1.2. PROBLEM STATEMENT
Create a small application by selecting relevant system environment/ platform and programming languages.
Narrate concise Test Plan consisting features to be tested and bug taxonomy. Prepare Test Cases inclusive of Test
Procedures for identified Test Scenarios. Perform selective Black-box and White-box testing covering Unit and
Integration test by using suitable Testing tools. Prepare
1.3. OBJECTIVE
We are going to learn how to Prepare Test Cases inclusive of Test Procedures for identified Test Scenarios. Perform
selective Black-box and White-box testing covering Unit and Integration test by using suitable Testing tools. also
Prepare Test Reports based on Test Pass/Fail Criteria
7|Page
CHAPTER 3: METHODOLOGY
The methodology for this mini-project involves several key steps. First, we select a relevant system environment and
programming language, in this case, opting for Android as the platform and Java as the programming language. We
then define a test plan outlining objectives and testing phases.
Next, we develop a small application, such as a to-do list, and identify various test scenarios, creating detailed test
cases with test procedures for each scenario. Black-box testing is conducted to ensure the application functions
correctly from a user's perspective, while white-box testing explores the internal logic and code paths. Unit testing is
employed to verify individual components, and integration testing is carried out to examine interactions between
different parts of the application. Test reports are generated based on predefined pass/fail criteria for each test case.
Finally, the acceptance of the application is judged against these criteria, with further iterations of testing and
development being performed until all critical bugs are resolved and acceptance criteria are met, ensuring a robust
and reliable application.
8|Page
CHAPTER 3: IMPLEMANTATION
1. Download JDK 1.8 and Eclipse latest version here we are using eclipse-java-photon-R-win32.
2. Open Eclipse IDE
3. Go to File and Select New -> Create New Java Project
9|Page
4. Give Junit Test Project name to the project and check use project folder as root for source and class files
5. Click on Next-> Next Screen will Appear-> Click Finish
10 | P a g e
6. Next Screen Shown JunitTestProject Folder in Project Explorer
7. Right Click on Folder name JunitTestProject->New->Package
11 | P a g e
8. Name package as programming hub-> Click on Finish
9. See the Programming hub package see in project Explorer Screen of Eclipse
12 | P a g e
10. Right Click on Programminghub Package->New->Class give the name JunitClass->Click Finish.
11. Next screen will appear
13 | P a g e
12 Write a small program with only two functions Add and Multiplication
13. Write Test Cases for Java Program
14. Name test suite as Add Test and choose New Junit4 test
14 | P a g e
15. Click on add Checkbox
16. Click on Next-> Ok
17. Next screen will appear
15 | P a g e
18. Write a code for Test case addition of two number inside AddTest
19. Let us run AddTest test case. Right click AddTest-> Debug As->JUnit Test
16 | P a g e
20. Result of test case is as follows. It shows 0 error and 0 failure and green color test bar which means that
test case has run successfully( Green Color Bar Indicate)
21. Let us purposely give wrong input in assertEquals method or unexpected result here we write 501 instead of
500 indicate wrong addition result
17 | P a g e
22. Now test case should fail.(Brown Color Bar Indicate) So again run Add Test as follow
23. Similarly you can Create Test case for Multiplication Function
Click on Project Explorer Screen-> Right Click on JunitClass->New->JUnit Test Case-> Give name MulTest
18 | P a g e
24. Click on Next ->Select Mul Check Box -> Click Finish
25. Next Screen will appear
26. Write a Test Case Code inside MulTest method
19 | P a g e
27. Right Click on MulTest->Debug->JUnit Test
28. Execute Test
20 | P a g e
29. Click on Package name->New->Other->JUnit->JUnit Test Suite->Next
30. Click on Finsh
21 | P a g e
31. Next Screen Appear that automatically create Test Suite for Add and Mul
32. Execute Test Suite Right Click on All Test ->Debug->JUnit Test
33. Test Suite Executed successfully Test suite fails even if a single test case among all fails.
22 | P a g e
CHAPTER 4: CONLUSION
In this mini-project, we selected the Android platform, developed a small to-do list application using Java, and
conducted both black-box and white-box testing. Test cases were executed, and test reports were generated based on
pass/fail [Link] acceptance of the application can be determined by comparing the test results against predefined
acceptance criteria. If all criteria are met, the application can be considered [Link]'s crucial to iterate through
testing and development until the acceptance criteria are met, and all critical bugs are fixed.
23 | P a g e
24 | P a g e
25 | P a g e
26 | P a g e
27 | P a g e
DYPIEMR, Department of Computer Engineering 2023-24
Common questions
Powered by AIThe development and testing of a to-do list application serve as a practical demonstration of applying software testing methodologies by integrating both theoretical and practical components of testing . It covers the key steps of software testing strategies, such as defining test scenarios, creating test cases, and conducting black-box and white-box testing, to ensure functionality from both an end-user and internal logic perspective. Unit testing verifies individual functions, while integration testing ensures cohesive interaction between app components. This holistic approach ensures that the application meets both functional and non-functional requirements, such as reliability and performance. Additionally, iterative testing refines these processes, improving the application's robustness and ensuring it meets all acceptance criteria .
The systematic approach to implementing and testing a Java project using Eclipse IDE involves creating a new Java project and setting up a structured environment for development and testing. The process begins with downloading and configuring the necessary tools, such as JDK and Eclipse IDE . A new project is created, and a package and class structure is established for organizing the code. Java classes with functions, such as Add and Multiplication, are developed . Unit tests are then designed and implemented using JUnit, where individual test cases examine each function's correctness. A Test Suite is created to group these unit tests, which is executed to verify the test outcomes using Eclipse's integrated testing tools. Test results are analyzed to validate the code, with iterative cycles handling any failures, ensuring the reliability and correctness of the software .
The steps involved in preparing a test plan and conducting testing for a small Android application developed using Java include: selecting a relevant system environment and programming language, defining the test plan outlining objectives and phases, developing the application (e.g., a to-do list), identifying test scenarios, and creating detailed test cases with procedures for each scenario . Testing involves conducting black-box tests to examine functionality from a user's view and white-box tests to explore internal logic and code paths. Unit testing verifies individual components, and integration testing examines interactions between application parts. Finally, test reports are generated based on pass/fail criteria to determine the application's acceptance .
Bug taxonomy is significant in the software testing process as it helps in categorizing and analyzing bugs. By grouping a large number of potential bugs into few categories, testers can quickly identify possible reasons for software failures and understand the common types of issues that occur . This understanding allows testers to focus on writing test cases that are more likely to detect these types of bugs in future testing cycles, increasing the efficiency and effectiveness of the testing process. It also aids test leaders in guiding testers to concentrate on frequently occurring issues, thereby optimizing resource allocation .
The performance of Multithreaded Merge Sort can be influenced by the context in which it is applied. While it can potentially lead to speed enhancements by utilizing multithreading in a multi-core processor environment, certain scenarios such as thread synchronization overhead can affect its performance negatively . Additionally, when the input data does not significantly benefit from parallel processing, the overhead of managing threads may outweigh the performance gains . This makes it imperative to evaluate the context and data characteristics before selecting this algorithm.
Performance trade-offs that must be considered when selecting a sorting algorithm for specific use cases include the algorithm's time and space complexity, adaptability to data size and distribution, stability, and scalability in different environments. For example, while Merge Sort has a reliable time complexity of O(n log n) suitable for large datasets, it requires additional memory for its operations compared to in-place sorting algorithms . Multithreaded sorting algorithms, like Multithreaded Merge Sort, can expedite sorting in environments with ample processing cores, but they might incur synchronization overhead. Thus, the choice of algorithm must consider the specific requirements and constraints of the application context, including available system resources and expected data characteristics .
The study's conclusion emphasizes the importance of iterative testing and development by highlighting the necessity of meeting predefined acceptance criteria before considering the application accepted . It stresses that continuous iterations are critical to identifying and fixing all critical bugs, assessing test results against pass/fail criteria, and ensuring that the application functions correctly and reliably. These iterations allow for thorough testing and refinement in both the development and testing phases, ultimately contributing to a more robust and user-ready application .
Challenges that might arise during the synchronization of threads in a multithreaded sorting algorithm include managing data consistency and avoiding race conditions and deadlocks. These issues require careful coordination of thread operations to prevent access conflicts and ensure correct program execution . The overhead caused by implementing locking mechanisms or synchronization primitives can significantly impact the performance of the algorithm by introducing delays that negate the speed benefits of multithreading. This overhead can result in sub-optimal performance, especially if the cost of synchronization exceeds the computational benefits gained from parallel processing .
The main objectives of conducting black-box testing are to validate the functionality of the application from a user's perspective, ensuring that the software meets the specified requirements without considering the internal workings of the application . White-box testing aims to verify the internal logic, code paths, and functionalities by focusing on the code structure itself, which helps in identifying security vulnerabilities, optimizing code, and ensuring reliability through detailed path coverage .
Unit testing focuses on verifying individual software components or functions to ensure they work correctly in isolation, often performed by the developer responsible for that section of code . Integration testing, on the other hand, checks the interactions and data communication among integrated software modules, which may be coded by different programmers, to ensure they work together as intended . The primary utility of integration testing is to uncover issues related to interface and interaction between modules, whereas unit testing aims to ensure the correctness of the individual components themselves.