I0015N
Testing of IT Systems
Weekly Report - Week 2
2022-04-08
Helen Caspersson
GitHub username helcas
helcas/Junit5_Calculator: JUnit5 test week 2 (github.com)
Table of Contents
R0 - Miscellaneous 2
R1 - Estimated number of words? 2
R2 - What done? 2
R3 - What learned? 3
R4 - How applied? 3
R5 - What initially was not understood? 3
R6 - Find two related YouTube videos 4
R7 - Find two related web pages 4
R8 - Find one Google Image 6
R9 -Reflections about the course book chapter material 6
Chapter 1 6
Chapter 2 7
Chapter 3 8
Chapter 4 8
R10 - Reflections about any other weekly activities, including hands-on labs 9
R11 - Reflections about one related topic 11
R12 - Review of academic trends and knowledge 11
R13 - Review of next week’s list of activities 12
References 12
1
R0 - Miscellaneous
Study Buddies: John Andén
Estimated number of hours: approximately 18 hours.
We also had a meeting discussing this week's assignments.
Did you attend the live group sessions, and if not, why not?
I attended one live group session this week, on Tuesday. I missed the live group
session on Monday this week because of my schedule at work.
R1 - Estimated number of words?
The estimated number of words are: 3075, including the table of contents and
references.
R2 - What done?
This week we signed up for a Linux Bash Scripting Course and continued to work
with JUnit5. I created a simple calculator in IntelliJ with methods and then created a
test for the methods. We also read chapter one to four in the course book, “Praktisk
Mjukvarutestning” by Eva Holmquist. I also watched the Course Chapter Lecture
Recordings for each of the chapters and wrote a reflection for each chapter with a
question for next week’s Live Group Sessions.
2
Image 1. Enrolled in Linux course
R3 - What learned?
I am continuing to learn more about testing and writing test programs in JUnit5. It is
still very new to me but I am learning more and more about writing the code for the
testing in JUnit5. The chapters in the course book are very interesting to me and I am
starting to realize that there is so much more to testing than I realized.
R4 - How applied?
This week I looked at job advertisements at Platsbanken to see what companies are
looking for when it comes to testers. What I found was that many companies did not
list specific programs but wanted experienced testers that know how to plan, develop
and execute tests. Some of the companies mentioned that they work with Azure,
others mentioned that they needed people with skills in SQL (one example
https://arbetsformedlingen.se/platsbanken/annonser/25880192). One mentioned that
they were looking for experience in several softwares such as Selenium. This course
will teach us a lot of what they are looking for in the advertisements and also give us
experience with several different types of software.
R5 - What initially was not understood?
I am still very inexperienced with IntelliJ, JUnit5 and GitHub. This is something that I
need to work a lot with to become more comfortable with using the programs.
3
R6 - Find two related YouTube videos
This week I wanted to continue to learn more about JUnit5 since I am a beginner
writing tests with JUnit5. I found this YouTube video about Java Unit Testing with
JUnit - Tutorial - How to Create And Use Unit Tests by Coding with John.
https://www.youtube.com/watch?v=vZm0lHciFsQ
In this video I learned how important it is to have multiple scenarios when you write
Unit tests. One example given in the video shows that a test for an add-method will
not fail if you change the addition to multiplication in the method it will still pass if you
use input parameters that are 2; 2+2 and 2*2 will give the same result and the test
will pass even though the method is faulty.
I am also very new to GitHub and I am still learning how to use it with IntelliJ. So I
have found that JetBrains has really good tutorials on YouTube. This week I learned
more about how to clone a project since I found it difficult during this week’s Live
Group Session to navigate Git in IntellIJ and wanted to learn more.
I found this video from JetBrains, IntelliJ IDEA Cloning a Project from GitHub.
https://www.youtube.com/watch?v=aBVOAnygcZw
R7 - Find two related web pages
I wanted to learn more about static testing and dynamic testing and to learn more
about how they are applied.
The main difference between Static testing and Dynamic Testing is that Dynamic
testing is used to find active bugs in the program whereas Static testing is used to
give an assessment of the code (Gillis, 2020).
During Static Testing you analyze documents such as design documents, user
documents and so on as well as user requirements and source code. The benefits
with Static testing is early detection of errors, reduced cost early in the development
and it can give developers a better idea of quality issues in the software (Gillis,
2020).
There two main parts of Static testing, review and static analysis. Static review is
used to find errors in the supporting documents whereas Static analysis is used to
analyze the code written by the developers (Gillis, 2020).
Dynamic testing is when you analyze the software functionality by executing the
code. This is done by testing given input values and the expected result (Rajkumar,
2021).
4
Dynamic testing can be performed in different ways, white box testing and black box
testing. White box testing is when you test how the program is performing based on
the code and requires that you are familiar with the code or internal structure of the
program. Black box testing is when you test the functionality of the program without
knowing the internal structure of the program (Rajkumar, 2021).
There are two different techniques when it comes to dynamic testing, functional and
non-functional testing as shown in the image in section R8. Functional testing is used
to verify that each function of the program is working according to the requirements,
that is you test what the system actually does. Non-functional testing is used to
improve the user experience and how fast the program responds to a request
(Rajkumar, 2021).
What I have learned from reading more about these two forms of testing processes is
that both are needed and you should start testing early in the development process.
This will reduce costs for the business as well eliminate many errors later in the
process and therefore reduce the amount of testing needed as you advance through
the development process. This will make the testing process more efficient and also if
you wait too long to start testing it will get more and more complicated.
Website to learn more about Static testing from TechTarget:
https://www.techtarget.com/searchsoftwarequality/definition/static-testing
Website to learn more aboutDynamic testing from STM Software Testing Material
https://www.softwaretestingmaterial.com/dynamic-testing/
5
R8 - Find one Google Image
Image 2. Static testing and dynamic testing
Source: https://softwaretestingfundamentals.com/static-testing-vs-dynamic-testing/
R9 -Reflections about the course book chapter
material
Reflections on chapter one to four in the course book, “Praktisk Mjukvarutestning” by
Eva Holmquist.
Chapter 1:
Testing is all the activities that take place to see how well a system fulfills the
requirements from both users and stakeholders.
Testing consists of two parts. Dynamic testing is when you run the system and the
tester is using the system to find errors. The other one is Static testing where you do
not run the system instead you can use two different methods of static testing.
Review is when you manually are looking for errors and it can involve analysis and
calculations to find errors. Static analysis is when you analyze code, models or
documentation to find errors or possible errors. You can use different tools for this
type of testing. The course book also talks about meeting the requirements for the
system, verification and to meet the business needs, validation.
6
My own reflections about this chapter: In chapter one Eva Holmquis writes about
how to measure the quality of a system. The number of errors found during the
testing is correlated to the amount of testing that has occurred during the
development process. I found this interesting because often the higher amount of
errors found should be an indication of less quality. But here the testing is important
since this will discover the errors and make the quality higher since the errors are
solved. Less testing will result with unknown errors that will decrease the quality of
the system. Therefore it is not the number of errors in code that is important but it is
important to find them through testing and “make them go away”.
The question that I think would be interesting to talk about in the Live Group Session
is why organizations choose to test their system? What are the benefits?
Chapter 2:
In this chapter we learn about formal requirements and they can be requirements
from customers, authorities and laws. The book also talks about the importance of
coordinating the work when multiple teams work on a system. Multiple teams are
necessary when there are large and complex systems because they can work in
parallel and simultaneously. Multiple teams can lead to less efficiency if the work is
not coordinated properly.
There are both mature and immature systems according to the course book and in an
immature system the knowledge of the requirement s and functionality of the system
may be limited and there is a risk that the system might not meet the requirements of
the business and this might have an impact on the quality of the system, Errors might
occur in the requirements, architecture and code. In the mature system basically
everything is in place and the system is up and running and the team can focus
mainly on production problems.
My own reflections about this chapter: Chapter two there is a section that talks
about the customers and sometimes they do not require a system that is perfect.
They can accept smaller errors in the code if the support is good for the system. This
made me consider what type of customer I would be and to be honest I would not
accept a system with errors in them regardless of the support provided. I believe in
high quality and would probably be too impatient to wait for something to get fixed.
But I do understand that there is an expense to thorough testing and that there are
often dead-lines that should be met and not everything can be perfect. I think that this
subject would be interesting to discuss during a live group session.
7
Chapter 3:
Chapter three is about organizing the testing. There are different roles in the testing
process, one of them is the test leader that is responsible for documenting the
process and informing about the quality, plan and to lead the testing process. There
is also the tester and everyone can have a testing role in the organization but then
you have the title of tester that means that you perform testing activities.
Independent testing and they are beneficial because you can get access to
specialized knowledge and therefore more types of error can be found. Independent
testing can also be required if the testing or system needs to follow a particular
standard. The disadvantages of independent testing can be that there might occur
communication problems and it can be less efficient if there are not enough
independent testers.
My own reflections about this chapter: There is definitely a need for structure and
planning when it comes to work with multiple teams. I believe that roles are important
so that everyone knows their responsibilities. Otherwise it can lead to assignments
that are missed due to someone thinking it was the other one's job. To have a test
leader that plans and leads the testing process can help to avoid communication
problems and therefore it minimizes the risk of missing important aspects of the
testing process. The question I would like to talk about in the Live Group Session is,
Why is it important to have a test leader and what does a test leader do?
Chapter 4:
There is nothing called complete testing since the different testing options are infinite,
this means that you have to prioritize the testing. There is no way to show that a
system is free of error, you can show that there is an error through testing but not
show that there are no errors according to the book. The amount of testing is not
important, it is that you test the right things that are important. There is a need to do
risk based testing to determine which test should be done and what should be
prioritized. There is also a need to do continuous testing because errors can occur
over time as the system is developed. It is important to start testing early in the
development process because you want to find errors early in the process since it
can be more costly to correct them later. Calendar Time is something that is
important since not every test can be done in parallel and sometimes tests cannot be
performed early in the development and then it may take longer to complete them.
My own reflections about this chapter: There is the question of quality of the
system and the question is how to determine the quality of the system. The number
of tests needed to reduce as many errors that you can or is it the right tests at the
8
right time that is important. This continues from the reflection of chapter one where
we saw that the number of errors found and the amounts of testing correlates to each
other. But the amount of testing will not directly improve the quality of the system
since it is important for quality that you test the right thing. Running many tests on the
wrong thing and leaving out important parts of the system will lead to errors not found
in the system and therefore will not lead to improved quality.
The question I would like to talk about in the Group Live Session is why can’t the test
time be calculated based on development time? My answer would be that the tests
continue after the development. Some tests need a completed system or completed
parts of the system before they can be performed.
R10 - Reflections about any other weekly activities,
including hands-on labs
This week I created a test program in JUnit5 that tests the methods in a simple
calculator.
helcas/Junit5_Calculator: JUnit5 test week 2 (github.com)
I created a simple Calculator with methods for different calculations. I created a test
for each of the methods with two different scenarios. I also created a repository on
GitHub and practiced commit and push to the repository.
Image 3. JUnit5 Calculator Test, Calculator Class
9
Image 4. JUnit5 Calculator Test, Calculate Class
Image 5. JUnit5 Calculator Test, CalculatorTest Class
10
R11 - Reflections about one related topic
I wanted to learn more about performance testing this week. Performance testing is a
non-functional testing technique that tests the stability, speed, scalability,and
responsiveness of a system against a given workload (Micro Focus, 2022). It is an
important step in ensuring the system’s quality and goal is to evaluate the
performance of the system for example processing speed, data transfer velocity,
maximum number of users (Micro Focus, 2022).
The testing process involves identifying the tools and defining acceptable
performance criteria,plan the tests, run the tests and resolve and retest (Micro Focus,
2022).
This is a test that according to Micro Focus (2022) may be overlooked and seen as
an afterthought when the code is ready to be released. According to Paessler (2022)
the performance test should start early in the development process even before the
code is written. This is important when you develop web applications.You start by
doing performance tests on the base technology such as the network, application
database and web servers. This is done to make sure that your hardware
configuration is accurate before deploying your application (Paessler, 2022).
R12 - Review of academic trends and knowledge
This week I looked for articles related to white box testing and black box testing and I
found one article about the tools that you can use for White box testing.
According to Dilara & Alok (2019) “White box testing is one of the most important and
prevalent software techniques and is very effective in validating design, decision,
assumptions and finding programming errors and implementation errors in software.”
There are several testing tools available and they have different features and
attributes (Dilara & Alok, 2019). Some of the tools mentioned in the article are JUnit
which we are learning in this course. SeleniumHQ which supports several languages
such as Java, C#, Python and Ruby. Windmill, a software testing framework for web
applications, and supports languages such as Python, Javascript and Ruby (Dilara &
Alok, 2019). There are many more tools mentioned in the report, all of them have
different language support and features.
The article also talks about different types of testing, and one of them is the branch
coverage which covers every option with true and false value, and it controls every
statement. This method makes sure that each piece of code (branch) is tested at
least one and that there will be no untouched code (Dilara & Alok, 2019).
11
R13 - Review of next week’s list of activities
Next week we will continue to read chapters in the course book and we will cover
chapters five to nine. I believe that I understand what to do next week.
References
Dilara, A. &, Alok, M. (2019) White Box Test Tools: A Comparative View. International
Journal on Information Technologies & Security, 3 (11), p.79-90
https://ijits-bg.com/contents/IJITS-No3-2019/2019-N3-08.pdf
Gillis, A (2020, Sept) Static Testing. TechTarget
https://www.techtarget.com/searchsoftwarequality/definition/static-testing
Micro Focus (2022, n.d.) What is Performance Testing?
https://www.microfocus.com/en-us/what-is/performance-testing
Paessler (2022, n.d.) When should I start Performance Testing?
https://www.paessler.com/manuals/webserver_stress_tool/whenshouldistartperforma
ncetesting#:~:text=As%20soon%20as%20several%20web,each%20build%20of%20t
he%20software.
Rajkumar (2021, Sept 20) What is Dynamic Testing? How to Perform Dynamic
Testing? STM Software Testing Material
https://www.softwaretestingmaterial.com/dynamic-testing/
12
