The `when` syntax won&#39;t work with a void method (it won&#39;t fit within the `when`), and `doReturn` doesn&#39;t apply when there&#39;s no return value. [`doCallRealMethod`](http://site.mockito.org/mockito/docs/current/org/mockito/Mockito.html#doCallRealMethod()) is likely the answer you want.

    doCallRealMethod().when(instance).voidFunction();

Bear in mind that when calling a real method on a mock, you may not get very realistic behavior, because unlike with spies mocked objects will skip all constructor and initializer calls including those to set fields. That means that if your method uses any instance state at all, it is unlikely to work as a mock with `doCallRealMethod` or `thenCallRealMethod`. With a spy, you can create a real instance of your class, and then the `Mockito.spy` method will copy that instance state over to make for a more realistic interaction.

how can i convert a video to images using ffmpeg? Example am having a video with total duration 60 seconds. I want images between different set of duration like between 2-6 seconds, then between 15-24 seconds and so on. Is that possible using ffmpeg?

FFMPEG- Convert video to images

I do not understand the meaning of `types` field in `tsconfig.json`. In documentation I have read such text: 

            


&lt;!-- language: lang-js --&gt;

    &quot;types&quot;: {
      &quot;description&quot;: &quot;Type declaration files to be included in compilation. Requires TypeScript version 2.0 or later.&quot;,
      &quot;type&quot;: &quot;array&quot;,
      &quot;items&quot;: {
        &quot;type&quot;: &quot;string&quot;
      }
    },


As far, as I understand if I install `@types/express` I should add such string in `tsconfig.json`

    {
      &quot;compilerOptions&quot;: {
         ...
         &quot;types&quot;: [&quot;lodash&quot;]
       }
    } 

but everything works fine without it. And now I do not understand, why I need `types` field

Typescript 2.0. &quot;types&quot; field in tsconfig.json

I have been running into a problem when trying to write a JUnit test case and am relatively new to Mockito.

I have a function of a class that I am mocking, this function happens to be of a void return type. When calling this function from my mocked class it is my understanding (and debugging experience) that it does NOT call the original function. In order to overcome this, I have attempted to use a &quot;when&quot; with a &quot;thenCallRealMethod()&quot;.

    when(instance.voidFunction()).thenCallRealMethod();

The &quot;voidFunction&quot; is full of logic that I do NOT want to fire. I have extracted these into when statements to avoid that. I have read that I should use the format of `doReturn().when().voidFunction()`, however doing this does not call the real method.

It was also my understanding that I could not use a Spy here, due to the fact that I do not want the `voidFunction()` called before the &quot;when&quot; statements. Any help is appreciated I apologize if this is a very easy solution as my understanding of mockito isn&#39;t very great despite reading quite a bit. Thanks!

Mockito - thenCallRealMethod() on void function

I have been running into a problem when trying to write a JUnit test case and am relatively new to Mockito.
I have a function of a class that I am mocking, this function happens to be of a void return type. When calling this function from my mocked class it is my understanding (and debugging experience) that it does NOT call the original function. In order to overcome this, I have attempted to use a "when" with a "thenCallRealMethod()".
<pre><code class="hljs language-scss">when(instance.voidFunction()).thenCallRealMethod();
</code></pre>
The "voidFunction" is full of logic that I do NOT want to fire. I have extracted these into when statements to avoid that. I have read that I should use the format of <code>doReturn().when().voidFunction()</code>, however doing this does not call the real method.
It was also my understanding that I could not use a Spy here, due to the fact that I do not want the <code>voidFunction()</code> called before the "when" statements. Any help is appreciated I apologize if this is a very easy solution as my understanding of mockito isn't very great despite reading quite a bit. Thanks!

I have the following function in a React component:

    onUploadStart(file, xhr, formData) {
      formData.append(&#39;filename&#39;, file.name);
      formData.append(&#39;mimeType&#39;, file.type);
    }

This is my test that at least gets the spy to be called: 

    const formData = { append: jest.fn() };
    const file = { name: &#39;someFileName&#39;, type: &#39;someMimeType&#39; };
    eventHandlers.onUploadStart(file, null, formData);

    expect(formData.append).toHaveBeenCalledWith(
      [&#39;mimeType&#39;, &#39;someMimeType&#39;],
      [&#39;fileName&#39;, &#39;someFileName&#39;]
    );

However, the assertion is not working:

    Expected mock function to have been called with:
     [[&quot;mimeType&quot;, &quot;someMimeType&quot;], [&quot;fileName&quot;, &quot;someFileName&quot;]]
    But it was called with:
      [&quot;mimeType&quot;, &quot;someMimeType&quot;], [&quot;filename&quot;, &quot;someFileName&quot;]

What is the right way to use `toHaveBeenCalledWith`?

How to check multiple arguments on multiple calls for jest spies?

When do you use the async function in the **TestBed** when testing in Angular 2?

When do you use this?

     beforeEach(() =&gt; {
            TestBed.configureTestingModule({
                declarations: [MyModule],
                schemas: [NO_ERRORS_SCHEMA],
            });
        });

And when do you use this?

    beforeEach(async(() =&gt; {
        TestBed.configureTestingModule({
            declarations: [MyModule],
            schemas: [NO_ERRORS_SCHEMA],
        });
    }));

Can anyone enlighten me on this ?

Angular 2 Testing - Async function call - when to use

I have a Jupyter notebook that I plan to run repeatedly. It has functions in it, the structure of the code is this:

    def construct_url(data):
        ...
        return url

    def scrape_url(url):
        ... # fetch url, extract data
        return parsed_data

    for i in mylist: 
        url = construct_url(i)
        data = scrape_url(url)
        ... #&#160;use the data to do analysis

I&#39;d like to write tests for `construct_url` and `scrape_url`. What&#39;s the most sensible way to do this?

Some approaches I&#39;ve considered:

 - Move the functions out into a utility file, and write tests for that utility file in some standard Python testing library. Possibly the best option, though it means that not all of the code is visible in the notebook.
 - Write asserts within the notebook itself, using test data (adds noise to the notebook).
 - Use specialised Jupyter testing to test the content of the cells (don&#39;t think this works, because the content of the cells is going to change). 


Unit tests for functions in a Jupyter notebook?

I&#39;ve run into missing `&lt;router-outlet&gt;` messages in other unit tests, but just to have a nice isolated example, I created an AuthGuard that checks if a user is logged in for certain actions.

This is the code:

    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
        if (!this.authService.isLoggedIn()) {
            this.router.navigate([&#39;/login&#39;]);
            return false;
        }
        return true;
    }

Now I want to write a unit test for this.

This is how I start my test:

    beforeEach(() =&gt; {
        TestBed.configureTestingModule({
            imports: [
                RouterTestingModule.withRoutes([
                    {
                        path: &#39;login&#39;,
                        component: DummyComponent
                    }
                ])
            ],
            declarations: [
                DummyComponent
            ],
            providers: [
                AuthGuardService,
                {
                    provide: AuthService,
                    useClass: MockAuthService
                }
            ]
        });
    });

I created a DummyComponent that does nothing.
Now my test. Pretend that the service returns false and that it triggers `this.router.navigate([&#39;/login&#39;])`:

    it(&#39;should not let users pass when not logged in&#39;, (): void =&gt; {
        expect(authGuardService.canActivate(&lt;any&gt;{}, &lt;any&gt;{})).toBe(false);
    });

This will throw an exception with &quot;Cannot find primary outlet to load&quot;.
Obviously I can use `toThrow()` instead of `toBe(false)`, but that doesn&#39;t seem like a very sensible solution. Since I&#39;m testing a service here, there is no template where I can put the `&lt;router-outlet&gt;` tag. I could mock the router and make my own navigate function, but then what&#39;s the point of RouterTestingModule? Perhaps you even want to check that navigation worked.


How to test Angular2&#39;s router.navigate?

Is there any way in Jest to mock global objects, such as `navigator`, or `Image`*? I&#39;ve pretty much given up on this, and left it up to a series of mockable utility methods. For example:

    // Utils.js
    export isOnline() {
        return navigator.onLine;
    }

Testing this tiny function is simple, but crufty and not deterministic at all. I can get 75% of the way there, but this is about as far as I can go:

    // Utils.test.js
    it(&#39;knows if it is online&#39;, () =&gt; {
        const { isOnline } = require(&#39;path/to/Utils&#39;);

        expect(() =&gt; isOnline()).not.toThrow();
        expect(typeof isOnline()).toBe(&#39;boolean&#39;);
    });

On the other hand, if I am okay with this indirection, I can now access `navigator` via these utilities:

    // Foo.js
    import { isOnline } from &#39;./Utils&#39;;

    export default class Foo {
        doSomethingOnline() {
    		if (!isOnline()) throw new Error(&#39;Not online&#39;);

            /* More implementation */            
        }
    }

...and deterministically test like this...

    // Foo.test.js
    it(&#39;throws when offline&#39;, () =&gt; {
        const Utils = require(&#39;../services/Utils&#39;);
        Utils.isOnline = jest.fn(() =&gt; isOnline);

        const Foo = require(&#39;../path/to/Foo&#39;).default;
        let foo = new Foo();

        // User is offline -- should fail
        let isOnline = false;
        expect(() =&gt; foo.doSomethingOnline()).toThrow();

        // User is online -- should be okay
        isOnline = true;
        expect(() =&gt; foo.doSomethingOnline()).not.toThrow();
    });

Out of all the testing frameworks I&#39;ve used, Jest feels like the most complete solution, but any time I write awkward code just to make it testable, I feel like my testing tools are letting me down.

Is this the only solution or do I need to add Rewire?

*Don&#39;t smirk. `Image` is fantastic for pinging a remote network resource.

Mocking globals in Jest

Is there a better way to assert that a method throws an exception in JUnit 5?

Currently, I have to use an @Rule in order to verify that my test throws an exception, but this doesn&#39;t work for the cases where I expect multiple methods to throw exceptions in my test.

JUnit 5: How to assert an exception is thrown?

I have some junit tests which create some resources which should also be closed.

One way to implement this logic is using the `@Before` and `@After` approach.

What I did was to encapsulate the creation in some utility class to be reused. For example:

    class UserCreatorTestUtil implements AutoClosable {
      User create() {...}
      void close() {...}
    }

The whole point is for the object to close itself, rather than needing to remember to close it in `@After`.

The usage should be:

    @Test
    void test() {
      try (UserCreatorTestUtil userCreatorTestUtil = new UserCreatorTestUtil()) {
        User user = userCreatorTestUtil.create();
        // Do some stuff regarding the user&#39;s phone
        Assert.assertEquals(&quot;123456789&quot;, user.getPhone());
      }
    }

The problem is that junit&#39;s assert keyword throws an `Error` - not `Exception`.

**Will the try-with-resource &quot;catch&quot; the `Error` and invoke the close method?**

\* Couldn&#39;t find the answer in the [try-with-resources documentation][1].


  [1]: https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html

Does Java&#39;s try-with-resources catch errors or just exceptions?

Is there any reason to group multiple assertions:

    public void shouldTellIfPrime(){
        Assertions.assertAll(
                () -&gt; assertTrue(isPrime(2)),
                () -&gt; assertFalse(isPrime(4))
        );
    }

instead of doing this:

    public void shouldTellIfPrime(){
        Assertions.assertTrue(isPrime(2));
        Assertions.assertFalse(isPrime(4));
    }

assertAll vs multiple assertions in JUnit5

I am writing JUnit4 test in which I am using TemporaryFolder rule. It seems that it works fine with both @Rule and @ClassRule. What is the difference between Junit @Rule and @ClassRule? Why should I use one and not another? 

Junit @Rule and @ClassRule

I have got 4 classes lets says A, B, C, D each calling on methods from another one.

now I have mocked class A, and want to mock a method using mockito

    A a = Mockito.mock(A.class);

and want to get &quot;foo&quot; on recursive method calls like 

`a.getB().getC().getD()` should return `&quot;foo&quot;`

I tried 

&gt; when(a.getB().getC().getD()).thenReturn(&quot;foo&quot;);

but got nullPointerException

then I tried

    

&gt; doReturn(&quot;foo&quot;).when(a.getB().getC().getD());

then I got  `org.mockito.exceptions.misusing.UnfinishedStubbingException:`

I know I can create objects of B, C and D, or can even write something like 

&gt; B b = mock(B.class) or A.setB(new B())

 and so on.

But can&#39;t I do that in a single shot?
Any help would be appreciated.





mock nested method calls using mockito

I want to test that one of my [ES6][1] modules calls another ES6 module in a particular way. With [Jasmine][2] this is super easy --

The application code:

    // myModule.js
    import dependency from &#39;./dependency&#39;;

    export default (x) =&gt; {
      dependency.doSomething(x * 2);
    }

And the test code:

    //myModule-test.js
    import myModule from &#39;../myModule&#39;;
    import dependency from &#39;../dependency&#39;;

    describe(&#39;myModule&#39;, () =&gt; {
      it(&#39;calls the dependency with double the input&#39;, () =&gt; {
        spyOn(dependency, &#39;doSomething&#39;);

        myModule(2);

        expect(dependency.doSomething).toHaveBeenCalledWith(4);
      });
    });

What&#39;s the equivalent with Jest? I feel like this is such a simple thing to want to do, but I&#39;ve been tearing my hair out trying to figure it out.

The closest I&#39;ve come is by replacing the `import`s with `require`s, and moving them inside the tests/functions. Neither of which are things I want to do.

    // myModule.js
    export default (x) =&gt; {
      const dependency = require(&#39;./dependency&#39;); // Yuck
      dependency.doSomething(x * 2);
    }

    //myModule-test.js
    describe(&#39;myModule&#39;, () =&gt; {
      it(&#39;calls the dependency with double the input&#39;, () =&gt; {
        jest.mock(&#39;../dependency&#39;);

        myModule(2);

        const dependency = require(&#39;../dependency&#39;); // Also yuck
        expect(dependency.doSomething).toBeCalledWith(4);
      });
    });

For bonus points, I&#39;d love to make the whole thing work when the function inside `dependency.js` is a default export. However, I know that spying on default exports doesn&#39;t work in Jasmine (or at least I could never get it to work), so I&#39;m not holding out hope that it&#39;s possible in Jest either.

  [1]: https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_%E2%80%93_ECMAScript_2015
  [2]: https://en.wikipedia.org/wiki/Jasmine_(JavaScript_testing_framework)


How can I mock an ES6 module import using Jest?

I&#39;m having issues raising an exception from a function in my test:


    ### Implemetation
    def MethodToTest():
        myVar = StdObject()
        try:
            myVar.raiseError() # &lt;--- here
            return True
        except Exception as e:
            # ... code to test
            return False

    ### Test file
    @patch(&#39;stdLib.StdObject&#39;, autospec=True)
    def test_MethodeToTest(self, mockedObjectConstructor):
        mockedObj = mockedObjectConstructor.return_value
        mockedObj.raiseError.side_effect = Exception(&#39;Test&#39;) # &lt;--- do not work
        ret = MethodToTest()
        assert ret is False


I would like to `raiseError()` function to raise an error.

I found several examples on SO, but none that matched my need.

Python, mock: raise exception

Let&#39;s say I have this

    export class QuestionnaireQuestionsComponent {

        questions: Question[] = [];
        private loading:boolean = true;


        constructor(
            private route: ActivatedRoute,
            public questionnaireService:QuestionnaireService) {}

        ngOnInit(){
            this.route.parent.params.subscribe((params:any)=&gt;{
                this.questionnaireService.getQuestionsForQuestionnaire(params.id).subscribe((questions)=&gt;{
                    this.questions = questions;
                    this.loading = false;
                });
            });
        }

   
    }

My component is actually working pretty well. Problem is that I want to unit test it but I can&#39;t figure out how to mock the `this.route.parent` object. Here&#39;s my test that fails

    beforeEach(()=&gt;{
        route = new ActivatedRoute();
        route.parent.params = Observable.of({id:&quot;testId&quot;});
        
        questionnaireService = jasmine.createSpyObj(&#39;QuestionnaireService&#39;, [&#39;getQuestionsForQuestionnaire&#39;]);
        questionnaireService.getQuestionsForQuestionnaire.and.callFake(() =&gt; Observable.of(undefined));
        component = new QuestionnaireQuestionsComponent(route, questionnaireService);
    });


    describe(&quot;on init&quot;, ()=&gt;{
        it(&quot;must call the service get questions for questionnaire&quot;,()=&gt;{
            component.ngOnInit();
            expect(questionnaireService.getQuestionsForQuestionnaire).toHaveBeenCalled();
        });  
    });

The test fails with this error 

    TypeError: undefined is not an object (evaluating &#39;this._routerState.parent&#39;) 

How to mock an activatedRoute parent Route in angular2 for testing purposes?

I need to test a function which opens a new tab in the browser

    openStatementsReport(contactIds) {
      window.open(`a_url_${contactIds}`);
    }

I would like to mock the window&#39;s `open` function so I can verify the correct URL is passed in to the `open` function.

Using Jest, I don&#39;t know how to mock the `window`. I tried to set `window.open` with a mock function but this way doesn&#39;t work. Below is the test case

    it(&#39;correct url is called&#39;, () =&gt; {
      window.open = jest.fn();
      statementService.openStatementsReport(111);
      expect(window.open).toBeCalled();
    });

But it gives me the error

```lang-none
expect(jest.fn())[.not].toBeCalled()

jest.fn() value must be a mock function or spy.
    Received:
      function: [Function anonymous]
```

What should I do to the test case?





How can I mock the JavaScript window object using Jest?

How can I use injection with Mockito and JUnit 5?

In JUnit4 I can just use the `@RunWith(MockitoJUnitRunner.class) ` Annotation. In JUnit5 is no `@RunWith` Annotation?

How to use Mockito with JUnit5

I am attempting to mock a public class, however when doing so, Mockito throws an `Mockito cannot mock this class` exception.

Class I wish to mock: https://github.com/scribejava/scribejava/blob/master/scribejava-core/src/main/java/com/github/scribejava/core/builder/ServiceBuilder.java

Test code:

    package xyz.jacobclark.adapter;
    
    import com.github.scribejava.apis.TwitterApi;
    import com.github.scribejava.core.builder.ServiceBuilder;
    import com.github.scribejava.core.model.OAuth1RequestToken;
    import com.github.scribejava.core.oauth.OAuth10aService;
    import org.junit.Assert;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.mockito.Mock;
    import org.mockito.junit.MockitoJUnitRunner;
    
    import java.io.IOException;
    
    import static org.hamcrest.Matchers.is;
    import static org.hamcrest.core.IsInstanceOf.any;
    
    @RunWith(MockitoJUnitRunner.class)
    public class TwitterOAuthAdapterTest {
        @Mock
        ServiceBuilder serviceBuilder;
    
        @Test
        public void getRequestTokenShouldReturnAValidRequestToken() throws IOException {
            class TwitterOAuthAdapter {
                private final OAuth10aService service;
    
                public TwitterOAuthAdapter(ServiceBuilder serviceBuilder){
                    this.service = serviceBuilder
                        .apiKey(&quot;&quot;)
                        .apiSecret(&quot;&quot;)
                        .build(TwitterApi.instance());
                }
    
                public OAuth1RequestToken getRequestToken() throws IOException {
                    return this.service.getRequestToken();
                }
            }
    
            TwitterOAuthAdapter oAuthAdapter = new TwitterOAuthAdapter(serviceBuilder);
            Assert.assertThat(oAuthAdapter.getRequestToken(), is(any(OAuth1RequestToken.class)));
        }
    }


Full stacktrace:

    xyz.jacobclark.adapter.TwitterOAuthAdapterTest
    
    org.mockito.exceptions.base.MockitoException: 
    Mockito cannot mock this class: class com.github.scribejava.core.builder.ServiceBuilder.
    
    Mockito can only mock non-private &amp; non-final classes.
    If you&#39;re not sure why you&#39;re getting this error, please report to the mailing list.
    
    
    Java               : 1.8
    JVM vendor name    : Oracle Corporation
    JVM vendor version : 25.0-b70
    JVM name           : Java HotSpot(TM) 64-Bit Server VM
    JVM version        : 1.8.0-b132
    JVM info           : mixed mode
    OS name            : Mac OS X
    OS version         : 10.11.3
    
    
    Underlying exception : java.lang.IllegalArgumentException: object is not an instance of declaring class
    
    	at org.mockito.internal.runners.SilentJUnitRunner$1.withBefores(SilentJUnitRunner.java:29)
    	at org.junit.runners.BlockJUnit4ClassRunner.methodBlock(BlockJUnit4ClassRunner.java:276)
    	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    	at org.mockito.internal.runners.SilentJUnitRunner.run(SilentJUnitRunner.java:39)
    	at org.mockito.internal.runners.StrictRunner.run(StrictRunner.java:39)
    	at org.mockito.junit.MockitoJUnitRunner.run(MockitoJUnitRunner.java:103)
    	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:117)
    	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:42)
    	at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:262)
    	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:84)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:483)
    	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
    Caused by: java.lang.IllegalArgumentException: object is not an instance of declaring class
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:483)
    	at net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeArgument.resolve(TypeDescription.java:3843)
    	at net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Delegator$Chained.resolve(TypeDescription.java:3468)
    	at net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeArgument.resolve(TypeDescription.java:3803)
    	at net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Delegator.asList(TypeDescription.java:3439)
    	at net.bytebuddy.description.type.TypeDescription$Generic$OfWildcardType$ForLoadedType.getDeclaredAnnotations(TypeDescription.java:4748)
    	at net.bytebuddy.description.type.TypeDescription$Generic$Visitor$TypeVariableErasing.onWildcard(TypeDescription.java:680)
    	at net.bytebuddy.description.type.TypeDescription$Generic$Visitor$TypeVariableErasing.onWildcard(TypeDescription.java:663)
    	at net.bytebuddy.description.type.TypeDescription$Generic$OfWildcardType.accept(TypeDescription.java:4656)
    	at net.bytebuddy.description.type.TypeDescription$Generic$Visitor$TypeVariableErasing.onParameterizedType(TypeDescription.java:691)
    	at net.bytebuddy.description.type.TypeDescription$Generic$Visitor$TypeVariableErasing.onParameterizedType(TypeDescription.java:663)
    	at net.bytebuddy.description.type.TypeDescription$Generic$OfParameterizedType.accept(TypeDescription.java:4998)
    	at net.bytebuddy.description.type.TypeList$Generic$AbstractBase.accept(TypeList.java:249)
    	at net.bytebuddy.description.type.TypeDescription$Generic$Visitor$TypeVariableErasing$RetainedTypeVariable.getUpperBounds(TypeDescription.java:832)
    	at net.bytebuddy.description.type.TypeDescription$Generic$OfTypeVariable.asErasure(TypeDescription.java:5373)
    	at net.bytebuddy.description.method.MethodDescription$AbstractBase.asTypeToken(MethodDescription.java:701)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default$Key$Harmonized.of(MethodGraph.java:881)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default$Key$Store.registerTopLevel(MethodGraph.java:1074)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.doAnalyze(MethodGraph.java:588)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.analyze(MethodGraph.java:548)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.analyzeNullable(MethodGraph.java:567)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.doAnalyze(MethodGraph.java:581)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.compile(MethodGraph.java:521)
    	at net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$AbstractBase.compile(MethodGraph.java:442)
    	at net.bytebuddy.dynamic.scaffold.MethodRegistry$Default.prepare(MethodRegistry.java:480)
    	at net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:160)
    	at net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:153)
    	at net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase.make(DynamicType.java:2568)
    	at net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase$Delegator.make(DynamicType.java:2670)
    	at org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:84)
    	at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$CachedBytecodeGenerator.getOrGenerateMockClass(TypeCachingBytecodeGenerator.java:91)
    	at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:38)
    	at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:67)
    	at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:38)
    	at org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:26)
    	at org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)
    	at org.mockito.internal.MockitoCore.mock(MockitoCore.java:63)
    	at org.mockito.Mockito.mock(Mockito.java:1637)
    	at org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:33)
    	at org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)
    	at org.mockito.internal.configuration.DefaultAnnotationEngine.createMockFor(DefaultAnnotationEngine.java:39)
    	at org.mockito.internal.configuration.DefaultAnnotationEngine.process(DefaultAnnotationEngine.java:63)
    	at org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:59)
    	at org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:43)
    	at org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:67)
    	... 23 more
    
    
    Test ignored.
    Process finished with exit code 255



Mockito cannot mock this class

I&#39;m trying to make a unit test with `@InjectMocks` and `@Mock`.

    @RunWith(MockitoJUnitRunner.class)
    public class ProblemDefinitionTest {
    
        @InjectMocks
        ProblemDefinition problemDefinition;
    
        @Mock
        Matrix matrixMock;    
       
        @Test
        public void sanityCheck() {
            Assert.assertNotNull(problemDefinition);
            Assert.assertNotNull(matrixMock);
        }
    }

When I don&#39;t include the `@RunWith` annotation, the test fails. But

&gt; The type MockitoJUnitRunner is deprecated

I&#39;m using Mockito 2.6.9. How should I go about this?

MockitoJUnitRunner is deprecated

I&#39;m getting following exception once tests is started:

        Testcase: treeCtorArgumentTest(com.xythos.client.drive.cachedtree.CachedTreeTest):	Caused an ERROR
    Could not initialize plugin: interface org.mockito.plugins.MockMaker
    java.lang.IllegalStateException: Could not initialize plugin: interface org.mockito.plugins.MockMaker
    	at org.mockito.internal.configuration.plugins.PluginLoader$1.invoke(PluginLoader.java:66)
    	at com.sun.proxy.$Proxy7.isTypeMockable(Unknown Source)
    	at org.mockito.internal.util.MockUtil.typeMockabilityOf(MockUtil.java:29)
    	at org.mockito.internal.util.MockCreationValidator.validateType(MockCreationValidator.java:22)
    	at org.mockito.internal.creation.MockSettingsImpl.validatedSettings(MockSettingsImpl.java:168)
    	at org.mockito.internal.creation.MockSettingsImpl.confirm(MockSettingsImpl.java:162)
    	at org.mockito.internal.MockitoCore.mock(MockitoCore.java:64)
    	at org.mockito.Mockito.mock(Mockito.java:1687)
    	at org.mockito.Mockito.mock(Mockito.java:1600)
    	at com.xythos.client.drive.cachedtree.CachedTreeTest.setUp(CachedTreeTest.java:51)
    Caused by: java.lang.NoClassDefFoundError: net/bytebuddy/dynamic/loading/ClassLoadingStrategy
    	at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.&lt;init&gt;(SubclassByteBuddyMockMaker.java:33)
    	at org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.&lt;init&gt;(ByteBuddyMockMaker.java:22)
    	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    	at java.lang.Class.newInstance(Class.java:442)
    	at org.mockito.internal.configuration.plugins.PluginLoader.loadPlugin(PluginLoader.java:54)
    	at org.mockito.internal.configuration.plugins.PluginRegistry.&lt;init&gt;(PluginRegistry.java:18)
    	at org.mockito.internal.configuration.plugins.Plugins.&lt;clinit&gt;(Plugins.java:17)
    	at org.mockito.internal.util.MockUtil.&lt;clinit&gt;(MockUtil.java:24)
    Caused by: java.lang.ClassNotFoundException: net.bytebuddy.dynamic.loading.ClassLoadingStrategy
    	at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
    	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
    	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)

This is my test:

    package com.xythos.client.drive.cachedtree;
    
    import org.junit.After;
    import org.junit.AfterClass;
    import org.junit.Before;
    import org.junit.BeforeClass;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.mockito.junit.MockitoJUnitRunner;
    
    @RunWith(MockitoJUnitRunner.class)
    
        public class CachedTreeTest {
        
            public CachedTreeTest() {
            }
        
            @Test
            public void treeCtorArgumentTest() {
        	somemock m = mock(SomeClass.class);
            }
        }

I&#39;m using NetBeans 8.2. I&#39;ve downloaded mockito-core-2.7.0.jar, and then I select &quot;Test Libraries&quot;-&gt;&quot;Add Jar&quot; and added mockito-core-2.7.0.jar.

Classpath and everything looks ok, I&#39;,m still getting exception.

Any advice?

Could not initialize plugin: interface org.mockito.plugins.MockMaker

In TypeScript, you can annotate a function as returning `void`:

    function fn1(): void {
      // OK
    }

    function fn2(): void {
      // Error
      return 3;
    }

You can also annotate a function to return `undefined`:

    function fn3(): undefined {
      // OK
      return;
    }

    function fn4(): undefined {
      // Error
      return 3;
    }

So it seems that if you call a function returning `void`, you&#39;ll always get back the value `undefined`. Yet you can&#39;t write this code:

    function fn5(): void {
    }
    let u: undefined = fn5(); // Error


Why isn&#39;t `void` just an alias for `undefined`? Does it need to exist at all?

Why does TypeScript have both `void` and `undefined`?

I am reading a book ([Programming with POSIX Threads](https://smile.amazon.com/dp/0201633922) by Butenhof, 1997) that uses C, and I came across the following line:

```
(void)free(data);
```

Here, `data` is just a pointer to an allocated struct,

```
data = malloc(sizeof(my_struct_t));
```

Why is the result of `free` being cast to `void`?

From my understanding of C, this doesn&#39;t seem to make sense for two reasons:

 -  The free function already returns `void`
 -  The code is not using the return value (it&#39;s not even being assigned to a variable)

The book was written in 1997. Is this some sort of legacy thing?

The author mentions that the examples were run on Digital Unix 4.0d, but I still can&#39;t imagine a reason to ever cast the result of a function if you&#39;re not going to use that result.

Content Type	Original Author	Original Content on Stackoverflow
Question	CRDamico	View Question on Stackoverflow
Solution 1 - Unit Testing	Jeff Bowman	View Answer on Stackoverflow

Mockito - thenCallRealMethod() on void function

Unit Testing Problem Overview

Unit Testing Solutions

Solution 1 - Unit Testing

Typescript 2.0. "types" field in tsconfig.json

FFMPEG- Convert video to images

Attributions