You never initialize the filter field in the test class

NoiseFilter filter;
SensorData dataSet;


@Before
public void setUp() throws Exception {
    this.dataSet = new SensorData();
    dataSet.setFilter(filter);
}

so it is null here and that reference propagates to the SensorData object you are testing.

public void setFilter(NoiseFilter filterVar) {
    this.filter = filterVar;
}

filterVar is null when you call the above.

You have to initialize it with an implementation of your interface, such as your AveragingFilter:

@Before
public void setUp() throws Exception {
    this.filter = new AveragingFilter(); // or something like it
    this.dataSet = new SensorData();
    dataSet.setFilter(filter);
}

Also, you are testing for null in a few places using this pattern:

if( x.equals( null ) ) {...

This will not work, because this is calling the equals(Object) method on the object x. In Java, null does not have any methods. You always have to check for null against its identity, using the == operator. Your examples should read:

if( x == null ) { ...

I believe you want to use fail here:

@Test(expected=NullPointerException.class)
public void testNullInput() {
    fail(nullString.indexOf(3));
}

Make sure to add import static org.junit.Assert.fail; if you need to.

This is the right way to do it:

@Before
public void setUp() {
    p1 = new Person ("Thomas", "Brown");
}

You have 2 problems in your code.

public PersonTest() {
    Person p1 = new Person ("Thomas", "Brown");
}

This creates a local variable and your field p1 stays null.

The second is that in your setUp method you do not initialize p1.

The method you annotate with @Before will run before every test to you should put the initialization there. I also suggest to use more descriptive names so you should change p1 to target or something like that.

Edit: For your set... methods you can do something like this:

public class PersonTest {
    private static final String TEST_FIRST_NAME = "some name";

    Person target;

    // ...
    @Test
    public void testSetFirstName() {
        target.setFirstName(TEST_FIRST_NAME);
        Assert.assertEquals(target.getFirstName(), TEST_FIRST_NAME);
    }
}

At that point you can assume that getFirstName works since you have a test for it as well.

A sidenote: I think you don't have to test getters and setters as long as you generate them with Eclipse. It is just unnesessary.

Edit:
For JUnit5 and mockito refer to this answer:
How to use Mockito with JUnit5
I've updated the example below as well.

Edit2: As the TO did not state which JUnit version or mockito version is being used, I will try to edit the answer if still does not work.

Thanks to @helospark for poining this out.

Using the Runner or the Rule does not work with JUnit5, so probably Mockito Version 2 should be used.

With Mockito Version 1 , an explictly call to the init Method is required.

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

For Junit5 and the latest Mockito version (2.27) the test class should look like this:

class InnerClass {
    public void doSomething(String fileName) {
    }
}

class SomeClass {

    InnerClass innerClass;

    public boolean doSomething(String fileName) {
        innerClass.doSomething(fileName);
        return true;
    }
}

@ExtendWith(MockitoExtension.class)
class SomeClassTest {

    @InjectMocks
    SomeClass someClass;

    @Mock
    InnerClass innerClass;

    @Test
    public void test() {
        someClass.doSomething("test");
        Mockito.verify(innerClass, Mockito.times(1)).doSomething(Mockito.any());
    }
}

The null pointer exception is not in your code. Neither is there an error in the code which throws the exception.

The issue is in how you are using the API. You can't use most JavaFX APIs without starting up the JavaFX platform on which the API implementations rely. You haven't done that in your tests that I can see. The Application javadoc explains the JavaFX lifecycle and how it is used.

What is needed is to startup the JavaFX platform, run a test (or tests) then exit the platform after all tests have been run.

If you want to use junit to test code that uses JavaFX, IMO it is best to use a 3rd party framework that supports that (e.g. TestFX). I advise this over trying to manually manage the JavaFX platform state in the code that you write.

Alternately, you can separate out much of your code logic from JavaFX code (this is a good idea in any case), and test the non-JavaFX logic independently using standard testing tools like junit, then test the UI elements manually.

Your tests and API design are strange. You have:

view.setNum_Player(new TextField("4"));
Assertions.assertEquals(4, view.getNum_Player());

You set the number of players to a TextField, but when you get the number of players, you expect an integer. That doesn't make a lot of sense. If you get and set a value on a bean, it should get and set the same value and type by convention. In your case, it should be an integer, not a TextField.

Use

@Test(expected=NullPointerException.class)

instead of

@Test

and the error-message will go away.

This looks like you trying to mix an integration test with unit tests.

When you use the @SpringBootTest annotation then SpringExtension for Junit5 starts an application context before running your test, and to make mocks in tests you need to use @MockBean annotation instead of @Mock & @InjectMocks. This is a different scope of tests.

As I see, you need just a unit test and you can remove the SpringBootTest annotation.

By the way, I think you got NPE because of you any(Course.class) in when(courseRepo.... Try to use isNull() or any() (without specification concrete class).

From what you have shown, you are not initializing your mock's. There are cleaner ways to do this (which varies based on if you are using JUnit 4 or 5, so please specify if you would like help with that), but for the sake of finding the problem, can you try the following setup method:

@BeforeEach
void setUp() {
    orderDao = Mockito.mock(OrderDao.class);
    orderService = new OrderServiceImpl(orderDao);
}

greenLeftArrow is not initialized to a value (it's automatically initialized to null) so calling greenLeftArrow.isOn() in the PhaseOneInitialization method will throw a NullPointerException.