Let me first rewrite your example into something that compiles fine:
{code starts}
class Abc {
public void init() {
XyzConfiguration xyz = XyzConfiguration.getInstance();
xyz.configureXyz();
}

public void someMethod() {
System.out.println(“Some method works fine”);
}
}

/** Singleton that holds the configuration for XYZ */
class XyzConfiguration {
private static XyzConfiguration XYZ_CONFIGURATION = null;

/** This class is not instantiable from outside. Use {@link #getInstance}. */
private XyzConfiguration() {
}

public static XyzConfiguration getInstance() {
if (XYZ_CONFIGURATION == null) {
XYZ_CONFIGURATION = new XyzConfiguration();
}
return XYZ_CONFIGURATION;
}

public void configureXyz() {
System.out.println(“Configure XYZ”);
}
}

public class AbcTest {
Abc abc;

@Before
public void setUp() {
abc = new Abc();
abc.init();
}

@Test
public void testSomeMethod() {
abc.someMethod();
// Assert something, to make sure it worked…
}
}
{code ends}

Now, if the configuration implies using a production system, writing into a database and whatnot, this test will be slow and dangerous.

To fix this, let’s apply dependency injection, and this is the final result:

{code begins}
class Abc {
private final XyzConfiguration xyz;

public Abc(XyzConfiguration xyz) {
this.xyz = xyz;
}

public void init() {
xyz.configureXyz();
}

public void someMethod() {
System.out.println(“Some method works fine”);
}
}

interface XyzConfiguration {
public void configureXyz();
}

/** Singleton that holds the configuration for XYZ */
class DefaultXyzConfiguration implements XyzConfiguration {
private static XyzConfiguration XYZ_CONFIGURATION = null;

/** This class is not instantiable from outside. Use {@link #getInstance}. */
private DefaultXyzConfiguration() {
}

public static XyzConfiguration getInstance() {
if (XYZ_CONFIGURATION == null) {
XYZ_CONFIGURATION = new DefaultXyzConfiguration();
}
return XYZ_CONFIGURATION;
}

@Override
public void configureXyz() {
System.out.println(“Configure XYZ”);
}
}

public class AbcTest {
Abc abc;

@Before
public void setUp() {
abc = new Abc(new FakeXyzConfiguration());
abc.init();
}

@Test
public void testSomeMethod() {
abc.someMethod();
// Assert something, to make sure it worked…
}

class FakeXyzConfiguration implements XyzConfiguration {
@Override
public void configureXyz() {
System.out.println(“Lightweight configuration, just for testing”);
}
}
}
{code ends}

Now you can test Abc in isolation. And, as a bonus, now your Abc class doesn’t even notice about changes in the implementation of XYZ configuration. Now it is only aware of the interface.

Hope it helps, and sorry that the code is not properly formatted!

I am learning mockito and unittesting.

I am writing testcase for a Class , which Uses singleton class instance inside one method. The method that gives the instance is “Static”.

for ex:

public class abc{

public init(){
XYZConfiguration xyz = XYZConfiguration.getInstance();
}

}

// This class is initialized with SPRING
// Singleton Class
public class XYZConfiguration {

private static XYZConfiguration = null;

public static getInstance() {

if(XYZConfiguration ==null)
throw new exception();
else
return XYZConfiguration;
}

}

can you suggest me any idea, how to use mock and spy on this ??

Thanks,
Bhavin

Still, sometimes there are trade-offs to make. What can easily happen with dependency injection is that your constructors end up having too many arguments. Another problem is that some classes are just forwarding objects that they don’t even need to others.

To alleviate this, you can “start the dependency injection later”: let a selected group of central classes get the server instance, and inject from there.

Not sure I made my point. It’s sort of difficult to explain without an example and with my limited literary skills