Develop Reference

Why java compile is not invoking a method which is present inside a method

I am working on Cucumber java project and which is in very initial phase . While writing the code in step definition file. I found there is data required in Step N which is present only in Step N-1 i.e Sharing of data between cucumber test steps .As the project is in very initial phase . I thought implementation setter() and getter() method will work for me i.e is setter() I will set the value of variable and the call the getter() method whenever i need this data
Kindly find the actual implementation.
StepDefinition:
#Given("^recent destination list$")
public void list_of_recent_destinations_is_non_empty() throws Throwable {
gm.appLaucher();
gm.setValue_searchAddressOrName_HomeScreen("Wemmel");
gm.click_selectAddress_HomeScreen();
gm.click_driveButton_OnMapScreen();
gm.click_clearRouteButton_OnMapScreen();
gm.setValue_searchAddressOrName_HomeScreen("Ukkel, Beersel,1180");
gm.click_selectAddress_HomeScreen();
gm.click_driveButton_OnMapScreen();
gm.click_clearRouteButton_OnMapScreen();
gm.setValue_searchAddressOrName_HomeScreen("Sint-Jansplein Brussel, 1000");
gm.click_selectAddress_HomeScreen();
gm.click_driveButton_OnMapScreen();
gm.click_clearRouteButton_OnMapScreen();
gm.click_mainMenuButton_OnMapScreen();
gm.tap_recentDestinationButton_OnMainMenuScreen();
gm.tap_editListButton_RecentDestinationScreen();
List<MobileElement> em1= gm.get_recentDestinaList_EditListScreen();
System.out.println("____________________________________________"+em1.size());
int numOfElement=em1.size()-2;
boolean status =em1.size()>0;
Assert.assertEquals(true,status);
}
#When("^user selects one or more $")
public void user_selects_one_or_more_recent_destinations() throws Exception {
List<MobileElement> em1= gm.get_recentDestinaList_EditListScreen();
System.out.println("____________________________________________"+em1.size());
Iterator<MobileElement> it=em1.iterator();
while(it.hasNext())
{
System.out.println(it.next().getText());
}
String str= gm.getIndividualElement_recentDestinationList_EditListScreen(2);
System.out.println(str+"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
}
#When("^user deletes address$")
public void user_deletes_selected_addresses() throws Exception {
gm.setValueForOtherSteps(gm.get_recentDestinaList_EditListScreen().size());
gm.deleteIndividualElememnt_recentDestinationList_EditListScreen(2);
}
#Then("^recent\\(s\\) is\\(are\\) removed from list$")
public void recent_destination_s_is_are_removed_from_list() throws Exception {
// Write code here that turns the phrase above into concrete actions
System.out.println(gm.getValueFromOtherStep()+"Intermidiate value from Step definition class");
int x=gm.getSize_recentDestinationList_EditListScreen();
System.out.println(x+"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
String strLastElement=gm.getIndividualElement_recentDestinationList_EditListScreen(3);
String strSecondLast=gm.getIndividualElement_recentDestinationList_EditListScreen(2);
int y=gm.getSize_recentDestinationList_EditListScreen();
Assert.assertEquals(x, y);
// Assert.assertEquals(strLastElement, strSecondLast);
// gm.tap_editListButton_RecentDestinationScreen();
//
// gm.deleteAllElement_recentDestinationList_EditListScreen();
}
#Then("^recent desorted in temporal order$")
public void recent_destinations_list_is_sorted_in_temporal_order() throws Exception {
// Write code here that turns the phrase above into concrete actions
}
In Above gm is object of GMain class kindly find the implementation as below
class GMain{
public void setValueForOtherSteps(Object obj) throws IOException {
System.out.println(obj+"Intermediate values to verify +++++++++++++++++++++++++++++++++++++++");
getValueFromOtherStep();
}
public Object getValueFromOtherStep()
{
if(getValue() instanceof Integer) {
System.out.println((Integer)getValue()+" test");
return (Integer) getValue();
}
else if (getValue() instanceof String)
{
return (String) getValue();
}
else if (getValue() instanceof Boolean)
{
return (Boolean) getValue();
}
else {
System.out.print(getValue());
return "";
}
}
So as we call setValueForOtherSteps() from stepDefinition ,Control comes to GMain class method public void setValueForOtherSteps(Object obj) but why transfer goes back to caller without calling getValueFromOtherStep() method
I know this may be silly but Any kind of help will be appreciated
Thanks

Java Array of InnerClass throwing java.lang.NoSuchFieldError

I am trying to brushup java after a long time.
Any help is much appreciated.
For demonstration I have Animal Class that has an array of innerclass of Organs.
public class Animal
{
String nameOfAnimal;
Organs [] vitalOrgans = new Organs[3];
public Animal()
{
}
public String getNameOfAnimal() {
return nameOfAnimal;
}
public void setNameOfAnimal(String nameOfAnimal) {
this.nameOfAnimal = nameOfAnimal;
}
#Override
public String toString() {
return "Animal{" + "nameOfAnimal=" + nameOfAnimal + "}";
}
class Organs{
String nameOfOrgan;
public String getNameOfOrgan() {
return nameOfOrgan;
}
public void setNameOfOrgan(String nameOfOrgan) {
this.nameOfOrgan = nameOfOrgan;
}
#Override
public String toString() {
return "Organs{" + "nameOfOrgan=" + nameOfOrgan + '}';
}
}
}
Now in driver file when I make call there is no syntactical error but I get "Exception in thread "main" java.lang.NoSuchFieldError: vitalOrgans"
Animal mamal = new Animal();
mamal.setNameOfAnimal("Chimp");
mamal.vitalOrgans[0].setNameOfOrgan("Heart");
System.out.println(mamal.vitalOrgans[0].getNameOfOrgan());
What would be the way to make this (or similar idea) to work.
Thanks.

You would need to initialize the vitalOrgrans with new Organs(). Like:
public Animal() {
for (int i = 0; i < vitalOrgans.length; i++) {
vitalOrgans[i] = new Organs();
}
}
Because when you say :
Organs[] vitalOrgans = new Organs[3];
You are creating an array of 3 null Organs. Hence the null pointer exception, when accessing "vitalOrgans[i].".

Taking the relevant bit of code:
public class Animal
{
//...
Organs [] vitalOrgans = new Organs[3];
//...
}
Since your declaration of vitalOrgans was never given an access modifier (i.e. one of private, public, protected) it took on default access, which means only other classes in the same package can see it. Since your other block of code is not in the same package, it cannot see the field.
A minimally viable modification to just make it work would be to set the access to public:
public class Animal
{
//...
public Organs [] vitalOrgans = new Organs[3];
//...
}
While this works, it's not necessarily the best solution, as if you ever change how vitalOrgans is represented, or need to perform any validation, those edits would have to be done throughout the application. Thus, a better solution (and also, a major stylistic convention in Java for those exact reasons) is to make it (and all your fields, in fact) private and access via methods:
public class Animal {
private String nameOfAnimal;
private Organs[] vitalOrgans = new Organs[3];
//...
public Organs[] getVitalOrgans() {
return vitalOrgans;
}
//Alternative accessor that fetches only one organ.
public Organs getVitalOrgan(int index) {
if(index >= 0 && index < vitalOrgans.length)
return vitalOrgans[index];
else
return null;
}
public void setVitalOrgans(Organs[] vitalOrgans) {
this.vitalOrgans = vitalOrgans
}
//...
}
Your caller could then access Organs via either form of the get method (note, you probably want Organs to be public):
Animal.Organs futureMammalHeart = mamal.getVitalOrgan(0); //Animal.Organs due to Organs being an inner class.
if(futureMammalHeart != null) //Demonstration of null check. Safety first!
futureMammalHeart.setNameOfOrgan("Heart");
Animal.Organs[] mammalianVitalOrgans = mamal.getVitalOrgans();
if(mammalianVitalOrgans != null) //Just in case...
System.out.println(mamal.mammalianVitalOrgans[0].getNameOfOrgan());
Also, as Ari mentioned in his answer, don't forget to initialize the organs in your array, otherwise you will get a NullPointerException!

Creating array of methods returning boolean and iterating through for-each loop

Okay so I have a batch of methods returning boolean values of true/false.
private void saveChangesOnEditButtonActionPerformed(java.awt.event.ActionEvent evt) {
updateMainTabsAccess();
updateUserPaymentTabPermissions();
updateUserRegistrationTabPermissions();
updateUserStudentsTabPermissions();
updateUserFacultyTabPermissions();
updateUserHomePermissions(); //saves any update made on existing user settings/permissions
updateUserInformation(); // sasve any update made on existing user information such as username
}
I would like to know if it's possible for me to check each of the methods' return value through a for-each loop.
I'm thinking of creating a private boolean isUpdateSuccessful() method.
Say like,
private boolean isUpdateSuccessful(){
Boolean a = updateMainTabsAccess();
Boolean b = updateUserPaymentTabPermissions();
//........so on....
Boolean result = (a && b &&...)
return result;
}
Problem is, I don't know if it's possible to put them in an arraylist or component array like
ArrayList<Boolean> listOfMethods = new ArrayList<Boolean>(method1,method2..);
So that I can then check each through a for-each loop
for(Boolean b:listOfMethods){
Boolean successful=true;
successful = (successful && b)
}
My questions are:
1.) How do I extract the return values of these methods and use the methods to initialize the Arraylist.
2.) Using for-each loop, is there any possibility of what I'm trying to do? I none, then what do you suggest I do?
I'd appreciate any answer or suggestion. I simply want to check if every method was successful. I thought of using ?1:0:
Thanks in advance.

If I am you, I would do this. Just a sample code:
private void saveChangesOnEditButtonActionPerformed(java.awt.event.ActionEvent evt) {
if (updateMainTabsAccess()) {
if (updateUserPaymentTabPermissions()) {
if (updateUserRegistrationTabPermissions()) {
...
} else {
// error on update registration
}
} else {
// error on update payment
}
}
With the above style:
You don't execute other methods when the before one fails.
Can have detailed error messages for each error.
You need not to main a collection and iteration.

Why not use a Stream to check the results:
Stream.<Boolean>of(updateMainTabsAccess(),
updateUserPaymentTabPermissions(),
updateUserRegistrationTabPermissions(),
updateUserStudentsTabPermissions(),
updateUserFacultyTabPermissions(),
updateUserHomePermissions(),
updateUserInformation()).allMatch(b -> b);
this way you get rid of short circuit evaluation and also don't need to create method references for each method.
method references
List<Supplier<Boolean>> methods = Arrays.asList(this::updateMainTabsAccess,
this::updateUserPaymentTabPermissions,
...
);
for (Supplier<Boolean> supplier : methods) {
boolean methodResult = supplier.get();
...
}
This can hardly be considered an improvement though...

this will find all method in side your class which is return Boolean after automatically invoke method one by one and store response to successful variable
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
public class Test {
public static void main(String[] args) {
Test test = new Test();
Class c = test.getClass();
boolean successful = true;
for (Method method : c.getDeclaredMethods()) {
if (method.getReturnType().toString().equals("boolean")) {
try {
String mname = method.getName();
Object o = method.invoke(test, null);
System.out.format("%s() returned %b%n", mname, (Boolean) o);
successful = successful && (Boolean) o;
} catch (Exception e) {
e.printStackTrace();
}
}
}
System.out.println("final answer : " + successful);
}
public boolean a() {
return true;
}
public boolean b() {
return false;
}
public boolean c() {
return false;
}
}
Hope its help to you.

If you want every method to be executed and check if every method scucceded you could simply write
boolean success = updateMainTabsAccess() &
updateUserPaymentTabPermissions() &
updateUserRegistrationTabPermissions() &
updateUserStudentsTabPermissions() &
updateUserFacultyTabPermissions() &
updateUserHomePermissions() &
updateUserInformation();

You have already received some answers.
Fabian's is a good one if you are using java 8.
But to answer directly your points
1.) How do I extract the return values of these methods and use the methods to initialize the Arraylist.
ArrayList<Boolean> resultsList = new ArrayList<Boolean>();
resultsList.add(updateMainTabsAccess());
...
2.) Using for-each loop, is there any possibility of what I'm trying to do? I none, then what do you suggest I do?
boolean res = true;
for (Boolean singleResult : resultsList) {
res = res && singleResult;
}

Here is the old style way to acheive your goal when Lambdas weren't introduced by Java 8.
public class TestMethodsListCall {
public abstract class Checker {
public abstract boolean check();
}
public static void main(String[] args) {
new TestMethodsListCall();
}
public TestMethodsListCall() {
final TestMethodsListCall that = this;
List<Checker> checkers = Arrays.asList( //
new Checker() { public boolean check() { return that.methodA(); } }, //
new Checker() { public boolean check() { return that.methodB(); } } //
// , ...
);
boolean res = true;
for (Checker c : checkers) {
res = res & c.check();
if (!res) {
// Break, display some message or all together
}
}
}
public boolean methodA() {
return true;
}
public boolean methodB() {
return false;
}
}

Strange Java error placement

Still working on the same project (Java-based shell) and tried to run it - and got a strange error. I was working with a single class that represents one of the commands, and, because of the fact that school computers have no compilers, I use ideone. Anyway, I am getting an error and, while I have seen it before, the placement is really weird. The error:
Main.java:56: error: no enclosing instance of type LIST_Command is in scope
public FAKE_CMD(int i) {this.msg = i;System.out.println(i);}
^
Shouldn't this be in a place that is CALLING the constructor, or a static method of the class?
And here is the code (in its entirety, let me know what I should trim or edit it out yourself) Yes, this makes it an SSCCE.
package javashell.ver2.command;
import java.io.*;
import java.util.*;
class LIST_Command { /*extends Command*/
public static Map<String, Command> commands = new HashMap<>();
public String description() {
return "List all commands, their descriptions, or usages.";
}
public String usage() {
return "list <cmds | desc | usage>";
}
public boolean runCmd(String[] cmdArgs, PrintStream output) {
try {
if (cmdArgs.length == 0) {
return false;
}
else if (cmdArgs.length > 0) {
if (cmdArgs[0].equals("cmds")) {
for (Map.Entry<String, Command> cmd : /*main.Main.*/commands.entrySet()) {
output.println(cmd.getKey());
}
}
else if (cmdArgs[0].equals("desc")) {
for (Map.Entry<String, Command> cmd : /*main.Main.*/commands.entrySet()) {
output.println(cmd.getValue().description());
}
}
}
return true;
}
catch (Exception e) {
return false;
}
}
public static void main(String[] args) {
commands.put("test1", new FAKE_CMD(1));
commands.put("test2", new FAKE_CMD(2));
new LIST_Command().runCmd(new String[] {"cmds"}, System.out);
}
abstract class Command {
public abstract String usage();
public abstract String description();
public abstract boolean runCmd(String[] cmdArgs, PrintStream output);
}
static class FAKE_CMD extends Command {
int msg;
public FAKE_CMD(int i) {
this.msg = i;
System.out.println(i);
}
public String usage() {
return "usagetest" + msg;
}
public String description() {
return "descriptiontest" + msg;
}
public boolean runCmd(String[] cmdArgs, PrintStream output) {
return true;
}
}
}

Command is an inner class, which doesn't seem to make sense since it is contained in a class that should be its subclass. Anyway, that is the cause of your error: regardless of whether FAKE_CMD is itself static or not, it needs an enclosing instance of LIST_Command since it extends Command.
Note a possible subtlety in Java's terminology: inner class means a non-static nested class, therefore it implies the need for an enclosing instance.

The constructor of FAKE_CMD need to call its superclass' (Command's) constructor. However, since the superclass is not static, Java has no way of instantiate a superclass instance before constructing a FAKE_CMD.

How do I get the method name from within that method?

I am trying to create a function that returns the method name from within that method:
public static String getMethodName(final int depth)
{
final StackTraceElement[] ste = Thread.currentThread().getStackTrace();
return ste[ste.length - 1 - depth].getMethodName();
}
However, when I call this method from Activity.onCreate(), it returns "main" instead of "onCreate".
How do I get the actual method name from within that method?

return ste[1+depth].getMethodName();
If you change return statement as above, you would get immediate calling method name , of cource depth shoould be zero..

Despite the fact initiating an Exception is more expensive way, I would do it anyway.
Log.d("CurrentMethod", new Exception().getStackTrace()[0].getMethodName());
Works if called in onCreate.

A singleton to manage logs:
public class ActiveLog {
public static final String TAG = "TRACE LOG";
private static ActiveLog instance;
private static boolean actif;
public static ActiveLog getInstance() {
if (null == instance)
instance = new ActiveLog();
return instance;
}
private ActiveLog() {
ActiveLog.setActif(true);
}
public void log() {
if(isActif())
Log.d(TAG, "" + (new Exception().getStackTrace()[1].getClassName())
+ ": "
+ (new Exception().getStackTrace()[1].getMethodName()));
}
public static boolean isActif() {
return actif;
}
public static void setActif(boolean actif) {
ActiveLog.actif = actif;
}}
An example of use:
public class MyTest {
public void test() {
ActiveLog.getInstance().log();
}
}
The result:
09-05 14:37:09.822: D/TRACE LOG(XXXX): com.TestProject.MyTest: test

I think your problem maybe you are accessing the stack upside down. In the returned value element 0 is the most recent call (which would be getStackTrace()). I think what you are intending to do is:
public static String getMethodName(final int depth) {
final StackTraceElement[] ste = Thread.currentThread().getStackTrace();
return ste[1 + depth].getMethodName();
}
This will access the most recent call in the stack (outside of the call to getStackTrace()). For example if you have a method:
public void foo() {
System.out.println(getMethodName(0));
}
This will print "foo" with the above implementation of the function. Of course you may also want to add some bounds checking to the function since it could easily go outside the array.