title: ByteBuddy superMethod null
body: <p>I have an strange behavior. Consider this code:</p>
  <p>Every object that is returned from the database is created by this proxy:</p>
  <pre><code>public static &lt;T&gt; T bbcreate(Class&lt;T&gt; c, OElement ov, Transaction transaction ) {
          LOGGER.log(Level.FINEST, &quot;create proxy for class: &quot;+c+(c!=null?c.getName().toString():&quot;NULL CLASS!!!!&quot;));
          T po = null;
          try {
              Class&lt;?&gt; type = cache.findOrInsert(c.getClassLoader(), c, () -&gt; {
                                  return
                                      new ByteBuddy(ClassFileVersion.ofThisVm())
                                          .subclass(c)
                                          .defineField(&quot;___ogm___interceptor&quot;, ObjectProxy.class, Visibility.PUBLIC)
                                          .implement(IObjectProxy.class)
                                          .defineConstructor(Visibility.PUBLIC)
                                              .withParameter(ObjectProxy.class)
                                              .intercept(FieldAccessor.ofField(&quot;___ogm___interceptor&quot;).setsArgumentAt(0)
                                                          .andThen(MethodCall.invoke(c.getDeclaredConstructor()))
                                              )
                                          .method(ElementMatchers.any()) // isDeclaredBy(ITest.class)
                                              .intercept(MethodDelegation   // This.class,Origin.class,AllArguments.class,SuperMethod.class)
                                                          .withDefaultConfiguration() //.withBinders(TargetMethodAnnotationDrivenBinder.ParameterBinder.DEFAULTS)
                                                          .filter(ElementMatchers.named(&quot;intercept&quot;))
                                                          .toField(&quot;___ogm___interceptor&quot;))   // MethodDelegation.to(bbi)
                                          .make()
                                          .load(c.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                                          .getLoaded();
              });
              
              
              // crear el proxy al que delegar las llamadas
              ObjectProxy bbi = new ObjectProxy(c,ov,transaction);
              
              // crear una instancia
              po = (T)type.getConstructor(ObjectProxy.class).newInstance(bbi);
              
              bbi.___setProxiedObject(po);
              
              // clean possible dirtiness (because of actions in default constructor)
              bbi.___removeDirtyMark();
              
          } catch (InstantiationException | IllegalAccessException | SecurityException | NoSuchMethodException | IllegalArgumentException | InvocationTargetException ex) {
              Logger.getLogger(ObjectProxyFactory.class.getName()).log(Level.SEVERE, null, ex);
          }
          return po;
      }
  </code></pre>
  <p>The ObjectProxy's intercept method that is called is this:</p>
  <pre><code>// ByteBuddy interceptor 
      @RuntimeType
      public Object intercept(@This Object self, 
                              @Origin Method method, 
                              @AllArguments Object[] args, 
                              @SuperMethod(nullIfImpossible = true) Method superMethod,
                              @Empty Object defaultValue
                              ) throws Throwable {
          
  //         
          
          // response object
          Object res = null;
          //this.___proxiedObject = self;
          // el estado del objeto se debe poder consultar siempre
          //=====================================================
          LOGGER.log(Level.FINEST, &quot;=====================================================&quot;);
          LOGGER.log(Level.FINEST, self.getClass().getName() + &quot; : &quot;+ this.___baseElement.getRecord().getIdentity()+ &quot; &gt; method: &quot;+method.getName()+&quot;  superMethod: &quot;+(superMethod!=null?superMethod.getName():&quot;NULL&quot;));
          LOGGER.log(Level.FINEST, &quot;=====================================================&quot;);
          
          String debugLabel = this.___baseElement.getRecord().getIdentity()+ &quot; &gt; method: &quot;+method.getName();
          
          if (method.getName().equals(&quot;___isValid&quot;)) {
              return this.___isValid();
          }
          
          if (method.getName().equals(&quot;___isDeleted&quot;)) {
              return this.___isDeleted();
          }
  
          if (method.getName().equals(&quot;___getVertex&quot;)) {
              return this.___getVertex();
          }
          if (method.getName().equals(&quot;___getEdge&quot;)) {
              return this.___getEdge();
          }
          if (method.getName().equals(&quot;___getElement&quot;)) {
              return this.___getElement();
          }
  
          if (method.getName().equals(&quot;___getRid&quot;)) {
              return this.___getRid();
          }
          
          if (method.getName().equals(&quot;___getBaseClass&quot;)) {
              return this.___getBaseClass();
          }
  
          if (!this.___isValidObject) {
              LOGGER.log(Level.FINER, &quot;El objeto está marcado como inválido!!!&quot;);
              throw new InvalidObjectReference(this.___transaction);
          }
  
          if (method.getName().equals(&quot;___rollback&quot;)) {
              if (this.___objectReady) {
                  this.___rollback();
                  return true;
              }
          }
  
          if (this.___baseElement.getIdentity().isNew()) {
              LOGGER.log(Level.FINER, &quot;RID nuevo. No procesar porque el store preparó todo y no hay nada que recuperar de la base.&quot;);
              this.___loadLazyLinks = false;
          }
          
          //if object was deleted:
          if (this.___deletedMark) {
              switch (method.getName()) {
                  case &quot;equals&quot;:
                  case &quot;hashCode&quot;:
                      if (!this.___transaction.getSessionManager().getConfig().
                              isEqualsAndHashCodeOnDeletedThrowsException()) {
                          return superMethod.invoke(self, args);
                      }
                  default:
                      throw new ObjectMarkedAsDeleted(&quot;The object &quot; + this.___baseElement.getIdentity().toString() + 
                              &quot; was deleted from the database. Trying to call to &quot; + method.getName(),
                              this.___transaction);
              }
          }
          
          // modificar el llamado
          switch (method.getName()) {
              case &quot;___uptadeVersion&quot;:
                  if (this.___objectReady) {
                      this.___uptadeVersion();
                  }
                  break;
              case &quot;___injectRid&quot;:
                  if (this.___objectReady) {
                      this.___injectRid();
                  }
                  break;
              case &quot;___getProxiedObject&quot;:
                  if (this.___objectReady) {
                      res = this.___getProxiedObject();
                  }
                  break;
              case &quot;___loadLazyLinks&quot;:
                  if (this.___objectReady) {
                      this.___loadLazyLinks();
                  }
                  break;
              case &quot;___eagerLoad&quot;:
                  if (this.___objectReady) {
                      this.___eagerLoad();
                  }
                  break;
              case &quot;___fullLoad&quot;:
                  if (this.___objectReady) {
                      this.___fullLoad();
                  }
                  break;
              case &quot;___isDirty&quot;:
                  if (this.___objectReady) {
                      res = this.___isDirty();
                  }
                  break;
              case &quot;___setDirty&quot;:
                  if (this.___objectReady) {
                      this.___setDirty();
                  }
                  break;
              case &quot;___removeDirtyMark&quot;:
                  if (this.___objectReady) {
                      this.___removeDirtyMark();
                  }
                  break;
              case &quot;___commit&quot;:
                  /**
                   * FIXME: se podría evitar si se controlara si los links se
                   * han cargado o no al momento de hacer el commit para
                   * evitar realizar el load sin necesidad.
                   */
                  if (this.___objectReady) {
                      if (this.___loadLazyLinks) {
                          this.___loadLazyLinks();
                      }
                      this.___commit();
                  }
                  break;
              case &quot;___reload&quot;:
                  if (this.___objectReady) {
                      this.___reload();
                  }
                  break;
              case &quot;___commitSuccessful&quot;:
                  if (this.___objectReady) {
                      this.___commitSuccessful();
                  }
                  break;
              case &quot;___setDeletedMark&quot;:
                  this.___setDeletedMark();
                  break;
              case &quot;___updateElement&quot;:
                  this.___updateElement();
                  break;
              
              case &quot;___setEdge&quot;:
                  this.___setEdge((OEdge)args[0]);
                  break;
              case &quot;___setVertex&quot;:
                  this.___setVertex((OVertex)args[0]);
                  break;
  
              case &quot;___setAuditLogLabel&quot;:
                  this.___setAuditLogLabel((String)args[0]);
                  break;
              case &quot;___getAuditLogLabel&quot;:
                  res = this.___getAuditLogLabel();
                  break;
                  
              
              case &quot;___ogm___setDirty&quot;:
                  res = superMethod.invoke(self, args);
                  break;
              case &quot;___ogm___isDirty&quot;:
                  res = superMethod.invoke(self, args);
                  break;
  
              default:
                  // invoke the method on the real object with the given params:
  
                  if (method.getName().equals(&quot;toString&quot;)) {
                      try {
                          //if object doesn't have toString defined, we implement one on the fly
                          ReflectionUtils.findMethod(this.___baseClass, &quot;toString&quot;, (Class&lt;?&gt;[]) null);
                      } catch (NoSuchMethodException nsme) {
                          res = this.___baseElement.getIdentity().toString(); //returns rid
                          break;
                      }
                  }
  
                  if (this.___loadLazyLinks) {
                      boolean methodTriggersLoadLazyLink = true;
                      if (method.getName().equals(&quot;equals&quot;) || method.getName().equals(&quot;hashCode&quot;)) {
                          methodTriggersLoadLazyLink &amp;= this.___transaction.getSessionManager().
                                  getConfig().isEqualsAndHashCodeTriggerLoadLazyLinks();
                      }
                      methodTriggersLoadLazyLink &amp;= !method.isAnnotationPresent(DontLoadLinks.class);
                      if (this.___objectReady &amp;&amp; methodTriggersLoadLazyLink) {
                          this.___loadLazyLinks();
                      }
                  }
                  
                  if (superMethod == null) {
                      System.out.println(&quot;superMethod == NULL !!!!&quot;);
                      return defaultValue;
                  }
                  try {
                      res = superMethod.invoke(self, args);
                  } catch (InvocationTargetException ex) {
                          throw ex.getCause();
                  }
  
                  // verificar si hay diferencias entre los objetos dependiendo de la estrategia seleccionada.
                  if (this.___objectReady) {
                      switch (this.___transaction.getSessionManager().getActivationStrategy()) {
                          case CLASS_INSTRUMENTATION:
                              // si se está usando la instrumentación de clase, directamente verificar en el objeto
                              // cual es su estado.
                              LOGGER.log(Level.FINEST, &quot;o: {0} ITrans: {1}&quot;, new Object[]{self.getClass().getName(), self instanceof ITransparentDirtyDetector});
                              if (((ITransparentDirtyDetector) self).___ogm___isDirty()) {
                                  LOGGER.log(Level.FINEST, &quot;objeto {0} marcado como dirty por ASM. Agregarlo a la lista de pendientes.&quot;, self.getClass().getName());
                                  this.___setDirty();
                              }
                      }
                  }
                  break;
          }
          // return the result
          LOGGER.log(Level.FINEST, &quot;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt; INTERCEPT END: &quot;+debugLabel);
          return res;
      }
  
  </code></pre>
  <p>SimpleVertex test object:</p>
  <pre><code>package test;
  
  import java.util.Date;
  import java.util.Objects;
  import java.util.UUID;
  import java.util.logging.Logger;
  import net.odbogm.annotations.Audit;
  import net.odbogm.annotations.Entity;
  import net.odbogm.annotations.Ignore;
  import net.odbogm.annotations.RID;
  import net.odbogm.annotations.Sequence;
  import net.odbogm.annotations.Version;
  
  /**
   *
   * @author Marcelo D. Ré {@literal &lt;marcelo.re@gmail.com&gt;}
   */
  @Entity
  @Audit(log = Audit.AuditType.DELETE)
  public class SimpleVertex implements Comparable&lt;SimpleVertex&gt;{
      @Ignore
      private final static Logger LOGGER = Logger.getLogger(SimpleVertex.class .getName());
  
      @RID private String rid;
      @Version private int version = -1;
      @Sequence(sequenceName = &quot;test_sequence&quot;) private final Long serial = null;
  
      private String uuid;
      private String s;
      public int i;
      private float f;
      private boolean b;
      private Date fecha;
          
      private Integer oI;
      private Float oF;
      private Boolean oB;
      
      public Date getFecha() {
          return fecha;
      }
  
      public void setFecha(Date fecha) {
          this.fecha = fecha;
      }
      
      public int getI() {
          return i;
      }
  
      public float getF() {
          return f;
      }
  
      public boolean isB() {
          return b;
      }
  
      public Integer getoI() {
          return oI;
      }
  
      public Float getoF() {
          return oF;
      }
  
      public Boolean getoB() {
          return oB;
      }
  
      public Long getSerial() {
          return serial;
      }
      
      
      public SimpleVertex(String s, int i, float f, boolean b, Integer oI, Float oF, Boolean oB) {
          this.s = s;
          this.i = i;
          this.f = f;
          this.b = b;
          this.oI = oI;
          this.oF = oF;
          this.oB = oB;
          this.uuid = UUID.randomUUID().toString();
      }
  
      public SimpleVertex(){
          this.s = &quot;string&quot;;
          this.i = 1;
          this.f = 0.1f;
          this.b = true;
          this.oI = 100;
          this.oF = 1.1f;
          this.oB = true;
          this.uuid = UUID.randomUUID().toString();
      }
      
      public SimpleVertex(String s) {
          super();
          this.s = s;
      }
      
      public String getRid() {
          return rid;
      }
  
      public int getVersion() {
          return version;
      }
      
      public String getS(){
          return this.s;
      }
  
      public void setRid(String rid) {
          this.rid = rid;
      }
  
      public void setS(String s) {
          this.s = s;
      }
      
      public void testSVMethod() {
          System.out.println(&quot;in SV&quot;);
      }
  
  //    @Override
  //    public String toString() {
  //        return this.s + &quot; - &quot; + this.b +  &quot; - &quot; + this.i +  &quot; - &quot; + this.f;
  //    }
  
      public void setI(int i) {
          this.i = i;
      }
  
      public void setF(float f) {
          this.f = f;
      }
  
      public void setB(boolean b) {
          this.b = b;
      }
  
      public void setoI(Integer oI) {
          this.oI = oI;
      }
  
      public void setoF(Float oF) {
          this.oF = oF;
      }
  
      public void setoB(Boolean oB) {
          this.oB = oB;
      }
  
      public String getUUID() {
          return this.uuid;
      }
  //    @Override
  //    public int hashCode() {
  //        int hash = 7;
  //        return hash;
  //    }
  
      @Override
      public boolean equals(Object obj) {
          if (this == obj) {
              return true;
          }
          if (obj == null) {
              return false;
          }
          if (getClass() != obj.getClass()) {
              return false;
          }
          final SimpleVertex other = (SimpleVertex) obj;
          return Objects.equals(this.uuid, other.uuid);
      }
  
      @Override
      public int compareTo(SimpleVertex t) {
          return this.uuid.compareTo(t.getUUID());
      }
      
  }
  </code></pre>
  <p>and SimpleVertexEx test object:</p>
  <pre><code>package test;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.UUID;
  import java.util.logging.Logger;
  import net.odbogm.annotations.Audit;
  import net.odbogm.annotations.CascadeDelete;
  import net.odbogm.annotations.Entity;
  import net.odbogm.annotations.FieldAttributes;
  import net.odbogm.annotations.Ignore;
  import net.odbogm.annotations.Indexed;
  import net.odbogm.annotations.RemoveOrphan;
  import net.odbogm.annotations.DontLoadLinks;
  import net.odbogm.annotations.Eager;
  import net.odbogm.annotations.Indirect;
  
  /**
   *
   * @author Marcelo D. Ré {@literal &lt;marcelo.re@gmail.com&gt;}
   */
  @Entity
  @Audit(log = Audit.AuditType.ALL)
  public class SimpleVertexEx extends SimpleVertex {
      @Ignore
      private final static Logger LOGGER = Logger.getLogger(SimpleVertexEx.class .getName());
  
      @FieldAttributes(mandatory = FieldAttributes.Bool.TRUE)
      private String svex;
  
      private SimpleVertexEx looptest;
      
      public EnumTest enumTest;
  
      @Indexed(type = Indexed.IndexType.UNIQUE)
      private String svuuid;
  
      @RemoveOrphan
      public SimpleVertex svinner; 
      
      public List&lt;String&gt; lString;
      
      public ArrayList&lt;String&gt; alString;
      
      public Map&lt;String, String&gt; mString;
      
      public HashMap&lt;String, String&gt; hmString;
      
      @RemoveOrphan
      @CascadeDelete
      public ArrayList&lt;SimpleVertex&gt; alSV;
      
      public List&lt;SimpleVertex&gt; lSV;
      
      public ArrayList&lt;SimpleVertexEx&gt; alSVE;
      
      @CascadeDelete
      public HashMap&lt;String, SimpleVertex&gt; hmSV;
      
      public HashMap&lt;String, SimpleVertexEx&gt; hmSVE;
      
      public HashMap&lt;EdgeAttrib, SimpleVertexEx&gt; ohmSVE;
      
      @Indirect(linkName = &quot;SimpleVertexEx_looptest&quot;)
      private SimpleVertexEx indirectLoopTest;
      
      @Eager
      private SimpleVertexEx eagerTest;
      
      @Indirect(linkName = &quot;SimpleVertexEx_eagerTest&quot;)
      private SimpleVertexEx indirectEagerTest;
      
      @Eager
      @Indirect(linkName = &quot;SimpleVertexEx_eagerTest&quot;)
      private SimpleVertexEx eagerIndirectEagerTest;
      
      
      public SimpleVertexEx(String svex, String s, int i, float f, boolean b, Integer oI, Float oF, Boolean oB) {
          super(s, i, f, b, oI, oF, oB);
          this.svex = svex;
          this.enumTest = EnumTest.UNO;
          this.svuuid = UUID.randomUUID().toString();
      }
  
      public SimpleVertexEx() {
          this(null, &quot;default&quot;);
      }
  
      public SimpleVertexEx(String s) {
          this(s, &quot;default&quot;);
      }
      
      public SimpleVertexEx(String s, String svex) {
          super(s);
          this.svex = svex;
          this.svuuid = UUID.randomUUID().toString();
      }
          
      public void initEnum() {
          this.enumTest = EnumTest.UNO;
      }
  
      public void initArrayListString() {
          this.alString = new ArrayList&lt;&gt;();
          this.alString.add(&quot;String 1&quot;);
          this.alString.add(&quot;String 2&quot;);
          this.alString.add(&quot;String 3&quot;);
      }
      
      public void initHashMapString() {
          this.hmString = new HashMap&lt;&gt;();
          this.hmString.put(&quot;hmString 1&quot;, &quot;hmString 1&quot;);
          this.hmString.put(&quot;hmString 1&quot;, &quot;hmString 2&quot;);
          this.hmString.put(&quot;hmString 1&quot;, &quot;hmString 3&quot;);
      }
      
      
      public void initArrayList(){
          this.alSV = new ArrayList&lt;SimpleVertex&gt;();
          this.alSV.add(new SimpleVertex());
          this.alSV.add(new SimpleVertex());
          this.alSV.add(new SimpleVertex());
      }
      
      public void initHashMap() {
          this.hmSV = new HashMap&lt;String, SimpleVertex&gt;();
          SimpleVertex sv = new SimpleVertex();
          this.hmSV.put(&quot;key1&quot;, sv);
          this.hmSV.put(&quot;key2&quot;, sv);
          this.hmSV.put(&quot;key3&quot;, new SimpleVertex());
      }
  
      public HashMap&lt;String, SimpleVertexEx&gt; getHmSVE() {
          return hmSVE;
      }
  
      public void setHmSVE(HashMap&lt;String, SimpleVertexEx&gt; hmSVE) {
          this.hmSVE = hmSVE;
      }
  
      public HashMap&lt;EdgeAttrib, SimpleVertexEx&gt; getOhmSVE() {
          return ohmSVE;
      }
  
      public void setOhmSVE(HashMap&lt;EdgeAttrib, SimpleVertexEx&gt; ohmSVE) {
          this.ohmSVE = ohmSVE;
      }
      
      
      public void initInner() {
          this.svinner = new SimpleVertex();
          this.svinner.setS(&quot;sv inner&quot;);
      }
      
      public void testSVEXMethod() {
          System.out.println(&quot;in SVEx&quot;);
      }
  
      public void setSvinner(SimpleVertex svinner) {
          this.svinner = svinner;
      }
  
      public void setSvex(String s) {
          this.svex = s;
      }
      
      public String getSvex() {
          return svex;
      }
  
      public EnumTest getEnumTest() {
          return enumTest;
      }
  
      public void setEnumTest(EnumTest e) {
          this.enumTest = e;
      }
      
      public SimpleVertex getSvinner() {
          return svinner;
      }
  
      public ArrayList&lt;SimpleVertex&gt; getAlSV() {
          return alSV;
      }
  
      public ArrayList&lt;SimpleVertexEx&gt; getAlSVE() {
          return alSVE;
      }
  
      public void setAlSVE(ArrayList&lt;SimpleVertexEx&gt; alSVE) {
          this.alSVE = alSVE;
      }
      
      public HashMap&lt;String, SimpleVertex&gt; getHmSV() {
          return hmSV;
      }
  
      public SimpleVertexEx getLooptest() {
          return looptest;
      }
      
      @DontLoadLinks
      public SimpleVertexEx getLooptestLinkNotLoaded() {
          return looptest;
      }
  
      public void setLooptest(SimpleVertexEx looptest) {
          this.looptest = looptest;
      }
  
      @DontLoadLinks
      public SimpleVertexEx getEagerTest() {
          return eagerTest;
      }
  
      public void setEagerTest(SimpleVertexEx eagerTest) {
          this.eagerTest = eagerTest;
      }
  
      @DontLoadLinks
      public SimpleVertexEx getIndirectLoopTestDontLoad() {
          return indirectLoopTest;
      }
      
      public SimpleVertexEx getIndirectLoopTest() {
          return indirectLoopTest;
      }
  
      @DontLoadLinks
      public SimpleVertexEx getIndirectEagerTest() {
          return indirectEagerTest;
      }
      
      @DontLoadLinks
      public SimpleVertexEx getEagerIndirectEagerTest() {
          return eagerIndirectEagerTest;
      }
  
      public String getUuid() {
          return this.svuuid;
      }
  
      public void setUuid(String uuid) {
          this.svuuid = uuid;
      }
  
      @Override
      public int hashCode() {
          int hash = 7;
          hash = 31 * hash + Objects.hashCode(this.svuuid);
          return hash;
      }
  
      @Override
      public boolean equals(Object obj) {
          if (this == obj) {
              return true;
          }
          if (obj == null) {
              return false;
          }
          if (!SimpleVertexEx.class.isInstance(obj)) {
              return false;
          }
          final SimpleVertexEx other = (SimpleVertexEx) obj;
          return Objects.equals(this.svuuid, other.svuuid);
      }
      
  }
  </code></pre>
  <p>Now, when I use that's objects:</p>
  <pre class="lang-java prettyprint-override"><code>var res = sm.query(SimpleVertexEx.class, &quot;where out('SimpleVertexEx_alSV').size() != 0 limit 1&quot;);
  
  SimpleVertexEx sve = res.get(0);
          
  SimpleVertex sv1 = sve.getAlSV().get(0);
  SimpleVertex sv2 = sve.getAlSV().get(1);
  SimpleVertex sv3 = sve.getAlSV().get(2);
          
  System.out.println(&quot;sv1: &quot;+sv1.getRid());
  System.out.println(&quot;sv2: &quot;+sv2.getRid());
  System.out.println(&quot;sv3: &quot;+sv3.getRid());
  System.out.println(&quot;&quot;+sv1.compareTo(sv2));
  System.out.println(&quot;&quot;+sv2.compareTo(sv3));
          
  var falla = sve.getAlSV().stream().sorted().collect(Collectors.toList());
  </code></pre>
  <p>All the lines works but the last fail.
  Sort call compareTo on the sv's but the proxy get a superMethod = null. Why?
  In the previous lines the call work well.
  This is what the interceptor log:</p>
  <pre><code>MÁS DETALLADO[2022/08/17 10:21:34]:net.odbogm.proxy.ObjectProxy intercept :: =====================================================
  MÁS DETALLADO[2022/08/17 10:21:34]:net.odbogm.proxy.ObjectProxy intercept :: test.SimpleVertex$ByteBuddy$ghrAs2Lb : #414:0 &gt; method: compareTo  superMethod: compareTo$accessor$XL9qkaa5
  MÁS DETALLADO[2022/08/17 10:21:34]:net.odbogm.proxy.ObjectProxy intercept :: =====================================================
  
  MÁS DETALLADO[2022/08/17 11:02:21]:net.odbogm.proxy.ObjectProxy intercept :: =====================================================
  MÁS DETALLADO[2022/08/17 11:02:21]:net.odbogm.proxy.ObjectProxy intercept :: test.SimpleVertex$ByteBuddy$rMJgDCTS : #413:0 &gt; method: compareTo  superMethod: compareTo$accessor$q70euKMf
  MÁS DETALLADO[2022/08/17 11:02:21]:net.odbogm.proxy.ObjectProxy intercept :: =====================================================
  
  MÁS DETALLADO[2022/08/17 10:21:34]:net.odbogm.proxy.ObjectProxy intercept :: =====================================================
  MÁS DETALLADO[2022/08/17 10:21:34]:net.odbogm.proxy.ObjectProxy intercept :: test.SimpleVertex$ByteBuddy$ghrAs2Lb : #413:0 &gt; method: compareTo  superMethod: NULL
  MÁS DETALLADO[2022/08/17 10:21:34]:net.odbogm.proxy.ObjectProxy intercept :: =====================================================
  superMethod == NULL !!!!
  </code></pre>
  <p>At some point it miss the method but I could not reproduce it as a simple script.</p>