So this error appeared after I compiled my java classes, packaged them in a war, and deployed it to the application server. The only major change that happened to my system was an upgrade to Snow Leopard. I searched the web forums and discovered that this issue is due to compiling the java classes with a different Java compiler version than the JVM version on the application server.

How can this be? It was working fine all this time. I checked my JAVA_HOME environment variable and it was pointing to a JVM-specific directory: 1.X.0

On the command line, I typed:

javac -version

and it returned the latest version. So I thought that maybe the OS upgrade overrided my default Java compiler. I started to look into the ant file to find a task attribute to point to a specific JVM. After redeployment, the error still persisted.

So finally, I thought about testing the actual java compiler, in the 1.X.0 directory. I typed: javac -version and it returned again the latest version. I tried: ./javac -version.. the results are the same.

Then I traversed to the other previous versioned directories. All of them returned the latest version.

This was really odd. So finally, I decided to override all the directories from the AWESOME Time Machine. Specifically, I replaced the directories with the directories before the OS upgrade.

I ran the compilation and deployment and the issue is RESOLVED.

I’m not sure why Snow Leopard overrided my directories with the latest Java compiler, but I’m glad the war file is deployable. If I didn’t discover this issue, then it would have caused me unneccessary stress and panic if it was a release day.

(Creating your own exception class (encapsulation) in asp.net c #)

Visitantes webianos, tudo bem?

Este artigo será pequeno, porém muito útil para sua aplicação.

Criar sua própria classe exception encapsulamento a classe exception do framework .net.

Trabalhar com exception de forma estruturada e organizada, otimiza muito as atividades de manutenção, implementação de layout (interface) e entendimento do código. Além de possibilitar a criação de um esquema de log para melhor monitoramento destes exceptions.

Mão na massa:

Minha sugestão é criar uma pasta “Util” dentro de App_Code. E dentro dela pasta “Util” criar seu arquivo contendo sua classe.

Eu uso como padrão de nomenclatura a letra “c” minúsculo antes de qualquer classe, isso para me ajudar nas identificações das minhas classes com as classes do próprio framework .net, das classes de bibliotecas externas e de plugins.

Para este exemplo, minha classe chamará “cException“, mas poderia ser “myException” ou “minhasExcessões“… vc coloca o nome que achar mais semântico para sua aplicação e equipe.

Meu arquivo ficou assim:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

namespace classe.util
{

/// <summary>
/// Classe para tratamento de exceções (erros) personalizadas.
/// </summary>
public class cException : Exception
{
#region Fields
private string _exceptionmessage;
#endregion

#region Properties
public string ExceptionMessage
{
get { return _exceptionmessage; }
set { _exceptionmessage = value; }
}
#endregion

#region Constructor
/// <summary>
/// Construtor da classe, este popula a field _exceptionmessage, usado para armazenar a mensagem original da exception.
/// </summary>
/// <param name=”excep”>Objeto Exception</param>

public cException(Exception excep)
{
ExceptionMessage = excep.Message;
}

/// <summary>
/// Construtor da classe, este popula a field _exceptionmessage, usado para armazenar a mensagem da exception.
/// Use msgDefinida(int) para melhor manutenção desta classe.
/// </summary>
/// <param name=”excepmsg”>String de exceção especifica</param>
public cException(string excepmsg)
{
ExceptionMessage = excepmsg;
}

#endregion

#region Methods

/// <summary>
/// Método que retorna mensagens de procedimentos inválidos (cath)
/// </summary>
/// <param name=”tipomsg”>
/// Código controle do tipo de mensagem que será retornada, especifico da exceção.
/// 1 – Dados inválidos, verifique a quantidade de caracteres digitados.
/// 2 – Usuário não autenticado.
/// 3 – Erro ao conectar com banco de dados.
/// 4 – Dados inválidos.
/// 5 – Erro de banco. Operação não foi concluída.
/// 6 – Erro: i não é maior que j (Mensagem teste)
/// </param>
/// <returns>String com mensagem</returns>
public static string MsgDefinida(int tipomsg)
{
string msg = “Operação invalida. Tente novamente!“;

switch (tipomsg)
{
case 1:
msg = “Erro: Dados inválidos, verifique a quantidade de caracteres digitados.“;
break;
case 2:
msg = “Erro: Usuário não autenticado.”;
break;
case 3:
msg = “Erro DB: Não conectou com banco de dados.”; ///usada em: cMensagem
break;
case 4:
msg = “Erro: Dados inválidos.“; ///usada em: cMensagem
break;
case 5:
msg = “Erro DB: Operação não foi concluída.“; ///usada em: cMensagem
break;
case 6:
msg = “Erro: i não é maior que j (Mensagem teste).”; ///usada em: Default.aspx.cs
break;
default:
break;
}

return msg;
}

#endregion

}

}

Explicando alguns pontos interessantes:

1. namespace classe.util. Eu uso sempre namespace para melhor organização do meu sistema.
2. public class cException : Exception. Minha classe herda a classe Exception .net que já possui varias propriedades interessantes. (Mais abaixo vou explicar algumas)
3. /// <summary>. Tente sempre comentar seus códigos usando atributos prefixados para documentação xml do .net. Use também comentários in-line (aqueles informativos usando “///aqui um comentário”).
4. public static string MsgDefinida(int tipomsg). Já predefini algumas mensagens mais usadas pelo meu sistema.

Algumas propriedades publicas da classe Exception .net:

• HelpLink Read-write

Gets or sets a link to the help file associated with this exception.
Obtém ou define um link para o arquivo de Ajuda associado com esta exceção.

• InnerException     Read-only

Gets the Exception instance that caused the current exception.
Obtém a instância Exception que causou a exceção atual.

• Message     Read-only

Gets a message that describes the current exception.
Recebe uma mensagem que descreve a exceção atual.

• Source     Read-write

Gets or sets the name of the application or the object that causes the error.
Obtém ou define o nome do aplicativo ou o objeto que causa o erro.

• StackTrace     Read-only

Gets a string representation of the frames on the call stack at the time the current exception was thrown.
Obtém uma representação de seqüência dos quadros na pilha de chamada no momento atual a exceção foi acionada.

• TargetSite     Read-only

Gets the method that throws the current exception.
Obtém o método que gera a exceção atual.

Fonte: http://www1.cs.columbia.edu/~lok/csharp/refdocs/System/types/Exception.html

Usando minha própria classe exception:

using System;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Collections;
using classe.util;

public partial class _Default : System.Web.UI.Page
{

protected void Page_Load(object sender, EventArgs e)
{

int i = 0;
int j = 10;
int x;

///1º) Primeiro tipo de uso, especificando o texto da minha própria exception.
try
{
if (i > j)
{
///aqui fazer qualquer coisa.
Response.Write(“<br />i é maior que j“);
///estou usando response.write pq estou na camada de apresentação. e para ficar mais fácil o entendimento.
}
else
{
throw new cException(“erro: i não é maior que j.“);
}
}
catch (cException myexcep)
{
Response.Write(“<br />1ª exception(texto escrito). Ocorreu uma exception: “);
Response.Write(myexcep.ExceptionMessage);
}

///2º) Segundo tipo de uso, especificando um texto predefinido da minha própria exception.
try
{
if (i > j)
{
///aqui fazer qualquer coisa.
Response.Write(“<br />i é maior que j“);
///estou usando response.write pq estou na camada de apresentação. e para ficar mais facil o entendimento.
}
else
{
throw new cException(cException.MsgDefinida(6));
}
}
catch (cException myexcep)
{
Response.Write(“<br />2ª exception(texto dinâmico). Ocorreu uma exception: “);
Response.Write(myexcep.ExceptionMessage);
}

///3º) Terceiro tipo de uso, usando texto(message) da própria classe exception do framework .net.
try
{

try
{
x = j / i;  ///DivideByZeroException
}
catch (Exception myexcepsub)
{
throw new cException(myexcepsub);
}

}
catch (cException myexcep)
{

Response.Write(“<br />3ª exception(Framework). Ocorreu uma exception: “);
Response.Write(myexcep.ExceptionMessage);

}

}

}

* Me desculpem pela endentação, mas não consegui ainda colocar codigos endentados igual do Visual Studio. hehe

Explicando alguns pontos interessantes:
1. Este teste foi feito no arquivo Default.aspx
2. using classe.util; Não esqueça de “chamar” o uso da classe pelo namespace, assim vc “inclui/include” a sua classe nesta pagina para ser usada.
3. 1º) Primeiro tipo de uso, especificando o texto da minha própria exception.
4. 2º) Segundo tipo de uso, especificando um texto predefinido da minha própria exception.
5. 3º) Terceiro tipo de uso, usando texto(message) da própria classe exception do framework .net.

Amigos usem e abusem desta classe.

Qualquer dúvida deixe seu comentário que eu respondo. Humm… e se tiver sugestão de algum tema para artigo também é só mandar seu comentário.

Abraços…. e até o próximo artigo.

If we want to get the Stack Trace of a Java Exception, we can’t simply use exception.printStackTrace() because that method returns nothing and just prints the stack trace into the console.

To get the Stack Trace and store it into a file, you can do this:


StringBuilder sb = new StringBuilder();
StackTraceElement[] stackTrace = exception.getStackTrace();
for(int i=0;i<stackTrace.length;i++){
sb.append(stackTrace[i]);
sb.append("\n");
}


Given the StringBuilder sb above, you can proceed to write the string in a file. This is how i would do it:

FileOutputStream fos = new FileOutputStream(filename);
try{
OutputStreamWriter osw = new OutputStreamWriter(fos);
try{
BufferedWriter bw = new BufferedWriter(osw);
try{
bw.write(sb.toString());
}finally{
bw.close();
}
}finally{
osw.close();
}
}finally{
fos.close();
}


Similarly, you can merge the 2 codes above like below:

FileOutputStream fos = new FileOutputStream(filename);
try{
OutputStreamWriter osw = new OutputStreamWriter(fos);
try{
BufferedWriter bw = new BufferedWriter(osw);
try{
StackTraceElement[] stackTrace = exception.getStackTrace();
for(int i=0;i<stackTrace.length;i++){
bw.write(stackTrace[i]);
bw.newLine();
}
}finally{
bw.close();
}
}finally{
osw.close();
}
}finally{
fos.close();
}


Einen Artikel, der das Error-Handling in Eclipse beschreibt finden wir hier:

http://wiki.eclipse.org/Platform_UI_Error_Handling

Um über das Exception-Handling die Kontrolle zu bekommen montiere ich folgende Teile im

ApplicationWorkbenchAdvisor:

//+++++hier bekommen wir alles gelogt, was in der Main-Event-Loop an Exceptions fliegt
public void eventLoopException(Throwable exception) {
     //        super.eventLoopException(exception);
     exception.printStackTrace();
}
//++++nach dem Startup will ich die Einstellung für die Variable WorkbenchPlugin.DEBUG überprüfen
public void postStartup() {
       System.out.println(" DEBUG : "  + WorkbenchPlugin.DEBUG);
       WorkbenchPlugin.DEBUG=true; //++++++dann setze ich die Variable von Hand auf Debug

//+++++immer, wenn irgendein Fehler auftritt wird der Standard Policy Handler aufgerufen,
//+++++dieser zeigt nur einen Dialog mit dem Fehler auf - aber kein Stacktrace
//+++++das ändern wir jetzt:
//den alten StatusHandler heben wir uns auf

        final StatusHandler defaultStatusHandler= Policy.getStatusHandler();

        Policy.setStatusHandler(new StatusHandler() {

                                @Override
                                public void show(IStatus status, String title) {
                                     status.getException().printStackTrace();

                                     //und leiten an den alten StatusHandler weiter

                                     defaultStatusHandler.show(status,title);

                                }

         });
         //++++++++zur Kontrolle: nochmal den Status Handler ausgeben
         System.out.println(" status handler " + Policy.getStatusHandler());
         //++++++++und auch noch mal das WorkbenchPlugin.DEBUG-Feld
         System.out.println(" DEBUG : "  + WorkbenchPlugin.DEBUG);

}

Ursprünglich wird der StatusHandler in org.eclipse.ui.internal.JFaceUtils.initializeJFace initialisiert.

Der Weg dorthin führt über:

ExtensionRegistry.createExecutableExtension->BundleHost.startWorker->…AbstractBundle.startActivator -> WorkbenchPlugin.start(BundleContext) -> JFaceUtils.initializeJFace

—

das Workbench.DEBUG -Feld wird über die Run-Configurations (Reiter: Trace) gesteuert. org.eclipse.ui -Checkbox

Nach Aktivierung erscheinen eine Menge Debug Informationen. Diese muss ich noch genauer untersuchen.

There’s a certain error-and-stack-trace we get every time we bring up an instance of JBoss (or is it every time we deploy one of our war projects?), to wit:

09:15:37,945 ERROR [STDERR] Oct 16, 2008 9:15:37 AM oracle.jdbc.driver.OracleDriver registerMBeans
SEVERE: Error while registering Oracle JDBC Diagnosability MBean.
javax.management.MalformedObjectNameException: Invalid character '
' in value part of property
        at javax.management.ObjectName.construct(ObjectName.java:529)
        at javax.management.ObjectName.(ObjectName.java:1314)
        at oracle.jdbc.driver.OracleDriver.registerMBeans(OracleDriver.java:303)
        at oracle.jdbc.driver.OracleDriver$1.run(OracleDriver.java:213)
        at java.security.AccessController.doPrivileged(Native Method)
        at oracle.jdbc.driver.OracleDriver.(OracleDriver.java:209)
        at oracle.jdbc.pool.OracleDataSource.(OracleDataSource.java:94)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:494)
        at java.lang.Class.newInstance0(Class.java:350)
        at java.lang.Class.newInstance(Class.java:303)
        at org.jboss.resource.adapter.jdbc.xa.XAManagedConnectionFactory.getXADataSource(XAManagedConnectionFactory.java:219)
        at org.jboss.resource.adapter.jdbc.xa.XAManagedConnectionFactory.createManagedConnection(XAManagedConnectionFactory.java:136)
        at org.jboss.resource.connectionmanager.InternalManagedConnectionPool.createConnectionEventListener(InternalManagedConnectionPool.java:577)
        at org.jboss.resource.connectionmanager.InternalManagedConnectionPool.getConnection(InternalManagedConnectionPool.java:262)
        at org.jboss.resource.connectionmanager.JBossManagedConnectionPool$BasePool.getConnection(JBossManagedConnectionPool.java:500)
        at org.jboss.resource.connectionmanager.BaseConnectionManager2.getManagedConnection(BaseConnectionManager2.java:341)
        at org.jboss.resource.connectionmanager.TxConnectionManager.getManagedConnection(TxConnectionManager.java:315)
        at org.jboss.resource.connectionmanager.BaseConnectionManager2.allocateConnection(BaseConnectionManager2.java:396)
        at org.jboss.resource.connectionmanager.BaseConnectionManager2$ConnectionManagerProxy.allocateConnection(BaseConnectionManager2.java:842)
        at org.jboss.resource.adapter.jdbc.WrapperDataSource.getConnection(WrapperDataSource.java:88)
        at org.springframework.orm.hibernate3.LocalDataSourceConnectionProvider.getConnection(LocalDataSourceConnectionProvider.java:82)
        at org.hibernate.cfg.SettingsFactory.buildSettings(SettingsFactory.java:84)
        at org.hibernate.cfg.Configuration.buildSettings(Configuration.java:2073)
        at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1298)
        at org.hibernate.cfg.AnnotationConfiguration.buildSessionFactory(AnnotationConfiguration.java:859)
        at org.springframework.orm.hibernate3.LocalSessionFactoryBean.newSessionFactory(LocalSessionFactoryBean.java:814)
        at org.springframework.orm.hibernate3.LocalSessionFactoryBean.buildSessionFactory(LocalSessionFactoryBean.java:732)
        at org.springframework.orm.hibernate3.AbstractSessionFactoryBean.afterPropertiesSet(AbstractSessionFactoryBean.java:211)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1368)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1334)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:473)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory$1.run(AbstractAutowireCapableBeanFactory.java:409)
        at java.security.AccessController.doPrivileged(Native Method)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:380)
        at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:264)
        at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:221)
        at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:261)
        at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:185)
        at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:164)
        at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:423)
        at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:729)
        at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:381)
        at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:139)
        at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:105)
        [...]

We’re used to this, and it doesn’t seem to cause any harm, so we ignore it, but wish it weren’t there.

A post to the SQLJ/JDBC forum at Oracle Technology Network Discussion Forums brings up this same issue, and the reply says that a patch to ojdbc5.jar has been released, dealing with this issue.  My results show we’re not using the patched version:

C:\path\to\jboss-4.2.2.GA\server\default\lib>java -jar ojdbc5-11.1.0.6.0.jar
Oracle 11.1.0.6.0-Production JDBC 3.0 compiled with JDK5

(If we had the patch, the output would be

Oracle 11.1.0.6.0-Production+ JDBC 3.0 compiled with JDK5

).

The drivers are available from Oracle.  Perhaps soon we’ll upgrade to them…

Often it will be required to find out how a particular method is invoked in order to investigate a bug or to understand the application flow. This can be done easily in small application using debugging tool or reading through the code. Even though, it is possible to debug large applications to find out the flow, it will obviously difficult to try the wide variety of usage scenarios. In case of large web applications, the developer may not even know every usage scenarios. Even missing a single usage scenario, also misses  method usage scenario.

This blog is about how to track various usage scenario in Java from code perspective.

The stack trace provides an excellent way to track the code flow. You would have seen in stack trace logs when exceptions are thrown, the stack trace has detail information on the classes, methods and the line numbers. We will use the same approach to trace the code flow without waiting for exceptions to happen.

In this scenario, we create a Throwable object, which the parent class of Exception. The Throwable object contains the entire stackTrace at the point where the object is created. We can use the getStackTrace() method on the Throwable object to obtain the stackTrace. The method returns an array of StackTraceElement. Each StackTraceElement represent a single stack frame and has information regarding the method which was invoked in the execution sequence. Also, the java class file name, complete java class name and the line number of invocation is also present.

Consider the following simple code scenario.

public String getName() {
          return "SOL_APP_MANG";
}

Inorder to trace, how the method getName is used in a application, the method is modified as follows.

public String getName() {
          Throwable throwable = new Throwable();
          StackTraceElement[] stElements = throwable.getStackTrace();
          for (StackTraceElement ste: stElement)
                   system.out.println("File Name:" + ste.getFileName());
                   system.out.println("Class Name:" + ste.getClassName());
                   system.out.println("Method Name:" + ste.getMethodName());
                   system.out.println("Line number:" + ste.getLineNumber());
          return "SOL_APP_MANG";
}

The code is very straightforword and simple.

I have implemented a small library for analyzing the stackTrace of the Throwable object. The library is a very small jar file with size of just 6.5 kb. The UML diagram is shown below.

It consists of 2 classes and a interface. The interface IDisplayableStackTrace has the method

public String getDisplayedStackTrace(StackTraceElement st)

Every implementation of the IDisplayableStackTrace should implement the method and implement the functionality of how a StackTraceElement should be represented as a String.

This allows any implmentation to be plugged based on requirement.

The following SimpleDisplayableStackTrace is an implementation.

package com.ast.sampleExample;

import com.ast.analyse.IDisplayableStackTrace;

public class SimpleDisplayableStackTrace implements IDisplayableStackTrace {

    @Override
    public String getDisplayedStackTrace(StackTraceElement st) {
        StringBuilder sb = new StringBuilder();
        sb.append(":$FILE$:").append(st.getFileName())
          .append(":$CLASS$:").append(st.getClassName())
          .append(":$METHOD$:").append(st.getMethodName())
          .append(":$LINE$:").append(st.getLineNumber());
        return sb.toString();
    }
}

You can write your own implementation of IDisplayableStackTrace depending on requirement.

The AnalyseThrowable class is the single most important class of the library. The AnalyseThrowable class has a static method.

public static void dumpStackTrace(IDisplayableStackTrace dst, PrintStream pw, Throwable throwable)
            throws AnalyseThrowableException

This method has the following arguments.

• IDisplayableStackTrace dst – An implementation of the class IDisplayableStackTrace
• PrintStream pw – A PrintStream object to where the customized stack trace needs to be written
• Throwable throwable – A Throwable whose stack trace needs to be analysed

Also, the class provides the method

public void dumpStackTrace(Throwable throwable) throws AnalyseThrowableException

which can be invoked using an instanceof AnalyseThrowable. The AnalyseThrowable has a parameterized constructor which accepts an implementation of IDisplayableStackTrace and PrintStream.

One of the variations of the dumpStackTrace method can be used depending on the scenario.

The class AnalyseThrowableException extends Exception class and some of the methods of class
AnalyseThrowable throws the AnalyseThrowableException exception object which needs to be
handled by the client using the library.

A typical usage scenario of the library is given below.

public String getName() {
          try {
                AnalyseThrowable.dumpStackTrace(new SimpleDisplayableStackTrace(), System.out, new Throwable());
          }
          catch(AnalyseThrowableException ex) {
                ex.printStackTrace(System.out);
          }
          return "SOL_APP_MANG";
}

An sample stack trace, when executed through a junit test case is shown below.

:$FILE$:AnalyseThrowableTest.java:$CLASS$:com.ast.analyse.AnalyseThrowableTest:$METHOD$:testDumpStackTraceIDisplayableStackTracePrintStreamThrowable:$LINE$:13
:$FILE$:NativeMethodAccessorImpl.java:$CLASS$:sun.reflect.NativeMethodAccessorImpl:$METHOD$:invoke0:$LINE$:-2
:$FILE$:NativeMethodAccessorImpl.java:$CLASS$:sun.reflect.NativeMethodAccessorImpl:$METHOD$:invoke:$LINE$:39
:$FILE$:DelegatingMethodAccessorImpl.java:$CLASS$:sun.reflect.DelegatingMethodAccessorImpl:$METHOD$:invoke:$LINE$:25
:$FILE$:Method.java:$CLASS$:java.lang.reflect.Method:$METHOD$:invoke:$LINE$:597
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:executeMethodBody:$LINE$:99
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:runUnprotected:$LINE$:81
:$FILE$:BeforeAndAfterRunner.java:$CLASS$:org.junit.internal.runners.BeforeAndAfterRunner:$METHOD$:runProtected:$LINE$:34
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:runMethod:$LINE$:75
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:run:$LINE$:45
:$FILE$:TestClassMethodsRunner.java:$CLASS$:org.junit.internal.runners.TestClassMethodsRunner:$METHOD$:invokeTestMethod:$LINE$:66
:$FILE$:TestClassMethodsRunner.java:$CLASS$:org.junit.internal.runners.TestClassMethodsRunner:$METHOD$:run:$LINE$:35
:$FILE$:TestClassRunner.java:$CLASS$:org.junit.internal.runners.TestClassRunner$1:$METHOD$:runUnprotected:$LINE$:42
:$FILE$:BeforeAndAfterRunner.java:$CLASS$:org.junit.internal.runners.BeforeAndAfterRunner:$METHOD$:runProtected:$LINE$:34
:$FILE$:TestClassRunner.java:$CLASS$:org.junit.internal.runners.TestClassRunner:$METHOD$:run:$LINE$:52
:$FILE$:JUnit4TestReference.java:$CLASS$:org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference:$METHOD$:run:$LINE$:38
:$FILE$:TestExecution.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.TestExecution:$METHOD$:run:$LINE$:38
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:runTests:$LINE$:460
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:runTests:$LINE$:673
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:run:$LINE$:386
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:main:$LINE$:196

Download jar file

OR

Download jar file

Stacktrace segnala il progetto Eulero… per gli appassionati di programmazione, e di matematica!