# Lombok bei Jaccoco excluden



## 8u3631984 (11. Aug 2022)

Hallo ich möchte in meinem Gradle Project gerne meine Lombok Klassen exclude - also z.B Builder Klassen.
Ich habe dazu im Root verezichnis die Datei  lombok.config mit folgendem Inhalt angelgt : 
lombok.addLombokGeneratedAnnotation = true

Hier meine Jaccoco Configuration in Gradle.

```
test {
    useJUnitPlatform()

    maxParallelForks = 3

    finalizedBy jacocoTestReport
}

jacocoTestCoverageVerification {
    dependsOn test

    violationRules {
        rule {
            limit {
                counter = 'CLASS'
                minimum = 0.90
            }
            limit {
                counter = 'METHOD'
                minimum = 0.80
            }
            limit {
                counter = 'LINE'
                minimum = 0.80
            }
            limit {
                counter = 'BRANCH'
                minimum = 0.80
            }
        }
    }
}
```

Leider werden KLassen wie z.B SamsCompetitionBuilder trotzdem im Testreport bei der Berechnung berücksichtigt.
Hat jemand eine Idee


----------



## httpdigest (11. Aug 2022)

Hast du schonmal verifiziert, ob die Lombok-generierten Klassen jetzt auch die `lombok.Generated` Annotation tragen? Z.B. mit javap.
Da sollte sowas erscheinen:

```
RuntimeInvisibleAnnotations:
      0: #38()
        lombok.Generated
```


----------



## 8u3631984 (11. Aug 2022)

Danke für die Info. Aber wenn ich den Befehl javap SamsCompetitionBuilder bekomme ich immer die Meldung, dass er die Klasse nicht findet.


----------



## httpdigest (11. Aug 2022)

Wenn dir jemand einen Begriff (wie "javap") nennt, sollte dein erster Reflex immer sein: https://www.google.com/search?q=javap
Bitte informiere dich also erstmal darüber, was `javap` für ein Tool ist und wie man es exakt aufruft, also welche Argumente es tatsächlich erwartet und was sie bedeuten.
Oder nutze alternativ andere Tools deiner Wahl, um die generierten Klassen zu prüfen.
Du kannst sie auch einfach mit einem Hex- oder Texteditor öffnen und einfach nach "lombok/Generated" suchen.


----------



## 8u3631984 (12. Aug 2022)

Sorry war gestern abend wohl zu motiviert .
Habe nun per javap mal nach den Bilder Klassen geschuat - also javap "BUILDER.class"
Allerdings sehe dor nicht lombok generated annotation.

Gibt es evtl. noch eine andere Möglichkeit


----------



## LimDul (12. Aug 2022)

Schau mal hier, da ist ein Workaround beschrieben: https://stackoverflow.com/questions...ombok-config-doesnt-ignore-lombok-annotations

(Klingt für mich allerdings nach einem Bug in Lombok, wundert mich, dass der dann nach 1 1/2 Jahren immer noch da ist)


----------



## 8u3631984 (12. Aug 2022)

Vielelicht noch eine Info. 
Ich habe ein Gradle Project  und habe die lombok.config im gleichen Verezcihnis angelegt wo auch die build.gradle angelegt ist.

Ich verwende folgenden Versionen : 

```
ext {
    springVersion = '2.7.2'
    lombokVersion = '1.18.24'
    h2Version = '2.1.214'
}
dependencies {
    // spring dependencies
    implementation "org.springframework.boot:spring-boot-starter-web:${springVersion}"
    implementation "org.springframework.boot:spring-boot-starter-data-jpa:${springVersion}"

    testImplementation "org.springframework.boot:spring-boot-starter-test:${springVersion}"

    // lombok dependencies
    compileOnly "org.projectlombok:lombok:${lombokVersion}"
    annotationProcessor "org.projectlombok:lombok:${lombokVersion}"

    testCompileOnly "org.projectlombok:lombok:${lombokVersion}"
    testAnnotationProcessor "org.projectlombok:lombok:${lombokVersion}"

    // database dependencies
    runtimeOnly "com.h2database:h2:${h2Version}"
}
jacoco {
    toolVersion = "0.8.8"
}
```


----------



## 8u3631984 (12. Aug 2022)

Danke für deine HIlfe . Habe nun mal versucht den Hinweis aus dem Link umzusetzen : 

```
@lombok.Builder(setterPrefix = "with")
@lombok.AllArgsConstructor
@lombok.NoArgsConstructor
@Entity
@Table(name = "samsSeason", uniqueConstraints = @UniqueConstraint(columnNames = {"startYear", "endYear"}))
@lombok.ToString(callSuper = true)
public class SamsSeason extends VolleyballModel implements Season {

    @lombok.Getter
    int startYear;

    @lombok.Getter
    int endYear;
}
```

Im TestReport taucht trotzdem der SamsSeasonBuilder auf


----------



## 8u3631984 (24. Aug 2022)

Hallo ich habe das Thema noch einmal aufgegriffen in einem abgespeckten Test Project : 

Dies ist meine build.gradle

```
plugins {
    id 'java'
    id 'jacoco'
    id 'org.springframework.boot' version '2.7.2'
    id "com.palantir.docker" version "0.22.1"
}

group 'example'
version '0.0.1-SNAPSHOT'

// java version
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11

repositories {
    mavenCentral()
}

ext {
    springVersion = '2.7.2'
    lombokVersion = '1.18.24'
    h2Version = '2.1.214'
    guavaVersion = '23.0'
    commonsioVersion = '2.11.0'
    mockitoVersion = '4.6.1'
}
dependencies {
    // spring dependencies
    implementation "org.springframework.boot:spring-boot-starter-web:${springVersion}"
    implementation "org.springframework.boot:spring-boot-starter-data-jpa:${springVersion}"

    testImplementation "org.springframework.boot:spring-boot-starter-test:${springVersion}"

    // lombok dependencies
    compileOnly "org.projectlombok:lombok:${lombokVersion}"
    annotationProcessor "org.projectlombok:lombok:${lombokVersion}"

    testCompileOnly "org.projectlombok:lombok:${lombokVersion}"
    testAnnotationProcessor "org.projectlombok:lombok:${lombokVersion}"

    // utils dependencies
    implementation "commons-io:commons-io:${commonsioVersion}"
    implementation "com.google.guava:guava:${guavaVersion}"

    // test utils dependencies
    implementation "org.mockito:mockito-inline:${mockitoVersion}"

    // database dependencies
    runtimeOnly "com.h2database:h2:${h2Version}"
}

test {
    useJUnitPlatform()

    maxParallelForks = 3

    finalizedBy jacocoTestReport
}



jacoco {
    toolVersion = "0.8.8"
}

jacocoTestCoverageVerification {
    dependsOn test

    violationRules {
        rule {
            limit {
                counter = 'CLASS'
                minimum = 0.75
            }
            limit {
                counter = 'METHOD'
                minimum = 0.75
            }
            limit {
                counter = 'LINE'
                minimum = 0.75
            }
            limit {
                counter = 'BRANCH'
                minimum = 0.50
            }
        }
    }
}
```

Meine lombok.config :
	
	
	
	





```
lombok.addLombokGeneratedAnnotation = true
```

Meine Example Klasse : 

```
package example;

import lombok.Builder;

@Builder
public class ExampleCoverage {

    private String msg;

    public void uncoveredCode(){

    }
}
```

Ich habe danach das Projekt mit gradle gebaut : 


```
gradle build jacocoTestReport
```

Ich habe per javap die gebaute Klasse mir mal angesehen :

```
javap -v -p  build.classes.java.main.example.ExampleCoverage
```

Heir die ausgabe : 

```
Warning: File ./build/classes/java/main/example/ExampleCoverage.class does not contain class build.classes.java.main.example.ExampleCoverage
Classfile /home/sebastian/git/learning/build/classes/java/main/example/ExampleCoverage.class
  Last modified 24.08.2022; size 794 bytes
  SHA-256 checksum d2e4671084c0ce5b404dca24744b8fbcecb98c6fc8b67350bb89042ac8d40590
  Compiled from "ExampleCoverage.java"
public class example.ExampleCoverage
  minor version: 0
  major version: 55
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #8                          // example/ExampleCoverage
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 1, methods: 3, attributes: 3
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // example/ExampleCoverage.msg:Ljava/lang/String;
   #8 = Class              #10            // example/ExampleCoverage
   #9 = NameAndType        #11:#12        // msg:Ljava/lang/String;
  #10 = Utf8               example/ExampleCoverage
  #11 = Utf8               msg
  #12 = Utf8               Ljava/lang/String;
  #13 = Class              #14            // example/ExampleCoverage$ExampleCoverageBuilder
  #14 = Utf8               example/ExampleCoverage$ExampleCoverageBuilder
  #15 = Methodref          #13.#3         // example/ExampleCoverage$ExampleCoverageBuilder."<init>":()V
  #16 = Utf8               uncoveredCode
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lexample/ExampleCoverage;
  #22 = Utf8               (Ljava/lang/String;)V
  #23 = Utf8               MethodParameters
  #24 = Utf8               RuntimeInvisibleAnnotations
  #25 = Utf8               Llombok/Generated;
  #26 = Utf8               builder
  #27 = Utf8               ()Lexample/ExampleCoverage$ExampleCoverageBuilder;
  #28 = Utf8               SourceFile
  #29 = Utf8               ExampleCoverage.java
  #30 = Utf8               NestMembers
  #31 = Utf8               InnerClasses
  #32 = Utf8               ExampleCoverageBuilder
{
  private java.lang.String msg;
    descriptor: Ljava/lang/String;
    flags: (0x0002) ACC_PRIVATE

  public void uncoveredCode();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 12: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       1     0  this   Lexample/ExampleCoverage;

  example.ExampleCoverage(java.lang.String);
    descriptor: (Ljava/lang/String;)V
    flags: (0x0000)
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: aload_1
         6: putfield      #7                  // Field msg:Ljava/lang/String;
         9: return
      LineNumberTable:
        line 5: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  this   Lexample/ExampleCoverage;
            0      10     1   msg   Ljava/lang/String;
    MethodParameters:
      Name                           Flags
      msg                            final
    RuntimeInvisibleAnnotations:
      0: #25()
        lombok.Generated

  public static example.ExampleCoverage$ExampleCoverageBuilder builder();
    descriptor: ()Lexample/ExampleCoverage$ExampleCoverageBuilder;
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: new           #13                 // class example/ExampleCoverage$ExampleCoverageBuilder
         3: dup
         4: invokespecial #15                 // Method example/ExampleCoverage$ExampleCoverageBuilder."<init>":()V
         7: areturn
      LineNumberTable:
        line 5: 0
    RuntimeInvisibleAnnotations:
      0: #25()
        lombok.Generated
}
SourceFile: "ExampleCoverage.java"
NestMembers:
  example/ExampleCoverage$ExampleCoverageBuilder
InnerClasses:
  public static #32= #13 of #8;           // ExampleCoverageBuilder=class example/ExampleCoverage$ExampleCoverageBuilder of class example/ExampleCoverage
```

Ich kann nicht so richtig einschätzen ob die gebaute Klasse richtig aussieht. Aber im Testreport taucht die Builder Klasse noch auf


----------



## 8u3631984 (24. Aug 2022)

Ich habe vielleicht noch eine wichtige Info : Den Test den ich oben beschrieben habe, war nur eine Application.
Also das src Directory liegt im root ordner.

Wenn ich jedoch eine Module anlege und den gleichen aufruf erneut mache, wird die Builder Klasse nicht mehr im Testreport berücksichtigt.

Ist das ein Bug oder baue ich das Gradle Projekt falsch


----------

