PerfTestConfiguration

cz.encircled.jput.model.PerfTestConfiguration

```
public class PerfTestConfiguration
```
Performance test configuration of a single junit test method

Constructor Summary

Constructors
Constructor and Description
`PerfTestConfiguration(java.lang.String testId, int warmUp, int repeats, long runTime, long delay, long maxTimeLimit, long avgTimeLimit, java.util.Map<java.lang.Double,java.lang.Long> percentiles, int parallelCount, long rampUp, boolean isReactive, long maxAllowedExceptionsCount, boolean continueOnException, TrendTestConfiguration trendConfiguration)` Performance test configuration of a single junit test method

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.String`	`component1()` Unique test id,
`long`	`component10()` Ramp-up in milliseconds.
`boolean`	`component11()`
`long`	`component12()` Unit test will be marked as failed,
`boolean`	`component13()` TODO implement: reactive
`TrendTestConfiguration`	`component14()` Performance trend analyzing
`int`	`component2()` Count of warm up test executions
`int`	`component3()` Test execution repeats count
`long`	`component4()` TODO
`long`	`component5()` Delay between test repeats,
`long`	`component6()` Upper limit for test execution time in milliseconds
`long`	`component7()` Upper limit for average execution time when using
`java.util.Map<java.lang.Double,java.lang.Long>`	`component8()` Upper limits for test execution time in milliseconds within defined percentiles. Defining multiple percentiles allows to have multiple validation constraints, for instance 200ms for 75% and 500ms for 95%.
`int`	`component9()` Count of maximum parallel executions
`PerfTestConfiguration`	`copy(java.lang.String testId, int warmUp, int repeats, long runTime, long delay, long maxTimeLimit, long avgTimeLimit, java.util.Map<java.lang.Double,java.lang.Long> percentiles, int parallelCount, long rampUp, boolean isReactive, long maxAllowedExceptionsCount, boolean continueOnException, TrendTestConfiguration trendConfiguration)` Performance test configuration of a single junit test method
`boolean`	`equals(java.lang.Object p)`
`long`	`getAvgTimeLimit()` Upper limit for average execution time when using
`boolean`	`getContinueOnException()` TODO implement: reactive
`long`	`getDelay()` Delay between test repeats,
`long`	`getMaxAllowedExceptionsCount()` Unit test will be marked as failed,
`long`	`getMaxTimeLimit()` Upper limit for test execution time in milliseconds
`int`	`getParallelCount()` Count of maximum parallel executions
`java.util.Map<java.lang.Double,java.lang.Long>`	`getPercentiles()` Upper limits for test execution time in milliseconds within defined percentiles. Defining multiple percentiles allows to have multiple validation constraints, for instance 200ms for 75% and 500ms for 95%.
`long`	`getRampUp()` Ramp-up in milliseconds.
`int`	`getRepeats()` Test execution repeats count
`long`	`getRunTime()` TODO
`java.lang.String`	`getTestId()` Unique test id,
`TrendTestConfiguration`	`getTrendConfiguration()` Performance trend analyzing
`int`	`getWarmUp()` Count of warm up test executions
`int`	`hashCode()`
`boolean`	`isReactive()`
`java.lang.String`	`toString()`
`PerfTestConfiguration`	`valid()`

- Constructor Detail
  - PerfTestConfiguration
```
public PerfTestConfiguration(java.lang.String testId,
                             int warmUp,
                             int repeats,
                             long runTime,
                             long delay,
                             long maxTimeLimit,
                             long avgTimeLimit,
                             java.util.Map<java.lang.Double,java.lang.Long> percentiles,
                             int parallelCount,
                             long rampUp,
                             boolean isReactive,
                             long maxAllowedExceptionsCount,
                             boolean continueOnException,
                             TrendTestConfiguration trendConfiguration)
```
    Performance test configuration of a single junit test method
    
    Parameters:
    
    testId - Unique test id, used to distinguish different tests. Default to testClassName#testMethodName
    
    warmUp - Count of warm up test executions
    
    repeats - Test execution repeats count
    
    runTime - TODO
    
    delay - Delay between test repeats, in ms
    
    maxTimeLimit - Upper limit for test execution time in milliseconds
    
    avgTimeLimit - Upper limit for average execution time when using repeats > 1, in milliseconds
    
    percentiles -
    Upper limits for test execution time in milliseconds within defined percentiles. Defining multiple percentiles allows to have multiple validation constraints, for instance 200ms for 75% and 500ms for 95%.
    Map is rank to maxTime
    
    parallelCount - Count of maximum parallel executions (e.g. java threads in case of base executor or coroutines/reactive executions)
    
    rampUp - Ramp-up in milliseconds. If parallel is 100, and the ramp-up period is 100000 (100 seconds),then JPut will take 100 seconds to get all 100 threads running, i.e. 1 second delay after each new thread
    
    maxAllowedExceptionsCount - Unit test will be marked as failed, if catched exceptions count is greater than this parameter
    
    continueOnException -
    TODO implement: reactive
    If true, jput will catch runtime exceptions and save errored repeats with result code "500" and corresponding error message.
    
    trendConfiguration - Performance trend analyzing
- Method Detail
  - valid
```
public PerfTestConfiguration valid()
```
  - toString
```
public java.lang.String toString()
```
  - getTestId
```
public java.lang.String getTestId()
```
    Unique test id,
    used to distinguish different tests. Default to testClassName#testMethodName
  - getWarmUp
```
public int getWarmUp()
```
    Count of warm up test executions
  - getRepeats
```
public int getRepeats()
```
    Test execution repeats count
  - getRunTime
```
public long getRunTime()
```
    TODO
  - getDelay
```
public long getDelay()
```
    Delay between test repeats,
    in ms
  - getMaxTimeLimit
```
public long getMaxTimeLimit()
```
    Upper limit for test execution time in milliseconds
  - getAvgTimeLimit
```
public long getAvgTimeLimit()
```
    Upper limit for average execution time when using
    repeats > 1, in milliseconds
  - getPercentiles
```
public java.util.Map<java.lang.Double,java.lang.Long> getPercentiles()
```
    Upper limits for test execution time in milliseconds within defined percentiles. Defining multiple percentiles allows to have multiple validation constraints, for instance 200ms for 75% and 500ms for 95%.
    Map is rank to maxTime
    
    See Also:
    
    200ms for 75%, 500ms for 95%
  - getParallelCount
```
public int getParallelCount()
```
    Count of maximum parallel executions
    (e.g. java threads in case of base executor or coroutines/reactive executions)
  - getRampUp
```
public long getRampUp()
```
    Ramp-up in milliseconds.
    If parallel is 100, and the ramp-up period is 100000 (100 seconds),then JPut will take 100 seconds to get all 100 threads running, i.e. 1 second delay after each new thread
  - isReactive
```
public boolean isReactive()
```
  - getMaxAllowedExceptionsCount
```
public long getMaxAllowedExceptionsCount()
```
    Unit test will be marked as failed,
    if catched exceptions count is greater than this parameter
  - getContinueOnException
```
public boolean getContinueOnException()
```
    TODO implement: reactive
    If true, jput will catch runtime exceptions and save errored repeats with result code "500" and corresponding error message.
  - getTrendConfiguration
```
public TrendTestConfiguration getTrendConfiguration()
```
    Performance trend analyzing
  - component1
```
public java.lang.String component1()
```
    Unique test id,
    used to distinguish different tests. Default to testClassName#testMethodName
  - component2
```
public int component2()
```
    Count of warm up test executions
  - component3
```
public int component3()
```
    Test execution repeats count
  - component4
```
public long component4()
```
    TODO
  - component5
```
public long component5()
```
    Delay between test repeats,
    in ms
  - component6
```
public long component6()
```
    Upper limit for test execution time in milliseconds
  - component7
```
public long component7()
```
    Upper limit for average execution time when using
    repeats > 1, in milliseconds
  - component8
```
public java.util.Map<java.lang.Double,java.lang.Long> component8()
```
    Upper limits for test execution time in milliseconds within defined percentiles. Defining multiple percentiles allows to have multiple validation constraints, for instance 200ms for 75% and 500ms for 95%.
    Map is rank to maxTime
    
    See Also:
    
    200ms for 75%, 500ms for 95%
  - component9
```
public int component9()
```
    Count of maximum parallel executions
    (e.g. java threads in case of base executor or coroutines/reactive executions)
  - component10
```
public long component10()
```
    Ramp-up in milliseconds.
    If parallel is 100, and the ramp-up period is 100000 (100 seconds),then JPut will take 100 seconds to get all 100 threads running, i.e. 1 second delay after each new thread
  - component11
```
public boolean component11()
```
  - component12
```
public long component12()
```
    Unit test will be marked as failed,
    if catched exceptions count is greater than this parameter
  - component13
```
public boolean component13()
```
    TODO implement: reactive
    If true, jput will catch runtime exceptions and save errored repeats with result code "500" and corresponding error message.
  - component14
```
public TrendTestConfiguration component14()
```
    Performance trend analyzing
  - copy
```
public PerfTestConfiguration copy(java.lang.String testId,
                                  int warmUp,
                                  int repeats,
                                  long runTime,
                                  long delay,
                                  long maxTimeLimit,
                                  long avgTimeLimit,
                                  java.util.Map<java.lang.Double,java.lang.Long> percentiles,
                                  int parallelCount,
                                  long rampUp,
                                  boolean isReactive,
                                  long maxAllowedExceptionsCount,
                                  boolean continueOnException,
                                  TrendTestConfiguration trendConfiguration)
```
    Performance test configuration of a single junit test method
  - hashCode
```
public int hashCode()
```
  - equals
```
public boolean equals(java.lang.Object p)
```

Class PerfTestConfiguration

Constructor Summary

Method Summary

Constructor Detail

PerfTestConfiguration

Method Detail

valid

toString

getTestId

getWarmUp

getRepeats

getRunTime

getDelay

getMaxTimeLimit

getAvgTimeLimit

getPercentiles

getParallelCount

getRampUp

isReactive

getMaxAllowedExceptionsCount

getContinueOnException

getTrendConfiguration

component1

component2

component3

component4

component5

component6

component7

component8

component9

component10

component11

component12

component13

component14

copy

hashCode

equals