KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use doThrowShouldNotAllowSettingNullVarArgThrowableClasses method of org.mockitousage.stubbing.StubbingWithThrowablesTest class

Best Mockito code snippet using org.mockitousage.stubbing.StubbingWithThrowablesTest.doThrowShouldNotAllowSettingNullVarArgThrowableClasses

Source:StubbingWithThrowablesTest.java

...168        exception.expectMessage("Exception type cannot be null");169        Mockito.doThrow(RuntimeException.class, ((Class) (null))).when(mock).isEmpty();170    }171    @Test172    public void doThrowShouldNotAllowSettingNullVarArgThrowableClasses() throws Exception {173        exception.expect(MockitoException.class);174        exception.expectMessage("Exception type cannot be null");175        Mockito.doThrow(RuntimeException.class, ((Class[]) (null))).when(mock).isEmpty();176    }177    @Test178    public void shouldNotAllowSettingNullVarArgsThrowableClasses() throws Exception {179        exception.expect(MockitoException.class);180        exception.expectMessage("Exception type cannot be null");181        Mockito.when(mock.isEmpty()).thenThrow(RuntimeException.class, ((Class<RuntimeException>[]) (null)));182    }183    @Test184    public void shouldNotAllowDifferntCheckedException() throws Exception {185        IMethods mock = Mockito.mock(IMethods.class);186        exception.expect(MockitoException.class);...

doThrowShouldNotAllowSettingNullVarArgThrowableClasses

Using AI Code Generation

1package org.mockitousage.stubbing;2import org.junit.Test;3import org.mockito.Mock;4import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;5import org.mockitousage.IMethods;6import org.mockitoutil.TestBase;7import static org.junit.Assert.fail;8import static org.mockito.Mockito.doThrow;9import static org.mockito.Mockito.mock;10public class StubbingWithThrowablesTest extends TestBase {11    @Mock private IMethods mock;12    public void shouldAllowSettingNullThrowableClasses() {13        doThrow((Class<? extends Throwable>[]) null).when(mock).oneArg(true);14    }15    public void shouldAllowSettingNullVarArgThrowableClasses() {16        doThrowShouldNotAllowSettingNullVarArgThrowableClasses();17    }18    public void shouldAllowSettingNullThrowable() {19        doThrow((Throwable) null).when(mock).oneArg(true);20    }21    public void shouldAllowSettingNullThrowableArray() {22        doThrow((Throwable[]) null).when(mock).oneArg(true);23    }24    public void shouldAllowSettingNullVarArgThrowables() {25        doThrow((Throwable) null, (Throwable) null).when(mock).oneArg(true);26    }27    public void shouldAllowSettingNullVarArgThrowables2() {28        doThrow((Throwable[]) null).when(mock).oneArg(true);29    }30    public void shouldAllowSettingNullVarArgThrowables3() {31        doThrow((Throwable[]) null).when(mock).oneArg(true);32    }33    public void shouldAllowSettingNullVarArgThrowables4() {34        doThrow((Throwable) null, (Throwable) null).when(mock).oneArg(true);35    }36    public void shouldAllowSettingNullVarArgThrowables5() {37        doThrow((Throwable) null, (Throwable) null).when(mock).oneArg(true);38    }39    public void shouldAllowSettingNullVarArgThrowables6() {40        doThrow((Throwable) null, (Throwable) null).when(mock).oneArg(true);41    }42    public void shouldAllowSettingNullVarArgThrowables7() {43        doThrow((Throwable) null, (Throwable) null).when(mock).oneArg(true);44    }

doThrowShouldNotAllowSettingNullVarArgThrowableClasses

Using AI Code Generation

1public class StubbingWithThrowablesTest {2    public void doThrowShouldNotAllowSettingNullVarArgThrowableClasses() {3        try {4            doThrow((Class<? extends Throwable>[]) null);5            fail();6        } catch (NullPointerException e) {7        }8    }9}

doThrowShouldNotAllowSettingNullVarArgThrowableClasses

Using AI Code Generation

1import org.mockito.*2import org.mockito.exceptions.base.MockitoException3import spock.lang.Specification4class StubbingWithThrowablesTest extends Specification {5    def "should not allow setting null var arg Throwable classes"() {6        def mock = mock(List)7        mock.addAll(null)8        def e = thrown(MockitoException)9    }10    def "should not allow setting null var arg Throwable classes"() {11        def mock = mock(List)12        mock.addAll(null)13        def e = thrown(MockitoException)14    }15}

doThrowShouldNotAllowSettingNullVarArgThrowableClasses

Using AI Code Generation

1package org.mockitousage.stubbing;2import static org.mockito.Mockito.*;3import static org.junit.Assert.*;4import org.junit.*;5import org.mockito.*;6import org.mockito.exceptions.base.MockitoException;7import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;8import org.mockito.exceptions.misusing.NullInsteadOfMockException;9import org.mockito.exceptions.misusing.UnfinishedStubbingException;10import org.mockitousage.IMethods;11import org.mockitoutil.TestBase;12import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;13public class StubbingWithThrowablesTest extends TestBase {14    private IMethods mock;15    public void setup() {16        mock = mock(IMethods.class);17    }18    public void shouldAllowSettingNullThrowable() {19        doThrow((Throwable) null).when(mock).simpleMethod();20        mock.simpleMethod();21    }22    public void shouldAllowSettingNullVarArgThrowableClasses() {23        doThrow((Class<? extends Throwable>[]) null).when(mock).simpleMethod();24        mock.simpleMethod();25    }26    public void shouldAllowSettingNullVarArgThrowables() {27        doThrow((Throwable[]) null).when(mock).simpleMethod();28        mock.simpleMethod();29    }30    public void shouldAllowSettingNullThrowableClasses() {31        doThrow((Class<? extends Throwable>) null).when(mock).simpleMethod();32        mock.simpleMethod();33    }34    public void shouldAllowSettingNullThrowableClassesInVarargs() {35        doThrow(new Class[] { NullPointerException.class, null }).when(mock).simpleMethod();36        mock.simpleMethod();37    }38    public void shouldAllowSettingNullThrowablesInVarargs() {39        doThrow(new Throwable[] { new NullPointerException(), null }).when(mock).simpleMethod();40        mock.simpleMethod();41    }42    @Test(expected = InvalidUseOfMatchersException.class)43    public void shouldDisallowMatchersInVarargs() {44        doThrow(new Class[] { NullPointerException.class, anyInt() }).when(mock).simpleMethod();45    }46    @Test(expected =

StackOverFlow community discussions

Questions

Discussion

How to do a JUnit assert on a message in a logger

Mockito mock objects returns null

Junit test for model class

How to use Mockito.verify() on static methods?

Avoiding unchecked warnings when using Mockito

How to Mock Injected Dependencies

What is the difference between mocking and spying when using Mockito?

ProGuard doesn't obfuscate JAR with dependencies

how to make sure mocked object is called only once in mockito

I've needed this several times as well. I've put together a small sample below, which you'd want to adjust to your needs. Basically, you create your own Appender and add it to the logger you want. If you'd want to collect everything, the root logger is a good place to start, but you can use a more specific if you'd like. Don't forget to remove the Appender when you're done, otherwise you might create a memory leak. Below I've done it within the test, but setUp or @Before and tearDown or @After might be better places, depending on your needs.

Also, the implementation below collects everything in a List in memory. If you're logging a lot you might consider adding a filter to drop boring entries, or to write the log to a temporary file on disk (Hint: LoggingEvent is Serializable, so you should be able to just serialize the event objects, if your log message is.)

import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

public class MyTest {
    @Test
    public void test() {
        final TestAppender appender = new TestAppender();
        final Logger logger = Logger.getRootLogger();
        logger.addAppender(appender);
        try {
            Logger.getLogger(MyTest.class).info("Test");
        }
        finally {
            logger.removeAppender(appender);
        }

        final List<LoggingEvent> log = appender.getLog();
        final LoggingEvent firstLogEntry = log.get(0);
        assertThat(firstLogEntry.getLevel(), is(Level.INFO));
        assertThat((String) firstLogEntry.getMessage(), is("Test"));
        assertThat(firstLogEntry.getLoggerName(), is("MyTest"));
    }
}

class TestAppender extends AppenderSkeleton {
    private final List<LoggingEvent> log = new ArrayList<LoggingEvent>();

    @Override
    public boolean requiresLayout() {
        return false;
    }

    @Override
    protected void append(final LoggingEvent loggingEvent) {
        log.add(loggingEvent);
    }

    @Override
    public void close() {
    }

    public List<LoggingEvent> getLog() {
        return new ArrayList<LoggingEvent>(log);
    }
}

https://stackoverflow.com/questions/1827677/how-to-do-a-junit-assert-on-a-message-in-a-logger

It really depends on GeneralConfigService#getInstance() implementation. Also you can simplify your test code a lot if you use @InjectMocks annotation.

When using MockitoJUnitRunner you don't need to initialize mocks and inject your dependencies manually:

@RunWith(MockitoJUnitRunner.class)
public class GeneralConfigServiceImplTest  {

    @InjectMocks
    private GeneralConfigService generalConfigService;

    @Mock
    private GeneralConfigDAO generalConfigDAO;

    @Test
    public void testAddGeneralConfigCallDAOSuccess() {
       // generalConfigService is already instantiated and populated with dependencies here
       ...
    }
}

https://stackoverflow.com/questions/16570029/mockito-mock-objects-returns-null

To verify a static method using Mockito -> MockedStatic.

If the method has parameters and you want to verify it then it will be verify by this way:

@Test
void testMethod() {
  try (MockedStatic<StaticProperties> theMock = Mockito.mockStatic(StaticProperties.class)) {
    theMock.when(StaticProperties.getProperty("abc", "xyz", "lmn"))).thenReturn("OK");

    //code .....

    theMock.verify(() -> StaticProperties.getProperty("abc", "xyz", "lmn"));
  }
  
}

https://stackoverflow.com/questions/34610042/how-to-use-mockito-verify-on-static-methods

All warnings go away when alternative way of mock specification is used:

    ScheduledFuture<?> future = Mockito.mock(ScheduledFuture.class);
    Mockito.doReturn(future).when(executor).schedule(
        Mockito.any(Runnable.class),
        Mockito.anyLong(),
        Mockito.any(TimeUnit.class)
    );

https://stackoverflow.com/questions/34475010/avoiding-unchecked-warnings-when-using-mockito

Consider overriding your Guice injection configuration using another test module.

I will show it using own example, but it's easy to adapt to your needs.

Module testModule = Modules.override(new ProductionModule())
    .with(new AbstractModule(){

    @Override
    protected void configure() {
        bind(QueueFactory.class).toInstance(spy(new QueueFactory()));
    }

});

Injector injector = Guice.createInjector(testModule);
QueueFactory qFactorySpy = injector.getInstance(QueueFactory.class);

https://stackoverflow.com/questions/19772247/how-to-mock-injected-dependencies

Difference between a Spy and a Mock

When Mockito creates a mock – it does so from the Class of a Type, not from an actual instance. The mock simply creates a bare-bones shell instance of the Class, entirely instrumented to track interactions with it. On the other hand, the spy will wrap an existing instance. It will still behave in the same way as the normal instance – the only difference is that it will also be instrumented to track all the interactions with it.

In the following example – we create a mock of the ArrayList class:

@Test
public void whenCreateMock_thenCreated() {
    List mockedList = Mockito.mock(ArrayList.class);

    mockedList.add("one");
    Mockito.verify(mockedList).add("one");

    assertEquals(0, mockedList.size());
}

As you can see – adding an element into the mocked list doesn’t actually add anything – it just calls the method with no other side-effect. A spy on the other hand will behave differently – it will actually call the real implementation of the add method and add the element to the underlying list:

@Test
public void whenCreateSpy_thenCreate() {
    List spyList = Mockito.spy(new ArrayList());
    spyList.add("one");
    Mockito.verify(spyList).add("one");

    assertEquals(1, spyList.size());
}

Here we can surely say that the real internal method of the object was called because when you call the size() method you get the size as 1, but this size() method isn’t been mocked! So where does 1 come from? The internal real size() method is called as size() isn’t mocked (or stubbed) and hence we can say that the entry was added to the real object.

Source: http://www.baeldung.com/mockito-spy + self notes.

https://stackoverflow.com/questions/15052984/what-is-the-difference-between-mocking-and-spying-when-using-mockito

proguard-maven-plugin will obfuscate the primary artifact of your project, not the secondary artifact jar-with-dependencies that the maven-assembly-plugin generated.

You need to configure the plugin to obfuscate the jar-with-dependencies by specifying the injar attribute:

Specifies the input jar name (or wars, ears, zips) of the application to be processed.

<injar>${project.build.finalName}-jar-with-dependencies.jar</injar>

Now, there is also a problem in the order of execution of plugins in your POM: we need to make sure that the maven-assembly-plugin is executed before the proguard-maven-plugin. As such, it is best to define an explicit execution for the maven-assembly-plugin bound to the package phase instead of manually invoking it from the command line with assembly:single. This would be the configuration:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <executions>
        <execution>
            <id>assembly</id>
            <goals>
                <goal>single</goal>
            </goals>
            <phase>package</phase>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </execution>
    </executions>
</plugin>

and then, you just need to make sure that the proguard-maven-plugin plugin configuration is after that in your POM.

Having done that, invoking Maven with mvn clean install will result in an obfuscated jar with dependencies.

To test with your actual POM, I added two repositories:

https://repo.spongepowered.org/maven to resolve the spongeapi dependency.
http://maven.restlet.com to resolve the org.restlet.jse dependencies.

With those 2 dependencies, warnings were generated by ProGuard because the org.restlet.ext.jackson dependency utilizes com.sun.msv.* classes that are not on the buildpath. Since I figure that your code is currently working, it means those classes don't need to be included and that those warnings can be ignored. As such, I added the -dontwarn option so that ProGuard doesn't error when there is a warning.

The final POM for which I was able to successfully obfuscate the jar with dependencies is the following:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>myproduct</artifactId>
    <version>1.0-SNAPSHOT</version>
    <repositories>
       <repository>
           <id>spongepowered</id>
           <url>https://repo.spongepowered.org/maven</url>
       </repository>
       <repository>
           <id>restlet</id>
           <url>http://maven.restlet.com</url>
       </repository>
    </repositories>
    <properties>
        <restlet-version>2.3.5</restlet-version>
    </properties>
    <build>
       <resources>
            <resource>
                <directory>${project.basedir}/src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>templating-maven-plugin</artifactId>
                <version>1.0-alpha-3</version>
                <executions>
                    <execution>
                        <id>filter-src</id>
                        <goals>
                            <goal>filter-sources</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <executions>
                    <execution>
                        <id>assembly</id>
                        <goals>
                            <goal>single</goal>
                        </goals>
                        <phase>package</phase>
                        <configuration>
                            <descriptorRefs>
                                <descriptorRef>jar-with-dependencies</descriptorRef>
                            </descriptorRefs>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>com.github.wvengen</groupId>
                <artifactId>proguard-maven-plugin</artifactId>
                <version>2.0.8</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals><goal>proguard</goal></goals>
                        <configuration>
                            <injar>${project.build.finalName}-jar-with-dependencies.jar</injar> <!-- make sure to obfuscate the jar with dependencies -->
                            <proguardVersion>5.2</proguardVersion>
                            <options>
                                <option>-allowaccessmodification</option>
                                <option>-dontoptimize</option>
                                <option>-dontshrink</option>
                                <option>-dontnote</option>
                                <option>-dontwarn</option> <!-- added option to ignore com.sun missing classes -->
                                <option>-keepattributes Signature</option>
                                <option>-keep class com.mycompany.MyPlugin { *; }</option>
                            </options>
                            <libs>
                                <lib>${java.home}/lib/rt.jar</lib>
                            </libs>
                            <dependencies>
                                <dependency>
                                    <groupId>net.sf.proguard</groupId>
                                    <artifactId>proguard-base</artifactId>
                                    <version>5.2</version>
                                    <scope>runtime</scope>
                                </dependency>
                            </dependencies>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <dependencies>
       <dependency>
            <groupId>org.spongepowered</groupId>
            <artifactId>spongeapi</artifactId>
            <version>3.0.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.easytesting</groupId>
            <artifactId>fest-assert-core</artifactId>
            <version>2.0M8</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>1.10.19</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.restlet.jse</groupId>
            <artifactId>org.restlet</artifactId>
            <version>${restlet-version}</version>
        </dependency>
        <dependency>
            <groupId>org.restlet.jse</groupId>
            <artifactId>org.restlet.ext.jackson</artifactId>
            <version>${restlet-version}</version>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>
</project>

https://stackoverflow.com/questions/34838280/proguard-doesnt-obfuscate-jar-with-dependencies

proguard-maven-plugin will obfuscate the primary artifact of your project, not the secondary artifact jar-with-dependencies that the maven-assembly-plugin generated.

You need to configure the plugin to obfuscate the jar-with-dependencies by specifying the injar attribute:

Specifies the input jar name (or wars, ears, zips) of the application to be processed.

<injar>${project.build.finalName}-jar-with-dependencies.jar</injar>

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <executions>
        <execution>
            <id>assembly</id>
            <goals>
                <goal>single</goal>
            </goals>
            <phase>package</phase>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </execution>
    </executions>
</plugin>

and then, you just need to make sure that the proguard-maven-plugin plugin configuration is after that in your POM.

Having done that, invoking Maven with mvn clean install will result in an obfuscated jar with dependencies.

To test with your actual POM, I added two repositories:

https://repo.spongepowered.org/maven to resolve the spongeapi dependency.
http://maven.restlet.com to resolve the org.restlet.jse dependencies.

The final POM for which I was able to successfully obfuscate the jar with dependencies is the following:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>myproduct</artifactId>
    <version>1.0-SNAPSHOT</version>
    <repositories>
       <repository>
           <id>spongepowered</id>
           <url>https://repo.spongepowered.org/maven</url>
       </repository>
       <repository>
           <id>restlet</id>
           <url>http://maven.restlet.com</url>
       </repository>
    </repositories>
    <properties>
        <restlet-version>2.3.5</restlet-version>
    </properties>
    <build>
       <resources>
            <resource>
                <directory>${project.basedir}/src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>templating-maven-plugin</artifactId>
                <version>1.0-alpha-3</version>
                <executions>
                    <execution>
                        <id>filter-src</id>
                        <goals>
                            <goal>filter-sources</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <executions>
                    <execution>
                        <id>assembly</id>
                        <goals>
                            <goal>single</goal>
                        </goals>
                        <phase>package</phase>
                        <configuration>
                            <descriptorRefs>
                                <descriptorRef>jar-with-dependencies</descriptorRef>
                            </descriptorRefs>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>com.github.wvengen</groupId>
                <artifactId>proguard-maven-plugin</artifactId>
                <version>2.0.8</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals><goal>proguard</goal></goals>
                        <configuration>
                            <injar>${project.build.finalName}-jar-with-dependencies.jar</injar> <!-- make sure to obfuscate the jar with dependencies -->
                            <proguardVersion>5.2</proguardVersion>
                            <options>
                                <option>-allowaccessmodification</option>
                                <option>-dontoptimize</option>
                                <option>-dontshrink</option>
                                <option>-dontnote</option>
                                <option>-dontwarn</option> <!-- added option to ignore com.sun missing classes -->
                                <option>-keepattributes Signature</option>
                                <option>-keep class com.mycompany.MyPlugin { *; }</option>
                            </options>
                            <libs>
                                <lib>${java.home}/lib/rt.jar</lib>
                            </libs>
                            <dependencies>
                                <dependency>
                                    <groupId>net.sf.proguard</groupId>
                                    <artifactId>proguard-base</artifactId>
                                    <version>5.2</version>
                                    <scope>runtime</scope>
                                </dependency>
                            </dependencies>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <dependencies>
       <dependency>
            <groupId>org.spongepowered</groupId>
            <artifactId>spongeapi</artifactId>
            <version>3.0.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.easytesting</groupId>
            <artifactId>fest-assert-core</artifactId>
            <version>2.0M8</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>1.10.19</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.restlet.jse</groupId>
            <artifactId>org.restlet</artifactId>
            <version>${restlet-version}</version>
        </dependency>
        <dependency>
            <groupId>org.restlet.jse</groupId>
            <artifactId>org.restlet.ext.jackson</artifactId>
            <version>${restlet-version}</version>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>
</project>

https://stackoverflow.com/questions/34838280/proguard-doesnt-obfuscate-jar-with-dependencies

I got the answer we can do it in the following way

when(nodeIterator.hasNext()).thenReturn(true).thenReturn(false);

this is known as method stubbing. Similarly if you want to call it twice and then you want to return false, then do as follows

when(nodeIterator.hasNext()).thenReturn(true).thenReturn(true).thenReturn(false);

https://stackoverflow.com/questions/19971523/how-to-make-sure-mocked-object-is-called-only-once-in-mockito

Blogs

Check out the latest blogs from LambdaTest on this topic:

Testing Modern Applications With Playwright ????

Web applications continue to evolve at an unbelievable pace, and the architecture surrounding web apps get more complicated all of the time. With the growth in complexity of the web application and the development process, web application testing also needs to keep pace with the ever-changing demands.

Aug’ 20 Updates: Live Interaction In Automation, macOS Big Sur Preview & More

Hey Testers! We know it’s been tough out there at this time when the pandemic is far from gone and remote working has become the new normal. Regardless of all the hurdles, we are continually working to bring more features on-board for a seamless cross-browser testing experience.

Appium: Endgame and What’s Next? [Testμ 2022]

The automation backend architecture of Appium has undergone significant development along with the release of numerous new capabilities. With the advent of Appium, test engineers can cover mobile apps, desktop apps, Flutter apps, and more.

LIVE With Automation Testing For OTT Streaming Devices ????

People love to watch, read and interact with quality content — especially video content. Whether it is sports, news, TV shows, or videos captured on smartphones, people crave digital content. The emergence of OTT platforms has already shaped the way people consume content. Viewers can now enjoy their favorite shows whenever they want rather than at pre-set times. Thus, the OTT platform’s concept of viewing anything, anytime, anywhere has hit the right chord.

What Agile Testing (Actually) Is

So, now that the first installment of this two fold article has been published (hence you might have an idea of what Agile Testing is not in my opinion), I’ve started feeling the pressure to explain what Agile Testing actually means to me.

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.