The Programmer's Guide
  • About
  • Algorithm
    • Big O Notation
      • Tree
      • Problems
    • Basic Notes
    • Data Structure Implementation
      • Custom LinkedList
      • Custom Stack
      • Custom Queue
      • Custom Tree
        • Binary Tree Implementation
        • Binary Search Tree Implementation
        • Min Heap Implementation
        • Max Heap Implementation
        • Trie Implementation
      • Custom Graph
        • Adjacency List
        • Adjacency Matrix
        • Edge List
        • Bidirectional Search
    • Mathematical Algorithms
      • Problems - Set 1
      • Problems - Set 2
    • Bit Manipulation
      • Representation
      • Truth Tables
      • Number System
        • Java Program
      • Problems - Set 1
    • Searching
    • Sorting
    • Array Algorithms
    • String Algorithms
    • Tree
      • Tree Traversal Techniques
      • Tree Implementation
      • Applications of Trees
      • Problems - Set 1
    • Graph
      • Graph Traversal Techniques
      • Shortest Path Algorithms
      • Minimum Spanning Tree (MST) Algorithms
    • Dynamic Programming
      • Problems - Set 1
    • Recursion
    • Parallel Programming
    • Miscellaneous
      • Problems - Set 1
  • API
    • API Basics
      • What is an API?
      • Types of API
        • Comparison - TBU
      • Synchronous vs Asynchronous API
    • API Architecture
      • Synchronous & Asynchronous Communication
    • API Specification
  • Cloud Computing
    • Cloud Fundamentals
      • Cloud Terminology
      • Core Terminology
      • Cloud Models
      • Cloud Service Models
      • Benefits, Challenges and Risk of Cloud Computing
      • Cloud Ecosystem
  • Database
    • DBMS
      • Types of DBMS
        • Relational DBMS (RDBMS)
        • NoSQL DBMS
        • Object-Oriented DBMS (OODBMS)
        • Columnar DBMS
        • In-Memory DBMS
        • Distributed DBMS
        • Cloud-Based DBMS
        • Hierarchical DBMS
      • DBMS Architecture
      • DBMS Structure
    • SQL Databases
      • Terminology
      • RDBMS Concepts
        • Entity Relationship Diagram (ERD)
          • ERD Examples
        • Normalization
        • Denormalization
        • ACID & BASE Properties
          • ACID Properties
          • BASE Properties
        • Locking and Unlocking
      • SQL Fundamentals
        • SQL Commands
          • DDL (Data Definition Language)
          • DML (Data Manipulation Language)
          • DCL (Data Control Language)
          • TCL (Transaction Control Language)
          • DQL (Data Query Language)
        • SQL Operators
          • INTERSECT
          • EXCEPT
          • MINUS
          • IN and NOT IN
          • EXISTS and NOT EXISTS
        • SQL Clauses
          • Joins
          • OVER
          • WITH
          • CONNECT BY
          • MODEL
          • FETCH FIRST
          • KEEP
          • OFFSET with FETCH
        • SQL Functions
          • Oracle Specific
        • SQL Data Types
          • Numeric Types
          • Character Types
          • Date & Time Types
          • Large Object Types
        • Others
          • Indexing
      • Vendor Specific Concepts
        • Oracle Specific
          • Data Types
          • Character Set
          • Rownum, Rowid, Urowid
          • Order of Execution of the query
          • Keys
          • Tablespace
          • Partition
      • Best Practice
      • Resources & References
        • O’Reilly SQL Cookbook (2nd Edition)
          • 1. Retrieving Records
          • 2. Sorting Query Results
          • 3. Working with Multiple Tables
          • 4. Inserting, Updating, and Deleting
          • 5. Metadata Queries
          • 6. Working with Strings
          • 7. Working with Numbers
          • 8. Date Arithmetic
          • 9. Date Manipulation
          • 10. Working with Ranges
          • 11. Advanced Searching
          • 12. Reporting and Reshaping
          • 13. Hierarchical Queries
          • 14. Odds 'n' Ends
    • SQL vs NoSQL
    • Best Practices
  • Git
    • Commands
      • Setup and Configuration Commands
      • Getting and Creating Projects
      • Tracking Changes
      • Branching and Merging
      • Sharing and Updating Projects
      • Inspection and Comparison
      • Debugging
      • Patching
      • Stashing and Cleaning
      • Advanced Manipulations
    • Workflows
      • Branching Strategies
        • Git Flow
        • Trunk-Based Development
        • GitHub Flow
        • Comparison
      • Merge Strategies
        • Merge
        • Rebase
        • Squash
        • Fast-forward vs No-fast-forward
        • MR vs PR
      • Conflict Resolution
        • Handling Merge Conflicts
        • Merge Conflicts
        • Rebase Conflicts
        • Divergent Branches After git pull
        • Force Push
      • Patch & Recovery
        • Cherry-pick strategies
        • Revert vs Reset
        • Recover from a bad rebase
      • Rebasing Practices
        • Merge vs Rebase
        • Rebase develop branch on main branch
      • Repository Management
        • Working Directory
        • Mirror a repository
        • Convert a local folder to a Git repo
        • Backup and restore a Git repository
  • Java
    • Java Installation
    • Java Distributions
    • Java Platform Editions
      • Java SE
      • Java EE
      • Jakarta EE
      • Java ME
      • JavaFX
    • Java Overview
      • OOP Principles
        • Encapsulation
        • Inheritance
        • Polymorphism
        • Abstraction
          • Abstract Class & Method
          • Interface
            • Functional Interfaces
            • Marker Interfaces
          • Abstract Class vs Interface
      • OOP Basics
        • What is a Class?
          • Types of Classes
        • What is an Object?
          • Equals and HashCode
            • FAQ
          • Shallow Copy and Deep Copy
          • Ways to Create Object
          • Serialization & Deserialization
        • Methods & Fields
          • Method Overriding & Overloading
          • Method Signature & Header
          • Variables
        • Constructors
        • Access Modifiers
      • Parallelism & Concurrency
        • Ways to Identify Thread Concurrency or Parallelism
        • Thread Basics
          • Thread vs Process
          • Creating Threads
          • Thread Context Switching
          • Thread Lifecycle & States
          • Runnable & Callable
          • Types of Threads
          • Thread Priority
        • Thread Management & Synchronisation
          • Thread Resource Sharing
          • Thread Synchronization
            • Why is Synchronization Needed?
            • Synchronized Blocks & Methods
          • Thread Lock
            • Types of Locks
            • Intrinsic Lock (Monitor Lock)
            • Reentrant Lock
          • Semaphore
          • Thread Starvation
          • Thread Contention
          • Thread Deadlock
          • Best Practices for Avoiding Thread Issues
      • Keywords
        • this
        • super
        • Access Modifiers
      • Data Types
        • Default Values
        • Primitive Types
          • byte
          • short
          • int
          • long
          • float
          • double
          • char
          • boolean
        • Non-Primitive (Reference) Types
          • String
            • StringBuilder
            • StringBuffer
              • Problems
            • Multiline String
            • Comparison - String, StringBuilder & StringBuffer
          • Array
          • Collections
            • List
              • Array vs List
              • ArrayList
              • Vector
                • Stack
                  • Problems
              • LinkedList
            • Queue
              • PriorityQueue
              • Deque (Double-Ended Queue)
                • ArrayDeque
                • ConcurrentLinkedDeque - TBU
                • LinkedBlockingDeque - TBU
            • Map
              • HashMap
              • Hashtable
              • LinkedHashMap
              • ConcurrentHashMap
              • TreeMap
              • EnumMap
              • WeakHashMap
            • Set
              • HashSet
              • LinkedHashSet
              • TreeSet
              • EnumSet
              • ConcurrentSkipListSet
              • CopyOnWriteArraySet
        • Specialized Classes
          • BigInteger
          • BigDecimal
            • Examples
          • BitSet
          • Date and Time
            • Examples
          • Optional
          • Math
          • UUID
          • Scanner
          • Formatter
            • Examples
          • Properties
          • Regex (Pattern and Matcher)
            • Examples
          • Atomic Classes
          • Random
          • Format
            • NumberFormat
            • DateFormat
            • DecimalFormat
        • Others
          • Object
          • Enum
            • Pre-Defined Enum
            • Custom Enum
            • EnumSet and EnumMap
          • Record
          • Optional
          • System
          • Runtime
          • ProcessBuilder
          • Class
          • Void
          • Throwable
            • Error
            • Exception
              • Custom Exception Handling
              • Best Practice
            • Error vs Exception
            • StackTraceElement
    • Java Features by Version
      • How New Java Features are Released ?
      • Java Versions
        • Java 8
        • Java 9
        • Scoped Values
        • Unnamed Variables & Patterns
      • FAQ
    • Concepts
      • Set 1
        • Streams
          • flatmap
          • Collectors Utility Class
          • Problems
        • Functional Interfaces
          • Standard Built-In Interfaces
          • Custom Interfaces
        • Annotation
          • Custom Annotation
          • Meta Annotation
        • Generics
          • Covariance and Invariance
        • Asynchronous Computation
          • Future
          • CompletableFuture
          • Future v/s CompletableFuture
          • ExecutorService
            • Thread Pool
            • Types of Work Queues
            • Rejection Policies
            • ExecutorService Implementations
            • ExecutorService Usage
          • Locks, Atomic Variables, CountDownLatch, CyclicBarrier - TBU
          • Parallel Streams, Fork/Join Framework,Stream API with Parallelism - TBU
      • Set 2
        • Standards
          • ISO Standards
          • JSR
            • JSR 303, 349, 380 (Bean Validation)
        • Operator Precedence
      • Set 3
        • Date Time Formatter
        • Validation
      • Set 4
        • Input from User
        • Comparison & Ordering
          • Object Equality Check
          • Comparable and Comparator
            • Comparator Interface
          • Sorting of Objects
          • Insertion Ordering
    • Packages
      • Core Packages
        • java.lang
          • java.lang.System
          • java.lang.Thread
      • Jakarta Packages
        • jakarta.validation
        • javax.validation
      • Third-party Packages
    • Code Troubleshoot
      • Thread Dump
      • Heap Dump
    • Code Quality & Analysis
      • ArchUnit
      • Terminologies
        • Cyclic dependencies
    • Code Style
      • Naming Convention
      • Package Structure
      • Formatting
      • Comments and Documentation
      • Imports
      • Exception Handling
      • Class Structure
      • Method Guidelines
      • Page 1
      • Code Smells to Avoid
      • Lambdas and Streams Style
      • Tools
    • Tools
      • IntelliJ IDEA
        • Shortcuts for MAC
      • Apache JMeter
        • Examples
      • Thread Dump Capture
        • jstack
        • VisualVM - TBU
        • jcmd - TBU
        • JConsole - TBU
        • YourKit Java Profiler - TBU
        • Eclipse MAT - TBU
        • IntelliJ IDEA Profiler - TBU
        • AppDynamics - TBU
        • Dynatrace - TBU
        • Thread Dump Analyzers - TBU
      • Heap Dump Capture
        • jmap
        • VisualVM - TBU
        • jcmd - TBU
        • Eclipse MAT (Memory Analyzer Tool) - TBU
        • IntelliJ IDEA Profiler - TBU
        • YourKit Java Profiler - TBU
        • AppDynamics - TBU
        • Dynatrace - TBU
        • Kill -3 Command - TBU
        • jhat (Java Heap Analysis Tool) - TBU
        • JVM Options - TBU
      • Wireshark
        • Search Filters
    • Best Practices
      • Artifact and BOM Versioning
  • Maven
    • Installation
    • Local Repository & Configuration
    • Command-line Options
    • Build & Lifecycle
    • Dependency Management
      • Dependency
        • Transitive Dependency
        • Optional Dependency
      • Dependency Scope
        • Maven Lifecycle and Dependency Scope
      • Dependency Exclusions & Overrides
      • Bill of Materials (BOM)
      • Dependency Conflict Resolution
      • Dependency Tree & Analysis
      • Dependency Versioning Strategies
    • Plugins
      • Build Lifecycle Management
      • Dependency Management
      • Code Quality and Analysis
      • Documentation Generation
      • Code Generation
      • Packaging and Deployment
      • Reporting
      • Integration and Testing
      • Customization and Enhancement
        • build-helper-maven-plugin
        • properties-maven-plugin
        • ant-run plugin
        • exec-maven-plugin
        • gmavenplus-plugin
      • Performance Optimization
    • FAQs
      • Fixing Maven SSL Issues: Unable to Find Valid Certification Path
  • Spring
    • Spring Basics
      • What is Spring?
      • Why Use Spring
      • Spring Ecosystem
      • Versioning
      • Setting Up a Spring Project
    • Core Concepts
      • Spring Core
        • Dependency Injection (DI)
        • Stereotype Annotation
      • Spring Beans
        • Bean Lifecycle
        • Bean Scope
          • Singleton Bean
        • Lazy & Eager Initialization
          • Use Case of Lazy Initialization
        • BeanFactory
        • ApplicationContext
      • Spring Annotations
        • Spring Boot Specific
        • Controller Layer (Web & REST Controllers)
    • Spring Features
      • Auto Configuration
        • Spring Boot 2: spring.factories
        • Spring Boot 3: spring.factories
      • Spring Caching
        • In-Memory Caching
      • Spring AOP
        • Before Advice
        • After Returning Advice
        • After Throwing Advice
        • After (finally) Advice
        • Around Advice
      • Spring File Handling
      • Reactive Programming
        • Reactive System
        • Reactive Stream Specification
        • Project Reactor
          • Mono & Flux
      • Asynchronous Computation
        • @Async annotation
      • Spring Security
        • Authentication
          • Core Components
            • Security Filter Chain
              • HttpSecurity
              • Example
            • AuthenticationManager
            • AuthenticationProvider
            • UserDetailsService
              • UserDetails
              • PasswordEncoder
            • SecurityContext
            • SecurityContextHolder
            • GrantedAuthority
            • Security Configuration (Spring Security DSL)
          • Authentication Models
            • One-Way Authentication
            • Mutual Authentication
          • Authentication Mechanism
            • Basic Authentication
            • Form-Based Authentication
            • Token-Based Authentication (JWT)
            • OAuth2 Authentication
            • Multi-Factor Authentication (MFA)
            • SAML Authentication
            • X.509 Certificate Authentication
            • API Key Authentication
            • Remember-Me Authentication
            • Custom Authentication
          • Logout Handling
        • Authorization
        • Security Filters and Interceptors
        • CSRF
          • Real-World CSRF Attacks & Prevention
        • CORS
        • Session Management and Security
        • Best Practices
      • Spring Persistence
        • JDBC
          • JDBC Components
          • JDBC Template
          • Transaction Management
          • Best Practices in JDBC Usage
          • Datasource
            • Connection Pooling
              • HikariCP
            • Caching
        • JPA (Java Persistence API)
          • JPA Fundamentals
          • ORM Mapping Annotations
            • 1. Entity and Table Mappings
            • 2. Field/Column Mappings
            • 3. Relationship Mappings
            • 4. Inheritance Mappings
            • 5. Additional Configuration Annotations
          • Querying Data
            • JPQL
            • Criteria API
            • JPA Specification
              • Example - Employee Portal
            • Native SQL Queries
            • Named Queries
            • Query Return Types
            • Pagination & Sorting
              • Example - Employee Portal
            • Projection
          • Fetch Strategies in JPA
        • JPA Implementation
          • Hibernate
            • Properties
            • Example
        • Spring Data JPA
          • Repository Abstractions
          • Entity-to-Table Mapping
          • Derived Query Methods
        • Cross-Cutting Concerns
          • Transactions
          • Caching
          • Concurrency
        • Examples
          • Employee Portal
            • API
    • Distributed Systems & Communication
      • Distributed Scheduling
      • Inter-Service Communication
        • 1. RestTemplate
        • 2. WebClient
        • 3. OpenFeign
        • Retry Mechanism
          • @Retryable annotation
            • Example
    • Security & Data Protection
      • Encoding | Decoding
        • Types
          • Base Encoding
            • Base16 - TBD
              • Encoding and Decoding in Java - TBD
            • Base32
              • Encoding and Decoding in Java
            • Base64 -TBD
              • Encoding and Decoding in Java - TBD
          • Text Encoding - TBD
            • Extended ASCII
              • Encoding and Decoding in Java - TBD
                • ISO-8859-1
                • Windows-1252 - TBD
                • IBM Code Pages - TBD
            • ASCII
              • Encoding and Decoding in Java
        • Java Guidelines
          • Text Encoding Decoding Examples
          • Base Encoding Decoding Examples
          • Best Practices and Concepts
          • Libraries
      • Cryptography
        • Terminology
        • Java Cryptography Architecture (JCA)
        • Key Management
          • Key Generation
            • Tools and Libraries
              • OpenSSL
              • Java Keytool
                • Concept
                • Use Cases
            • Key & Certificate File Formats
          • Key Distribution
          • Key Storage
          • Key Rotation
          • Key Revocation
        • Encryption & Decryption
          • Symmetric Encryption
            • Algorithm
            • Modes of Operation
            • Examples
          • Asymmetric Encryption
            • Algorithm
            • Mode of Operation
            • Examples
    • Utilities & Libraries
      • Apache Libraries
        • Apache Camel
          • Camel Architecture
            • Camel Context
            • Camel Endpoints
            • Camel Components
            • Camel Exchange & MEP
          • Spring Dependency
          • Different Components
            • Camel SFTP
        • Apache Commons Lang
      • MapStruct Mapper
      • Utilities by Spring framework
        • FileCopyUtils
    • General Concepts
      • Spring Boot Artifact Packaging
      • Classpath and Resource Loading
      • Configuration - Mapping Properties to Java Class
      • Validations in Spring Framework
        • Jakarta Validation
          • Jakarta Bean Validation Annotations
    • Practical Guidelines
      • Spring Configuration
      • Spring Code Design
  • Software Testing
    • Software Testing Methodologies
      • Functional Testing
      • Non Functional Testing
    • Software Testing Life Cycle (STLC)
    • Integration Test
      • Dynamic Property Registration
    • Java Test Framework
      • JUnit
        • JUnit 4
          • Examples
        • JUnit 5
          • Examples
        • JUnit 4 vs JUnit 5
  • System Design
    • Foundations
      • Programming Paradigms
      • Object-Oriented Design
        • SOLID Principles
        • GRASP Principles
        • Composition
        • Aggregation
        • Association
      • Design Pattern
        • Creational Pattern
        • Structural Pattern
        • Behavioral Pattern
        • Examples
          • Data Collector
          • Payment Processor
        • Design Enhancements
          • Fluent API Design
            • Examples
    • Architectural Building Blocks
      • CAP Theorem
      • Load Balancer
        • Load Balancer Architecture
        • Load Balancing in Java Microservices
          • Client-Side Load Balancing Example
          • Server-Side Load Balancing Example
        • Load Balancer Monitoring Tool
      • Scaling
        • Vertical Scaling (Scaling Up)
        • Horizontal Scaling (Scaling Out)
        • Auto-Scaling
        • Database Scaling via Sharding
      • Caching
        • Pod-Level vs Distributed Caching
      • Networking Metrics
        • Types of Delay
        • Scenario
      • System Characteristics
      • Workload Types
      • Resilience & Failure Handling
    • Performance
      • Why Is My API Sometimes Slow ?
    • Security
      • Security by Design
      • Zero Trust Security Model
      • Zero Trust Architecture
      • Principles
        • CIA
        • Least Privilege Principle
        • Defense in Depth
      • Security Threats & Mitigations
        • OWASP
          • Top 10 Security Threats
          • Application Security Verification Standard
          • Software Assurance Maturity Model
          • Dependency Check
          • CSRFGuard
          • Cheat Sheets
          • Security Testing Guide
          • Threat Dragon
        • Threat Modeling
      • Compliance & Regulation
        • PCI DSS
    • Deployment Patterns
    • Diagrams
      • UML Diagrams
        • PlantUML
          • Class Diagram
          • Object Diagram
          • Sequence Diagram
          • Use Case Diagram
          • Activity Diagram
          • State Diagram
          • Architecture Diagram
          • Component Diagram
          • Timing Diagram
          • ER Diagram (Entity-Relationship)
          • Network Diagram
    • Common Terminologies
    • Problems
      • Reference Materials
      • Cache Design
  • Interview Guide
    • Non-Technical
      • Behavioural or Introductory Guide
      • Project Specific
    • Technical
      • Java Interview Companion
        • Java Key Concepts
          • Set 1
          • Set 2
        • Java Code Snippets
        • Java Practice Programs
          • Set 3 - Strings
          • Set 4 - Search
          • Set 5 - Streams and Collection
      • SQL Interview Companion
        • SQL Practice Problems
          • Set 1
      • Spring Interview Companion
        • Spring Key Concepts
          • Set 1 - General
          • Set 2 - Core Spring
        • Spring Code Snippets
          • JPA
      • Application Server
      • Maven
      • Containerized Application
      • Microservices
    • General
      • Applicant Tracking System (ATS)
      • Flowchart - How to Solve Coding Problem?
Powered by GitBook
On this page
  • About
  • Core Concepts
  • Integration with Maven
  • POM Dependency
  • JUnit 4 Maven Plugin (Optional)
  • Package org.junit Details
  • Annotations in org.junit
  • Test Annotations
  • Setup and Teardown Annotations
  • Exception and Timeout Annotations
  • Ignoring Tests
  • Parameterized Tests Annotations
  • Rule Annotations
  • Category Annotations
  • Test Order Annotations
  • Custom Runner Annotations
  • Classes in org.junit
  • Assume
  • AssumptionViolatedException
  • ComparisonFailure
  • Assert
  • Packages in org.junit
  • org.junit.runners
  • org.junit.matchers
  • org.junit.runner
  • org.junit.validator
  • org.junit.rules

Was this helpful?

  1. Software Testing
  2. Java Test Framework
  3. JUnit

JUnit 4

About

JUnit 4, released in 2006, is a popular and widely used version of the JUnit testing framework for Java applications. It introduced annotations to streamline unit test development, making it more efficient and easier to understand compared to JUnit 3.x.

Core Concepts

  • Annotations: JUnit 4 relies heavily on annotations to define test methods (@Test), set up/tear down logic (@Before, @After), and manage test execution lifecycle (@BeforeClass, @AfterClass).

  • Test Runners: JUnit integrates with test runners like the built-in JUnit Runner or Maven Surefire plugin to execute and report test results.

  • Assertions: It provides assertions (like assertEquals, assertTrue) to verify expected outcomes within test methods.

  • Test Suites: JUnit allows grouping related tests into suites for better organization and execution control.

Integration with Maven

POM Dependency

Add the following dependencies to pom.xml

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

JUnit 4 Maven Plugin (Optional)

The JUnit 4 functionality is generally included with the Maven Surefire plugin, which is responsible for executing tests during the Maven build lifecycle. So, adding the Surefire plugin is usually not necessary for basic JUnit 4 usage.

However, if we want more advanced functionalities like custom test listeners or reports, we can optionally include the Surefire plugin in the pom.xml.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>3.0.0-M5</version>  
  <configuration></configuration>
</plugin>

Package org.junit Details

Annotations in org.junit

JUnit 4 introduced a variety of annotations to simplify test creation and management. org.junit provides core JUnit 4 annotations. Here is a list of JUnit 4 annotations categorized by their functionality.

Test Annotations

@Test: Marks a method as a test method. This is the primary annotation to indicate that a method is a test.

Setup and Teardown Annotations

  • @Before: Executes a method before each test method in the current class. Used for setting up test environments.

  • @After: Executes a method after each test method in the current class. Used for cleaning up after tests.

  • @BeforeClass: Executes a method once before any test methods in the current class. This method must be static.

  • @AfterClass: Executes a method once after all test methods in the current class. This method must be static.

Exception and Timeout Annotations

  • @Test(expected = Exception.class): Indicates that a test method is expected to throw a specified exception.

  • @Test(timeout = 1000): Indicates that a test method must finish execution within the specified timeout period (in milliseconds).

Ignoring Tests

  • @Ignore: Ignores the test method it annotates. Optionally, a reason for ignoring the test can be provided.

Parameterized Tests Annotations

  • @RunWith(Parameterized.class): Indicates that a test class should run with a custom runner (in this case, the Parameterized runner).

  • @Parameters: Used to specify the parameters for a parameterized test.

Rule Annotations

  • @Rule: Annotates fields that reference rules or methods that return rules. Rules allow more flexible and powerful test configurations and setups.

  • @ClassRule: Similar to @Rule, but applies to all tests in a class rather than individual tests. The field or method must be static.

Category Annotations

  • @Category: Assigns categories to test classes or methods, which can be used to include or exclude tests during execution based on their category.

Test Order Annotations

  • @FixMethodOrder: Specifies the order in which test methods are executed. This can be useful for tests that must run in a specific sequence.

Custom Runner Annotations

  • @RunWith: Specifies a custom runner to use for running tests. This is often used for running parameterized tests or tests with specific configurations.

Classes in org.junit

Assume

The Assume class in JUnit 4 provides a way to state assumptions about the conditions under which a test is meaningful. If an assumption fails, the test will be ignored rather than marked as failed. This is useful for tests that should only run in specific environments or conditions.

Key Methods:

  • assumeTrue(boolean assumption): Only continues with the test if the assumption is true.

  • assumeFalse(boolean assumption): Only continues with the test if the assumption is false.

  • assumeNotNull(Object... objects): Only continues with the test if all the given objects are not null.

  • assumeThat(T actual, Matcher<T> matcher): Only continues with the test if the actual value satisfies the matcher.

AssumptionViolatedException

AssumptionViolatedException is thrown when an assumption fails. JUnit handles this exception by marking the test as ignored. This exception allows tests to declare that they should be skipped based on dynamic conditions during test execution. We typically do not need to catch or throw AssumptionViolatedException directly, as it is managed by the Assume class methods.

ComparisonFailure

ComparisonFailure is a subclass of AssertionError that is thrown when an assertion comparing two strings fails. This exception provides a more informative error message by highlighting the differences between the expected and actual strings, making it easier to understand why the test failed. When using assertion methods like assertEquals(String expected, String actual), ComparisonFailure is automatically used to provide detailed failure messages

Assert

The Assert class in JUnit 4 provides a collection of static methods to perform various assertions in tests. These assertions are used to verify that certain conditions are met in the test code. If an assertion fails, the test fails, and a corresponding failure message is reported.

Equality and Identity

  • assertEquals(expected, actual): Asserts that two objects are equal.

  • assertEquals(String message, expected, actual): Asserts that two objects are equal with a custom failure message.

  • assertEquals(long expected, long actual): Asserts that two long values are equal.

  • assertEquals(String message, long expected, long actual): Asserts that two long values are equal with a custom failure message.

  • assertEquals(double expected, double actual, double delta): Asserts that two double values are equal within a specified delta.

  • assertEquals(String message, double expected, double actual, double delta): Asserts that two double values are equal within a specified delta with a custom failure message.

  • assertNotEquals(expected, actual): Asserts that two objects are not equal.

  • assertNotEquals(String message, expected, actual): Asserts that two objects are not equal with a custom failure message.

  • assertNotEquals(long unexpected, long actual): Asserts that two long values are not equal.

  • assertNotEquals(String message, long unexpected, long actual): Asserts that two long values are not equal with a custom failure message.

  • assertNotEquals(double unexpected, double actual, double delta): Asserts that two double values are not equal within a specified delta.

  • assertNotEquals(String message, double unexpected, double actual, double delta): Asserts that two double values are not equal within a specified delta with a custom failure message.

  • assertSame(expected, actual): Asserts that two objects refer to the same object.

  • assertSame(String message, expected, actual): Asserts that two objects refer to the same object with a custom failure message.

  • assertNotSame(unexpected, actual): Asserts that two objects do not refer to the same object.

  • assertNotSame(String message, unexpected, actual): Asserts that two objects do not refer to the same object with a custom failure message.

Truth and False

  • assertTrue(boolean condition): Asserts that a condition is true.

  • assertTrue(String message, boolean condition): Asserts that a condition is true with a custom failure message.

  • assertFalse(boolean condition): Asserts that a condition is false.

  • assertFalse(String message, boolean condition): Asserts that a condition is false with a custom failure message.

Null and Non-Null

  • assertNull(Object object): Asserts that an object is null.

  • assertNull(String message, Object object): Asserts that an object is null with a custom failure message.

  • assertNotNull(Object object): Asserts that an object is not null.

  • assertNotNull(String message, Object object): Asserts that an object is not null with a custom failure message.

Arrays

  • assertArrayEquals(Object[] expecteds, Object[] actuals): Asserts that two object arrays are equal.

  • assertArrayEquals(String message, Object[] expecteds, Object[] actuals): Asserts that two object arrays are equal with a custom failure message.

  • assertArrayEquals(byte[] expecteds, byte[] actuals): Asserts that two byte arrays are equal.

  • assertArrayEquals(String message, byte[] expecteds, byte[] actuals): Asserts that two byte arrays are equal with a custom failure message.

  • assertArrayEquals(char[] expecteds, char[] actuals): Asserts that two char arrays are equal.

  • assertArrayEquals(String message, char[] expecteds, char[] actuals): Asserts that two char arrays are equal with a custom failure message.

  • assertArrayEquals(short[] expecteds, short[] actuals): Asserts that two short arrays are equal.

  • assertArrayEquals(String message, short[] expecteds, short[] actuals): Asserts that two short arrays are equal with a custom failure message.

  • assertArrayEquals(int[] expecteds, int[] actuals): Asserts that two int arrays are equal.

  • assertArrayEquals(String message, int[] expecteds, int[] actuals): Asserts that two int arrays are equal with a custom failure message.

  • assertArrayEquals(long[] expecteds, long[] actuals): Asserts that two long arrays are equal.

  • assertArrayEquals(String message, long[] expecteds, long[] actuals): Asserts that two long arrays are equal with a custom failure message.

  • assertArrayEquals(float[] expecteds, float[] actuals, float delta): Asserts that two float arrays are equal within a specified delta.

  • assertArrayEquals(String message, float[] expecteds, float[] actuals, float delta): Asserts that two float arrays are equal within a specified delta with a custom failure message.

  • assertArrayEquals(double[] expecteds, double[] actuals, double delta): Asserts that two double arrays are equal within a specified delta.

  • assertArrayEquals(String message, double[] expecteds, double[] actuals, double delta): Asserts that two double arrays are equal within a specified delta with a custom failure message.

Fail

  • fail(): Fails a test with no message.

  • fail(String message): Fails a test with a custom failure message.

Packages in org.junit

org.junit.runners

This package contains built-in runners that JUnit uses to execute tests.

  • Classes:

    • BlockJUnit4ClassRunner: The default JUnit 4 test runner.

    • Parameterized: Runner for parameterized tests.

    • JUnit4: A simple runner for running tests in a JUnit 4 environment.

    • Suite: A runner for aggregating multiple test classes into a suite.

org.junit.matchers

This package provides additional matchers for use in assertions.

  • Classes:

    • JUnitMatchers: Contains additional matchers (generic) that can be used with assertThat to create more readable and flexible assertions.

org.junit.runner

This package contains classes related to running tests and getting results.

  • Classes:

    • JUnitCore: A facade for running tests.

    • Result: Contains the result of running a test, including details about failures and the number of tests run.

    • Notification: Class used to notify listeners about test execution events.

    • Request: Represents a request to run a test.

    • RunWith: Annotation used to specify a custom runner.

    • Description: Represents a test or a suite of tests.

org.junit.validator

This package contains classes for validating test classes.

  • Classes:

    • AnnotationValidator: An interface for validating custom annotations.

    • PublicClassValidator: Validates that a class is public.

    • ValidateWith: An annotation used to specify a custom validator.

    • ValidationError: Represents an error found during validation.

org.junit.rules

This package contains classes for creating and using rules, which can modify the behavior of tests.

  • Classes:

    • ExternalResource: A base class for rules that set up and tear down external resources.

    • TemporaryFolder: A rule that creates and deletes a temporary folder for use in tests.

    • TestName: A rule that makes the name of the currently running test method available.

    • Timeout: A rule that applies a timeout to all test methods in a class.

PreviousJUnitNextExamples

Last updated 8 months ago

Was this helpful?