testing

Question 1

process where developers write automated test cases before writing the actual code for their software.

Answer 1

Test-driven development (TDD)

Question 2

In TDD, the development process is broken down into ——–, iterative steps.

Answer 2

small

Question 3

First, a ——- is written that describes the ——– behavior of the code to be written. Then, the developer writes the code that ——– the test. If the code passes the test, the developer moves on to the ————-, writing another test for a new behavior, and then writing code to satisfy that test.

Answer 3

test
desired
satisfies
next iteration

Question 4

Benefits of TDD
1.Early ——- detection.
2. ——— code quality
3. ———–development time

Answer 4

bug
Improved
Reduced

Question 5

testing of the smallest testable units of code (for Java, this will be methods). and ensures that everything is running as it should

Answer 5

unit testing

Question 6

Generally, tests can be ———— or ————- tests and you should have both.

Answer 6

positive
negative

Question 7

with ———— tests give an we give an expected/valid input and check to see if the expected return occurs.

Answer 7

positive

Question 8

with ————- tests we take an invalid/unexpected input and see if your code handles it correctly.

Answer 8

negative

Question 9

a testing framework that provides annotations and methods for creating unit tests.

Answer 9

JUnit

Question 10

used to record application events, log debugging information for developers, and write exception events to files.

Answer 10

What is logging

Question 11

first steps for TDD.
TDD involves writing ——— tests first,
then writing the ———- amount of code necessary to pass the test,
then ———- the code.
finally the process is ————- until all of the desired functionality is implemented.

Answer 11

failing
minimum
refactoring
repeated

Question 12

disadvantages of TDD

Answer 12

Forget to run tests frequently
Write too many tests at once
Write tests that are too large

Question 13

Do all projects need to be tested before going live? If not, then when should testing be skipped?

Answer 13

yes, all projects need to be tested before going live.

Question 14

This is an important part of software development, it allows developers to preserve knowledge that that can be transferred to new developers. it also makes the code base easier to read, understand and maintain, and it’s a reference new developers can look at to understand the codebase and how the code works.

Answer 14

what is developer documentation

Question 15

————- coverage is used to test how many lines of code is being executed by tests, and can help highlighting areas of code that are not being adequately covered.

————— coverage is used to make sure that all the aspects of the software is adequately tested and measures the percentage of requirements.

Answer 15

code

Test

Question 16

What is more important: code coverage or test coverage? Explain your answer.

Answer 16

Both. code coverage and test coverage are important in different ways.

Question 17

Is it necessary to follow each step in the TDD process? What happens if we skip a step?

Answer 17

no it is not necessary but skipping a step can lead to bugs and errors that are avoidable.

Question 18

What’s the difference between manual and automated testing?

——– testing involves human testers executing test cases and checking to make sure that the software’s behavior matches the expected behavior

———– testing is done buy a computer
——– testing is good large and complex systems
—– testing is good for making sure the users needs are met by the software.

Answer 18

Manual
automatic
automatic
manual

Question 19

What’s the difference between functional and non-functional testing?

————– testing focuses on the functional requirements which is making sure the software works as expected and meets user requirements while

———– testing is used to check the non-functional requirements.

Functional testing typically involves testing the software’s ——- and output, data validation and examples include unit testing and acceptance testing. Non-functional testing typically involves testing the software’s performance, reliability, and accessibility and examples include load testing and security testing.

Answer 19

Functional

non-functional

Question 20

Functional testing typically involves testing the software’s ——- and —–, data validation and examples include ——- testing and acceptance testing.

Non-functional testing typically involves testing the software’s ———, reliability, and accessibility and examples include ——– testing and security testing.

Answer 20

input
output
unit
performance
load

Question 21

JUnit achieves the isolation of tests through several mechanisms:

————— = methods that set up the test environment before each test case is run.

—————- = classes that execute test cases and report the results.

—————— = used to compare expected and actual results in a test case.

————— = objects that simulate the behavior of a real object, and can be used to test code that depends on that object.

Answer 21

Test fixtures
Test runners
Assertion methods
Mock objects

Question 22

How do you check if a test method throws Exception in JUnit?

Answer 22

@Test annotation and the assertThrows() method.

Question 23

What are some best practices you follow while writing code to make it more testable?

1).Write ——-, focused methods:
2.)Write code that is easy to ——:
3.) Use ——– to abstract away implementation details.
4.)Write ——– code from the start:

Answer 23

small
understand
interfaces
testable

Question 24

What is the difference between Stub and Mock in Unit testing?

——— are simpler and are used to verify the behavior of the class being tested.

———— more complex and a more powerful way to verify the behavior or the class being tested.

——- designed to mimic the behavior of dependencies

———- provide controlled input to the class being tested.

Answer 24

stub
mock
mock
stub

Question 25

To test a protected method using JUnit, you can either create a ---------- that exposes the method or use -------- to access the method directly.

Answer 25

subclass reflection

Question 26

--------------- is a feature in Java that allows a program to examine and modify the behavior of objects at runtime.

Answer 26

reflection

Question 27

private methods are only accessible within the same class, so you -------- directly test a private method using JUnit. One approach is to use the ------------- annotation to make the private method visible to the test class. This annotation is not part of the standard Java library, but it is provided by some libraries such as Guava.

Answer 27

cannot @VisibleForTesting

Question 28

JUnit test classes should be placed in the same ------- and directory structure as the ------- code classes they are testing.

Answer 28

package package

Question 29

What is the difference between JUnit 4 and JUnit 5? JUnit5 instroduced assertion methods that are more flexible like the assertAll() method and the assertThrows() method. JUnit 4 had teests organized in test classes that contained test methods annotateed w/@test JUnit 5 allowed tests to be organized in nested test classes and allows annotations such as @BeforeEach, and @AfterEach.

Answer 29

Programming model: JUnit 4 uses a class-based programming model, where tests are organized in test classes that contain test methods annotated with @Test. JUnit 5 introduces a new programming model that allows tests to be organized in nested test classes, and uses annotations such as @BeforeEach, @AfterEach, @BeforeAll, and @AfterAll to define setup and teardown behavior. Extensions: JUnit 5 introduces a powerful extension model that allows developers to extend and customize the behavior of the framework. Extensions can be used to add new annotations, modify the test execution order, provide dependency injection, and more. JUnit 4 also supports extensions, but they are more limited in scope. Platform: JUnit 5 is designed to be more modular and flexible than JUnit 4, and provides a new platform that separates the core framework from the test engine and the IDE integration. This allows developers to use JUnit 5 with different build tools, test runners, and IDEs, and to run tests on different platforms and environments. Assertions: JUnit 5 introduces a new set of assertion methods that are more expressive and flexible than the ones in JUnit 4. The new assertAll() method allows multiple assertions to be grouped together, and the assertThrows() method provides a convenient way to test for exceptions.