How do I disable Java assertions for a junit test in the code

Typically you use surefire with maven for JUnit tests. Adding -disableassertions or the synonym -da as an argument should work:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>your_version</version>
    <configuration>
        <argLine>-disableassertions</argLine>
    </configuration>
</plugin>

If the tests are launched different through the IDE (that is outside of maven), you probably need to edit some launch configuration and pass the parameter. This is, however, IDE dependent.

Look at -da and -ea parameters for java tool. So, in you case just use one of them (+ specify correspond package on your application) as you want to disable or enable assertions.

With no arguments, -enableassertions or -ea enables assertions.

• With one argument ending in "...", the switch enables assertions in the specified package and any subpackages.
• If the argument is "...", then the switch enables assertions in the unnamed package in the current working directory.
• With one argument not ending in "...", the switch enables assertions in the specified class.

Within Java (disabling assertions in single class)

To enable or disable assertion checking within Java use setClassAssertionStatus in the ClassLoader. For example:

Foo.class.getClassLoader().setClassAssertionStatus(Foo.class.getName(), false);

Within Maven (disabling assertions for all classes)

Since version 2.3.1, Maven Surefire has a separate enableAssertions flag.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>your_version</version>
  <configuration>
    <enableAssertions>false</enableAssertions>
  </configuration>
</plugin>

With JUnit 4 Assume (for single test case)

Ideally, your tests should pass regardless of assertions are enabled or disabled. If one of the tests depends on assertions being disabled, the intended JUnit mechanism is to use an assumption:

import static org.junit.Assume.assumeTrue;

@Test
public foo onlyWithoutAssertions() {
    assumeTrue(assertionsDisabled());
    // your tricky test comes here, and is only executed in 
    // environments with assertion checking disabled.
}

public static boolean assertionsDisabled() {
    return !Foo.class.desiredAssertionStatus();
}

Note: I typically use this option the other way around: To check that an assert works as expected, in rare cases I have a test that assumes that assertion checking is enabled.

With JUnit 5 Assume

JUnit 5 assumptions are an extension of the JUnit 4 ones. Thus, for JUnit 5, the only change to the JUnit 4 code is the import, which now is from jupiter:

import static org.junit.jupiter.api.Assumptions.assumeTrue;