com.carrotsearch.junitbenchmarks.BenchmarkOptions Java Examples

@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws IllegalAccessException, IllegalArgumentException,
        InvocationTargetException {
    if (method.getName().equals("benchmarkRounds")) {
        log.trace("Intercepted benchmarkRounds() invocation: returning {}", rounds);
        return rounds;
    }
    if (method.getName().equals("warmupRounds")) {
        log.trace("Intercepted warmupRounds() invocation: returning {}", WARMUP_ROUNDS);
        return WARMUP_ROUNDS;
    }
    if (method.getName().equals("annotationType")) {
        return BenchmarkOptions.class;
    }
    log.trace("Returning default value for method intercepted invocation of method {}", method.getName());
    return method.getDefaultValue();
}
 

@BenchmarkOptions(
        benchmarkRounds = 20000,
        warmupRounds = 2000,
        concurrency = BenchmarkOptions.CONCURRENCY_AVAILABLE_CORES)
@Test
public void benchmarkFindRule() throws Exception {
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule("www.global.prod.fastly.net");
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
    index.findRule(RandomStringUtils.random(2));
}
 

@BenchmarkOptions(
        benchmarkRounds = 10000,
        concurrency = BenchmarkOptions.CONCURRENCY_AVAILABLE_CORES)
@Test
public void testGetRegistrableDomain() throws IOException {
    for (String[] tupel : TestUtil.getCheckPublicSuffixCases()) {
        String domain = tupel[0];
        String registrableDomain = tupel[1];

        String actual = StringUtils.lowerCase(psl.getRegistrableDomain(domain));
        String expected = StringUtils.lowerCase(registrableDomain);
        assertEquals(
            String.format("%s should return %s, but was %s", domain, expected, actual),
            expected,
            actual
        );
    }
}
 

@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 2)
@Test
public void writeDeltaPackingTest(){
  DeltaBinaryPackingValuesWriter writer = new DeltaBinaryPackingValuesWriterForInteger(
      blockSize, miniBlockNum, 100, 20000, new DirectByteBufferAllocator());
  runWriteTest(writer);
}
 

/**
 * Tests the GraalVM JavaScript script runner
 * @throws Exception if something goes wrong
 */
@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 1)
@Test
@Ignore("Should not be called together with other tests because it sets " +
        "CSL.sharedRunner, which cannot be reset")
public void graaljs() throws Exception {
    RunnerType prev = ScriptRunnerFactory.setRunnerType(RunnerType.GRAALJS);
    try {
        runTest();
    } finally {
        ScriptRunnerFactory.setRunnerType(prev);
    }
}
 

/**
 * Tests the JRE script runner
 * @throws Exception if something goes wrong
 */
@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 1)
@Test
@Ignore("Should not be called together with other tests because it sets " +
        "CSL.sharedRunner, which cannot be reset")
public void jre() throws Exception {
    RunnerType prev = ScriptRunnerFactory.setRunnerType(RunnerType.JRE);
    try {
        runTest();
    } finally {
        ScriptRunnerFactory.setRunnerType(prev);
    }
}
 

@BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 1)
@Test
@Ignore
public void shouldAllowTraceePrefixedParameters() {
	System.setProperty(PropertiesBasedTraceeFilterConfiguration.TRACEE_DEFAULT_PROFILE_PREFIX + CHANNEL, "tracee.*");

	for (int i = 0; i < 2000000; i++) {
		final Map<String, String> filteredProperties = unit.filterDeniedParams(propertyMap, CHANNEL);
		assertThat(filteredProperties.size(), is(2));
	}
}
 

@BenchmarkOptions(benchmarkRounds = 1, warmupRounds = 1)
@Test
@Ignore
public void shouldPermitAll() {

	for (int i = 0; i < 2000000; i++) {
		final Map<String, String> filteredProperties = unit.filterDeniedParams(propertyMap, CHANNEL);
		assertThat(filteredProperties.size(), is(4));
	}
}
 

@BenchmarkOptions(benchmarkRounds = 3, warmupRounds = 1)
@Test
@Ignore
public void ibanValidation() {

    for(int i = 0; i < LOOPS_COUNT; i++) {
        IbanUtil.validate("DE89370400440532013000");
    }
}
 

@BenchmarkOptions(benchmarkRounds = 3, warmupRounds = 1)
@Test
@Ignore
public void ibanConstruction() {

    for(int i = 0; i < LOOPS_COUNT; i++) {
        Iban iban = new Iban.Builder()
                        .countryCode(CountryCode.DE)
                        .bankCode("52060170")
                        .accountNumber("0012335785")
                        .build();
    }
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 4)
@Test
public void benchmarkSortedStringsWithDeltaLengthByteArrayValuesWriter() throws IOException {
  DeltaByteArrayWriter writer = new DeltaByteArrayWriter(64 * 1024, 64 * 1024, new DirectByteBufferAllocator());
  DeltaByteArrayReader reader = new DeltaByteArrayReader();

  Utils.writeData(writer, sortedVals);
  ByteBufferInputStream data = writer.getBytes().toInputStream();
  Utils.readData(reader, data, values.length);
  System.out.println("size " + data.position());
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 4)
@Test
public void benchmarkSortedStringsWithPlainValuesWriter() throws IOException {
  PlainValuesWriter writer = new PlainValuesWriter(64 * 1024, 64 * 1024, new DirectByteBufferAllocator());
  BinaryPlainValuesReader reader = new BinaryPlainValuesReader();

  Utils.writeData(writer, sortedVals);
  ByteBufferInputStream data = writer.getBytes().toInputStream();
  Utils.readData(reader, data, values.length);
  System.out.println("size " + data.position());
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 4)
@Test
public void benchmarkRandomStringsWithDeltaLengthByteArrayValuesWriter() throws IOException {
  DeltaByteArrayWriter writer = new DeltaByteArrayWriter(64 * 1024, 64 * 1024, new DirectByteBufferAllocator());
  DeltaByteArrayReader reader = new DeltaByteArrayReader();

  Utils.writeData(writer, values);
  ByteBufferInputStream data = writer.getBytes().toInputStream();
  Utils.readData(reader, data, values.length);
  System.out.println("size " + data.position());
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 4)
@Test
public void benchmarkRandomStringsWithPlainValuesWriter() throws IOException {
  PlainValuesWriter writer = new PlainValuesWriter(64 * 1024, 64 * 1024, new DirectByteBufferAllocator());
  BinaryPlainValuesReader reader = new BinaryPlainValuesReader();

  Utils.writeData(writer, values);
  ByteBufferInputStream data = writer.getBytes().toInputStream();
  Utils.readData(reader, data, values.length);
  System.out.println("size " + data.position());
}
 

@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 2)
@Test
public void writeDeltaPackingTest2(){
  DeltaBinaryPackingValuesWriter writer = new DeltaBinaryPackingValuesWriterForInteger(
      blockSize, miniBlockNum, 100, 20000, new DirectByteBufferAllocator());
  runWriteTest(writer);
}
 

@Ignore
@BenchmarkOptions(benchmarkRounds=200, concurrency=BenchmarkOptions.CONCURRENCY_AVAILABLE_CORES)
@Test
public void testParallelResourceAccess() throws ClientException
{
	SampleEntity entity = client.retrieveEntitySample1(token);
	assertNotNull(entity);
	assertEquals("manager", entity.getUsername());
	assertEquals(clientEntity.getClientId(), entity.getClientApp());
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 10)
@Test
public void readingRLE() throws IOException {
  for (int j = 0; j < 10; j++) {

    ValuesReader reader = new RunLengthBitPackingHybridValuesReader(32);
    readData(reader, rleBytes);
  }
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 10)
@Test
public void readingDelta() throws IOException {
  for (int j = 0; j < 10; j++) {

    DeltaBinaryPackingValuesReader reader = new DeltaBinaryPackingValuesReader();
    readData(reader, deltaBytes);
  }
}
 

@Ignore
@BenchmarkOptions(benchmarkRounds=200, concurrency=BenchmarkOptions.CONCURRENCY_SEQUENTIAL)
@Test
public void testResourceAccessWithRefresh() throws ClientException
{
	testCount++;
	if (testCount % 50 == 0 && testCount>0)
		token = client.refreshToken((OAuth2Token)token);
	SampleEntity entity = client.retrieveEntitySample1(token);
	assertNotNull(entity);
	assertEquals("manager", entity.getUsername());
	assertEquals(clientEntity.getClientId(), entity.getClientApp());
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 4)
@Test
public void benchmarkRandomStringsWithDeltaLengthByteArrayValuesWriter() throws IOException {
  DeltaLengthByteArrayValuesWriter writer = new DeltaLengthByteArrayValuesWriter(64 * 1024, 64 * 1024, new DirectByteBufferAllocator());
  DeltaLengthByteArrayValuesReader reader = new DeltaLengthByteArrayValuesReader();

  Utils.writeData(writer, values);
  ByteBufferInputStream data = writer.getBytes().toInputStream();
  Utils.readData(reader, data, values.length);
  System.out.println("size " + data.position());
}
 

@BenchmarkOptions(benchmarkRounds = 20, warmupRounds = 4)
@Test
public void benchmarkRandomStringsWithPlainValuesWriter() throws IOException {
  PlainValuesWriter writer = new PlainValuesWriter(64 * 1024, 64 * 1024, new DirectByteBufferAllocator());
  BinaryPlainValuesReader reader = new BinaryPlainValuesReader();

  Utils.writeData(writer, values);
  ByteBufferInputStream data = writer.getBytes().toInputStream();
  Utils.readData(reader, data, values.length);
  System.out.println("size " + data.position());
}
 

@BenchmarkOptions(
        benchmarkRounds = 5000,
        concurrency = BenchmarkOptions.CONCURRENCY_AVAILABLE_CORES)
@Test
public void benchmarkFindRule() throws Exception {
    assertEquals(
            "global.prod.fastly.net",
            index.findRule("www.global.prod.fastly.net").getPattern());
}
 

@Ignore
@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 2, concurrency = 8)
@Test
public void benchmark() throws InterruptedException {
    for (int i = 0; i < 100000; ++i) {
        logger.info("A VERY IMPORTANT LOG MESSAGE {}", i);
    }
}
 

@Override
public Statement apply(Statement base, Description description) {
    Class<?> clazz = description.getTestClass();
    String mname = description.getMethodName();
    Collection<Annotation> annotations = description.getAnnotations();
    final int rounds = getRoundsForFullMethodName(clazz.getCanonicalName() + "." + mname);

    List<Annotation> modifiedAnnotations = new ArrayList<Annotation>(annotations.size());

    boolean hit = false;

    for (Annotation a : annotations) {
        if (a.annotationType().equals(BenchmarkOptions.class)) {
            final BenchmarkOptions old = (BenchmarkOptions)a;
            BenchmarkOptions replacement = getWrappedBenchmarkOptions(old, rounds);
            modifiedAnnotations.add(replacement);
            log.debug("Modified BenchmarkOptions annotation on {}", mname);
            hit = true;
        } else {
            modifiedAnnotations.add(a);
            log.debug("Kept annotation {} with annotation type {} on {}",
                    new Object[] { a, a.annotationType(), mname });
        }
    }

    if (!hit) {
        BenchmarkOptions opts = getDefaultBenchmarkOptions(rounds);
        modifiedAnnotations.add(opts);
        log.debug("Added BenchmarkOptions {} with annotation type {} to {}",
                new Object[] { opts, opts.annotationType(), mname });
    }

    Description roundsAdjustedDesc =
            Description.createTestDescription(
                    clazz, mname,
                    modifiedAnnotations.toArray(new Annotation[modifiedAnnotations.size()]));
    return rule.apply(base, roundsAdjustedDesc);
}
 

@Test
@BenchmarkOptions(warmupRounds = 1, benchmarkRounds = 1)
public void testFastSplit() {
    S.List sl = S.fastSplit(toBeSplited, "**");
    UtilTestBase.eq(sl, C.listOf(toBeSplited.split("\\*\\*")));
}
 

@Test @BenchmarkOptions(warmupRounds = 1, benchmarkRounds = 5)
public void timeGenericConciseIntersection() throws Exception
{
  ImmutableBitmap intersection = conciseFactory.intersection(Lists.newArrayList(genericConcise));
  Assert.assertTrue(intersection.size() >= minIntersection);
}
 

@Test @BenchmarkOptions(warmupRounds = 1, benchmarkRounds = 2)
public void timeConciseUnion() throws Exception
{
  ImmutableConciseSet union = ImmutableConciseSet.union(concise);
  Assert.assertEquals(unionCount, union.size());
}
 

@Test @BenchmarkOptions(warmupRounds = 1, benchmarkRounds = 2)
public void timeOffheapConciseUnion() throws Exception
{
  ImmutableConciseSet union = ImmutableConciseSet.union(offheapConcise);
  Assert.assertEquals(unionCount, union.size());
}
 

@Test @BenchmarkOptions(warmupRounds = 1, benchmarkRounds = 2)
public void timeGenericConciseUnion() throws Exception
{
  ImmutableBitmap union = conciseFactory.union(Lists.newArrayList(genericConcise));
  Assert.assertEquals(unionCount, union.size());
}
 

private static BenchmarkOptions getDefaultBenchmarkOptions(int rounds) {
    return (BenchmarkOptions)Proxy.newProxyInstance(
            JUnitBenchmarkProvider.class.getClassLoader(), // which classloader is correct?
            new Class[] { BenchmarkOptions.class },
            new DefaultBenchmarkOptionsHandler(rounds));
}