We Keep Coding

Helger JCodeModel not used static import for 2 classes have the same name

This is what I want:
import com.abc.ClassA;
public class TestClass {
private ClassA firstClass;
private com.xyz.ClassA secondClass;
}
This is what I got:
public class TestClass {
private com.abc.ClassA firstClass;
private com.xyz.ClassA secondClass;
}
I am using com.helger.jcodemodel with CodeModel.ref("com.abc.ClassA") and CodeModel.ref("com.xyz.ClassA")

How to get the class of the genereric parameter of a Interface from the interface

I have this Interface:
public interface Test<T> {
default Class<?> getT() {
return T.getClass(); < --error
}
}
next i have a class that implements it:
static class ItemService implements Test<Item>{
}
And i want to get the 'Item' class from the 'ItemService' class
static ItemService service = new ItemService();
private static void k() {
System.out.println(service.getT());
}
Now one way to do it is this:
public interface Test<T> {
default Class<?> getT() {
return Type.type;
}
class Type {
public static Class<?> type;
}
}
Service:
static class ItemService implements Test<Item> {
public ItemService() {
Type.type = Item.class;
}
}
And it works fine but there is a problem,
When another class implement the interface:
static class OrderService implements Test<Order> {
public OrderService() {
Type.type = Order.class;
}
}
And i try:
static ItemService service = new ItemService();
static OrderService orderservice = new OrderService();
private static void k() {
System.out.println(service.getT());
}
I get the Order class and not the Item class
How can i make it work?

Classes inside interfaces are static, You can remove the default from the function and every class will need to implement this. example:
public interface Test<T> {
public Class<T> getT();
}
static class ItemService implements Test<Item> {
public Class<Item> getT() {return Item.class;}
}
static class OrderService implements Test<Order>{
public Class<Order> getT() {return Order.class;}
}

An alternative could be an abstract class.
public interface Test<T> {
public Class<T> getT();
}
abstract class AbstractTest<T> implements Test<T> {
private final Class<T> type;
AbstractItemService(Class<T> type) { this.type = type }
public Class<T> getT() {return type;}
}
class ItemService extends AbstractTest<Item> {
ItemService() { super(Item.class); }
// implement other things
}
class OrderService extends AbstractTest<Order>{
OrderService() { super(Order.class); }
// implement other things
}

Here is another option, if your implementation has an instance of T.
interface Test<T>{
T getT();
default Class<?> getClassOfT(){
return getT().getClass();
}
}

Why is "isModifiedByPowermock returning false with #PrepareForTest?

Using Powermock 2.0.7 (powermock-api-mockito2, powermock-core, powermock-module-junit4) and mockito-core (3.3.3). I thought I had created a comparable test scenario in a separate project (which worked), but something else must be missing.
Library class to be mocked:
public class CommonConstants {
private ConfigurationDataImpl configurationData;
private static Properties sysProperties;
private static Map<String, String> sysPermissions;
public CommonConstants(ConfigurationDataImpl configurationData) {
this.configurationData = configurationData;
}
public void init() {
sysProperties = this.configurationData.getSysParams();
sysPermissions = this.configurationData.getSysPermissions();
}
public static String getSysProperties(String key) {
return sysProperties.getProperty(key);
}
public static String getSysPermissions(String key) {
return (String)sysPermissions.get(key);
}
}
In my test, I have:
#RunWith(PowerMockRunner.class)
#PrepareForTest({CommonConstants.class}) <==== class that evidently is not modified!
class MyServiceTest {
public MyServiceTest() {}
#Mock
private MyDao myDao;
#InjectMocks
private MyService myService;
#Test
void retrieveUsers() {
RequestPayload rp = returnPayload();
PowerMockito.mockStatic(CommonConstants.class); <==== EXCEPTION
when(CommonConstants.getSysProperties(HOURS_TO_REGISTER)).thenReturn("24");
...
In the service code, I have:
#Service
#Slf4j
public class MyService {
MyDao myDao;
public MyService(MyDao myDao) {
this.myDao = myDao;
}
public UserListResponse retrieveUsers(RequestPayload requestPayload, String customer) {
List<User> users = myDao.getPtdUsers(queryParams, customer, totalRecords);
int hoursToExpire = Integer.parseInt(CommonConstants.getSysProperties(HOURS__TO_REGISTER));
...
Am I leaving out something? All help appreciated.

How unit test private class

How can we unit test private class ?
For example with an example of private class #Autowired with qualifier
I would like to verify if the good qualifier is call
public class MyClass {
#Autowired
IHelloService helloService;
public void sayHello(List<Person> list) {
for(Person person : list) {
helloService.sayHello(person);
}
}
}
.
#Primary
#Component
public class SayHelloService implements ISayHello {
#Autowired
#Qualifier("french")
ISayHello french;
#Autowired
#Qualifier("english")
ISayHello english;
#Override
public void sayHello(Person person) {
switch (person.getLanguage) {
case "EN":
english.sayHello(Person person);
break;
case "FR":
french.sayHello(Person person);
break;
default:
break;
}
}
}
.
#Qualifier("french")
Component
class SayHelloFrenchService implements ISayHello {
public void sayHello(Person person) {
sysout("Bonjour " + person.getName());
}
}
#Qualifier("english")
Component
class SayHelloFrenchService implements ISayHello {
public void sayHello(Person person) {
sysout("Hello " + person.getName());
}
}
Edit:
I failed my example: the twice qualifier class were private

If i #Mock the interface it works.
I thought i must #Mock the implementation...
But i can't write tests of implementation of private class.

Mocking super class method

How to mock super method call from mocked method
public class A extends B{
#Override
public retrieveData(){
//some action here
super.retrieveData();
}
}
abstract class B extends C{
//init super fields here
}
public class C{
public String retrieveData(){
//some return
}
}
Public Atest{
#InjectMock
A a;
#Mock
C parent; //also tryed for B but the same effect
#Before
public void setup() {
MockitoAnnotations.initMocks(this);
}
#Test
public void testDetailsRetrievePageList(){
when(parent.retrieveData()).thenReturn("stub");
String s = a.retrieveListData();
Assert.assertEquals("stub", s);
}
}
Didn't help Mockito How to mock only the call of a method of the superclass and post like that.
everytime my super is null in A class