the minimal coverage is not correctly checked

[yanns]

I tested the minimal coverage option, and this is the result:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]
[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]
[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [78,40% < 80%]
java.lang.RuntimeException: Coverage minimum was not reached
    at scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)
    at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
    at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
    at sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)
    at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
    at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
    at sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)
    at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
    at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
    at sbt.std.Transform$$anon$4.work(System.scala:64)
    at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
    at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
    at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
    at sbt.Execute.work(Execute.scala:244)
    at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
    at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
    at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
    at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
[error] (scoverage-test:executeTests) Coverage minimum was not reached

[0xRoch]

It fails because minimal coverage is not reached, did you expect something
else ?

On Tue, May 20, 2014 at 10:01 AM, Yann Simon notifications@github.comwrote:

I tested the minimal coverage option, and this is the result:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]
[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]
[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [78,40% < 80%]
java.lang.RuntimeException: Coverage minimum was not reached
at scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$4.work(System.scala:64)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
at sbt.Execute.work(Execute.scala:244)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.java:744)
error Coverage minimum was not reached

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/11
.

[sksamuel]

Yep that looks right ?

On 20 May 2014 09:02, Roch Delsalle notifications@github.com wrote:

It fails because minimal coverage is not reached, did you expect something
else ?

Roch

On Tue, May 20, 2014 at 10:01 AM, Yann Simon notifications@github.comwrote:

I tested the minimal coverage option, and this is the result:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation
[/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]

[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report
[/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]

[info] [scoverage] Generating XML report
[/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]

[info] [scoverage] Generating XML report
[/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]

[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [78,40% < 80%]
java.lang.RuntimeException: Coverage minimum was not reached
at
scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)

at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at
sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)

at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at
sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)

at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$4.work(System.scala:64)
at
sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at
sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
at sbt.Execute.work(Execute.scala:244)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at
sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)

at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at
java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at
java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)

at
java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)

at java.lang.Thread.run(Thread.java:744)
error Coverage minimum was not reached

—
Reply to this email directly or view it on GitHub<
https://github.com/scoverage/sbt-scoverage/issues/11>
.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/11#issuecomment-43596804
.

[yanns]

I'd expect scoverage to generate test to have an higher coverage...
just kidding ;)

Sorry, I copy the wrong terminal. The real error:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]
[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]
[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [78,40% < 70%]
java.lang.RuntimeException: Coverage minimum was not reached
    at scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)
    at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
    at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
    at sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)
    at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
    at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
    at sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)
    at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
    at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
    at sbt.std.Transform$$anon$4.work(System.scala:64)
    at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
    at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
    at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
    at sbt.Execute.work(Execute.scala:244)
    at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
    at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
    at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
    at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
[error] (scoverage-test:executeTests) Coverage minimum was not reached
[error] Total time: 80 s, completed 20.05.2014 10:31:28

Notice the 78,40% < 70%

[sksamuel]

That's been fixed in a newer release. Try 0.99.3 and there's even more
fixes going out in 0.99.4 which I'll release today.

On 20 May 2014 09:33, Yann Simon notifications@github.com wrote:

I'd expect scoverage to generate test to have an higher coverage...
just kidding ;)

Sorry, I copy the wrong terminal. The real error:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]
[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]
[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [78,40% < 70%]
java.lang.RuntimeException: Coverage minimum was not reached
at scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$4.work(System.scala:64)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
at sbt.Execute.work(Execute.scala:244)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.
java:744)
error Coverage minimum was not reached
[error] Total time: 80 s, completed 20.05.2014 10:31:28

Notice the 78,40% < 70%

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/11#issuecomment-43599416
.

[0xRoch]

Ok, this is related to : #7
It will be fixed in the next release, or in the current SNAPSHOT

On Tue, May 20, 2014 at 10:33 AM, Yann Simon notifications@github.comwrote:

I'd expect scoverage to generate test to have an higher coverage...
just kidding ;)

Sorry, I copy the wrong terminal. The real error:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]
[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]
[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [78,40% < 70%]
java.lang.RuntimeException: Coverage minimum was not reached
at scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
at sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
at sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
at sbt.std.Transform$$anon$4.work(System.scala:64)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
at sbt.Execute.work(Execute.scala:244)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
at java.util.concurrent.FutureTask.run(FutureTask.java:262)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
at java.lang.Thread.run(Thread.
java:744)
error Coverage minimum was not reached
[error] Total time: 80 s, completed 20.05.2014 10:31:28

Notice the 78,40% < 70%

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/11#issuecomment-43599416
.

[yanns]

@sksamuel @D-Roch thanks for the quick answer!
I'll try again with the new version then!

[sksamuel]

0.99.4 is out

[yanns]

the issue is not fixed with 0.99.4:

[info] [scoverage] Waiting for measurement data to sync...
[info] [scoverage] Reading scoverage instrumentation [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-data/scoverage.coverage.xml]
[info] [scoverage] Reading scoverage measurements...
[info] [scoverage] Generating Cobertura report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/coverage-report/cobertura.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/scoverage.xml]
[info] [scoverage] Generating XML report [/home/simon/ePost/project/apps/MUI/app/target/scala-2.10/scoverage-report/index.html]
[info] [scoverage] Reports completed
[error] [scoverage] Coverage is below minimum [79,66% < 75%]
java.lang.RuntimeException: Coverage minimum was not reached
    at scoverage.ScoverageSbtPlugin$$anonfun$testsCleanup$1$$anonfun$apply$2.apply$mcV$sp(ScoverageSbtPlugin.scala:150)
    at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
    at sbt.Tests$$anonfun$Cleanup$1.apply(Tests.scala:53)
    at sbt.Tests$$anonfun$sbt$Tests$$partApp$1$1$$anonfun$apply$1.apply$mcV$sp(Tests.scala:160)
    at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
    at sbt.Tests$$anonfun$sbt$Tests$$fj$1$1.apply(Tests.scala:159)
    at sbt.std.TaskExtra$$anon$1$$anonfun$fork$1$$anonfun$apply$1.apply(TaskExtra.scala:99)
    at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
    at sbt.std.Transform$$anon$3$$anonfun$apply$2.apply(System.scala:45)
    at sbt.std.Transform$$anon$4.work(System.scala:64)
    at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
    at sbt.Execute$$anonfun$submit$1$$anonfun$apply$1.apply(Execute.scala:237)
    at sbt.ErrorHandling$.wideConvert(ErrorHandling.scala:18)
    at sbt.Execute.work(Execute.scala:244)
    at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
    at sbt.Execute$$anonfun$submit$1.apply(Execute.scala:237)
    at sbt.ConcurrentRestrictions$$anon$4$$anonfun$1.apply(ConcurrentRestrictions.scala:160)
    at sbt.CompletionService$$anon$2.call(CompletionService.scala:30)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)
[error] (scoverage-test:executeTests) Coverage minimum was not reached

[tbarker9comcast]

I had the same problem with 0.99.4

[sksamuel]

This is the code in 0.99.4:

            if (min > 0) {
                if (min > coverage.statementCoverage) {
                  s.log.error(s"[scoverage] Coverage is below minimum [${coverage.statementCoverageFormatted}% < $min%]")
                  if (failOnMin)
                    throw new RuntimeException("Coverage minimum was not reached")
                } else {
                  s.log.info(s"[scoverage] Coverage is above minimum [${coverage.statementCoverageFormatted}% > $min%]")
                }
              }

I don't see what's wrong with it. Are you definitely sure you're using 0.99.4?

[tbarker9comcast]

in my plugins.sbt I have addSbtPlugin("org.scoverage" %% "sbt-scoverage" % "0.99.4")

after calling rm -rf ~/.ivy2/cache/org.scoverage/ in case there is a caching issue and then calling sbt clean scoverage:test I get

[error] [scoverage] Coverage is below minimum [99.07% < 90%]

[sksamuel]

Ok I got it.

On 20 May 2014 19:10, Tommy Barker notifications@github.com wrote:

in my plugins.sbt I have addSbtPlugin("org.scoverage" %% "sbt-scoverage"
% "0.99.4")

after calling rm -rf ~/.ivy2/cache/org.scoverage/ in case there is a
caching issue and then calling sbt clean scoverage:test I get

[error] [scoverage] Coverage is below minimum [99.07% < 90%]

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/11#issuecomment-43662692
.

[tbarker9comcast]

actually the code is wrong, it should be the other way, right? ie min < coverage.statementCoverage