org.hamcrest.CoreMatchers Java Examples

@Test
public void testDeleteBatchFailsWithWrongTenant() {
  // given
  Batch batch = batchHelper.migrateProcessInstanceAsync(tenant2Definition, tenant2Definition);

  // when
  identityService.setAuthentication("user", null, singletonList(TENANT_ONE));
  try {
    managementService.deleteBatch(batch.getId(), true);
    Assert.fail("exception expected");
  }
  catch (ProcessEngineException e) {
    // then
    Assert.assertThat(e.getMessage(), CoreMatchers.containsString("Cannot delete batch '"
      + batch.getId() + "' because it belongs to no authenticated tenant"));
  }
  finally {
    identityService.clearAuthentication();
  }
}
 

/**
 * Test method for {@link BootstrapConnectionFactory#bootstrap()} .
 */
@Test
public void testBootstrapStandaloneWithAuth() {
    startAuthenticated();

    final MongoClientConfiguration config = new MongoClientConfiguration(
            new InetSocketAddress("127.0.0.1", 27017));
    config.addCredential(Credential.builder().userName(USER_NAME)
            .password(PASSWORD).database(USER_DB)
            .authenticationType(Credential.MONGODB_CR).build());

    myTestFactory = new BootstrapConnectionFactory(config);

    assertThat("Wrong type of myTestFactory.", myTestFactory.getDelegate(),
            CoreMatchers.instanceOf(AuthenticationConnectionFactory.class));
}
 

@Test
public void cannotMigrateInstanceWithoutTenantIdToDifferentTenant() {
  // given
  ProcessDefinition sourceDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
  ProcessDefinition targetDefinition = testHelper.deployForTenantAndGetDefinition(TENANT_ONE, ProcessModels.ONE_TASK_PROCESS);

  ProcessInstance processInstance = engineRule.getRuntimeService().startProcessInstanceById(sourceDefinition.getId());
  MigrationPlan migrationPlan = engineRule.getRuntimeService().createMigrationPlan(sourceDefinition.getId(), targetDefinition.getId())
      .mapEqualActivities()
      .build();

  // when
  try {
    engineRule.getRuntimeService()
      .newMigration(migrationPlan)
      .processInstanceIds(Arrays.asList(processInstance.getId()))
      .execute();
    Assert.fail("exception expected");
  } catch (ProcessEngineException e) {
    Assert.assertThat(e.getMessage(),
        CoreMatchers.containsString("Cannot migrate process instance '" + processInstance.getId()
            + "' without tenant to a process definition with a tenant ('tenant1')"));
  }
}
 

@Test
public void counterRollupBuilderWithSingleInputYieldsZeroRate() throws IOException {

    // given
    Points<SimpleNumber> inputA = new Points<SimpleNumber>();
    inputA.add(new Points.Point<SimpleNumber>(1234L, new SimpleNumber(1L)));
    BluefloodCounterRollup rollupA = BluefloodCounterRollup.buildRollupFromRawSamples(inputA);

    Points<BluefloodCounterRollup> combined = new Points<BluefloodCounterRollup>();
    combined.add(new Points.Point<BluefloodCounterRollup>(1234L, rollupA));

    // when
    BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromCounterRollups(combined);

    // then
    Number count = rollup.getCount();
    assertNotNull(count);
    assertThat(count, is(CoreMatchers.<Number>instanceOf(Long.class)));
    assertEquals(1L, count.longValue());
    assertEquals(0.0d, rollup.getRate(), 0.00001d); // (1)/0=0
    assertEquals(1, rollup.getSampleCount());
}
 

@Test
public void testTransitionDuringFailures() {
  StatusTransitioner transitioner = new StatusTransitioner(LoggerFactory.getLogger(StatusTransitionerTest.class));
  assertThat(transitioner.currentStatus(), CoreMatchers.is(Status.UNINITIALIZED));
  StatusTransitioner.Transition st = transitioner.init();
  st.failed(new Throwable());
  assertThat(transitioner.currentStatus(), is(Status.UNINITIALIZED));
  try {
    st.failed(new Throwable());
    fail();
  } catch (AssertionError err) {
    assertThat(err.getMessage(), is("Throwable cannot be thrown if Transition is done."));
  }

  st.failed(null);
  assertThat(transitioner.currentStatus(), is(Status.UNINITIALIZED));

  StatusTransitioner.Transition st1 = transitioner.init();
  assertThat(transitioner.currentStatus(), is(Status.AVAILABLE));
  st1.failed(null);
  assertThat(transitioner.currentStatus(), is(Status.UNINITIALIZED));

}
 

public void testKafkaStreamsAliveAndReady() throws Exception {
    RestAssured.get("/health/ready").then()
            .statusCode(HttpStatus.SC_OK)
            .body("checks[0].name", CoreMatchers.is("Kafka Streams topics health check"))
            .body("checks[0].status", CoreMatchers.is("UP"))
            .body("checks[0].data.available_topics", CoreMatchers.is("streams-test-categories,streams-test-customers"));

    RestAssured.when().get("/health/live").then()
            .statusCode(HttpStatus.SC_OK)
            .body("checks[0].name", CoreMatchers.is("Kafka Streams state health check"))
            .body("checks[0].status", CoreMatchers.is("UP"))
            .body("checks[0].data.state", CoreMatchers.is("RUNNING"));

    RestAssured.when().get("/health").then()
            .statusCode(HttpStatus.SC_OK);
}
 

@Test
public void testPrintHelpForFullySetOption() {
	RequiredParameters required = new RequiredParameters();
	try {
		required.add(new Option("option").defaultValue("some").help("help").alt("o").choices("some", "options"));

		String helpText = required.getHelp();
		Assert.assertThat(helpText, CoreMatchers.allOf(
				containsString("Required Parameters:"),
				containsString("-o, --option"),
				containsString("default: some"),
				containsString("choices: "),
				containsString("some"),
				containsString("options")));

	} catch (RequiredParametersException e) {
		fail("Exception thrown " + e.getMessage());
	}
}
 

@Test
public void readList() throws IOException {
    Properties properties = new Properties();
    properties.setProperty("profiler.test.list1", "foo,bar");
    properties.setProperty("profiler.test.list2", "foo, bar");
    properties.setProperty("profiler.test.list3", " foo,bar");
    properties.setProperty("profiler.test.list4", "foo,bar ");
    properties.setProperty("profiler.test.list5", "    foo,    bar   ");

    ProfilerConfig profilerConfig = new DefaultProfilerConfig(properties);

    Assert.assertThat(profilerConfig.readList("profiler.test.list1"), CoreMatchers.hasItems("foo", "bar"));
    Assert.assertThat(profilerConfig.readList("profiler.test.list2"), CoreMatchers.hasItems("foo", "bar"));
    Assert.assertThat(profilerConfig.readList("profiler.test.list3"), CoreMatchers.hasItems("foo", "bar"));
    Assert.assertThat(profilerConfig.readList("profiler.test.list4"), CoreMatchers.hasItems("foo", "bar"));
}
 

@Test
public void testTableApiPathResolution() {
	List<String> lookupPath = testSpec.getTableApiLookupPath();
	CatalogManager catalogManager = testSpec.getCatalogManager();
	testSpec.getDefaultCatalog().ifPresent(catalogManager::setCurrentCatalog);
	testSpec.getDefaultDatabase().ifPresent(catalogManager::setCurrentDatabase);

	UnresolvedIdentifier unresolvedIdentifier = UnresolvedIdentifier.of(lookupPath);
	ObjectIdentifier identifier = catalogManager.qualifyIdentifier(unresolvedIdentifier);

	assertThat(
		Arrays.asList(identifier.getCatalogName(), identifier.getDatabaseName(), identifier.getObjectName()),
		CoreMatchers.equalTo(testSpec.getExpectedPath()));
	Optional<CatalogManager.TableLookupResult> tableLookup = catalogManager.getTable(identifier);
	assertThat(tableLookup.isPresent(), is(true));
	assertThat(tableLookup.get().isTemporary(), is(testSpec.isTemporaryObject()));
}
 

@Test
public void testObjectLiteral() {
    Expression emptyObjectLiteral = SqlParser.createExpression("{}");
    assertThat(emptyObjectLiteral, instanceOf(ObjectLiteral.class));
    assertThat(((ObjectLiteral) emptyObjectLiteral).values().size(), is(0));

    ObjectLiteral objectLiteral = (ObjectLiteral) SqlParser.createExpression("{a=1, aa=-1, b='str', c=[], d={}}");
    assertThat(objectLiteral.values().size(), is(5));
    assertThat(objectLiteral.values().get("a"), instanceOf(IntegerLiteral.class));
    assertThat(objectLiteral.values().get("aa"), instanceOf(NegativeExpression.class));
    assertThat(objectLiteral.values().get("b"), instanceOf(StringLiteral.class));
    assertThat(objectLiteral.values().get("c"), instanceOf(ArrayLiteral.class));
    assertThat(objectLiteral.values().get("d"), instanceOf(ObjectLiteral.class));

    ObjectLiteral quotedObjectLiteral = (ObjectLiteral) SqlParser.createExpression("{\"AbC\"=123}");
    assertThat(quotedObjectLiteral.values().size(), is(1));
    assertThat(quotedObjectLiteral.values().get("AbC"), instanceOf(IntegerLiteral.class));
    assertThat(quotedObjectLiteral.values().get("abc"), CoreMatchers.nullValue());
    assertThat(quotedObjectLiteral.values().get("ABC"), CoreMatchers.nullValue());

    SqlParser.createExpression("{a=func('abc')}");
    SqlParser.createExpression("{b=identifier}");
    SqlParser.createExpression("{c=1+4}");
    SqlParser.createExpression("{d=sub['script']}");
}
 

@Test
public void testMoreThenIp3() {
    try {
        String pattern = "otherwise => ~ip\"192.168.10.126\" , , ~ip\"192.168.10.130\"";
        List<Route> routes = RoutesExecutor.parseAll(pattern);
        InvocationContextImpl ctx = (InvocationContextImpl) InvocationContextImpl.Factory.currentInstance();
        ctx.setCookie("storeId", "118666200");
        ctx.methodName("updateOrderMemberId");

        List<RuntimeInstance> prepare = prepare(ctx, routes);


        List<RuntimeInstance> expectInstances = new ArrayList<>();
        expectInstances.add(runtimeInstance1);
        Assert.assertArrayEquals(expectInstances.toArray(), prepare.toArray());

    } catch (ParsingException ex) {
        Assert.assertThat(ex.getMessage(), CoreMatchers.containsString(
                ("[Validate Token Error]:target token: [(2,'=>')] is not in expects token: [(15,'逗号'), (-1,'文件结束符'), (1,'回车换行符')]")));
    }

}
 

@Test
public void togglePushInInit() throws Exception {
    // Open with push disabled
    open("push=disabled");

    assertFalse(getPushToggle().isSelected());

    getDelayedCounterUpdateButton().click();
    Thread.sleep(2000);
    Assert.assertEquals("Counter has been updated 0 times",
            getCounterText());

    // Open with push enabled
    open("push=enabled");
    Assert.assertThat(getPushToggle().getText(),
            CoreMatchers.containsString("Push enabled"));

    getDelayedCounterUpdateButton().click();
    Thread.sleep(2000);
    Assert.assertEquals("Counter has been updated 1 times",
            getCounterText());

}
 

@Test
public void check_metadatas_on_tag_3_2_1() {
    unchecked(() -> git.checkout().setName(TAG_3_2_1).call());

    GitVersionCalculator gvc = GitVersionCalculator.location(s.getRepositoryLocation());
    gvc.setMavenLike(true);
    Version versionObject = gvc.getVersionObject();

    assertThat(versionObject.getMajor(), CoreMatchers.is(3));
    assertThat(gvc.meta(Metadatas.CURRENT_VERSION_MAJOR).get(), CoreMatchers.is("3"));

    assertThat(versionObject.getMinor(), CoreMatchers.is(2));
    assertThat(gvc.meta(Metadatas.CURRENT_VERSION_MINOR).get(), CoreMatchers.is("2"));

    assertThat(versionObject.getPatch(), CoreMatchers.is(1));
    assertThat(gvc.meta(Metadatas.CURRENT_VERSION_PATCH).get(), CoreMatchers.is("1"));
}
 

@Test
public void open_openInSameWindow_closeTheClientApplication() {
    AtomicReference<String> capture = new AtomicReference<>();
    List<Serializable> params = new ArrayList<>();
    Page page = new Page(new MockUI()) {
        @Override
        public PendingJavaScriptResult executeJs(String expression,
                Serializable[] parameters) {
            capture.set(expression);
            params.addAll(Arrays.asList(parameters));
            return Mockito.mock(PendingJavaScriptResult.class);
        }
    };

    page.setLocation("foo");

    // self check
    Assert.assertEquals("_self", params.get(1));

    Assert.assertThat(capture.get(), CoreMatchers
            .startsWith("if ($1 == '_self') this.stopApplication();"));
}
 

@Test
public void counterRollupBuilderWithSingleThreeInputYieldsRate() throws IOException {

    // given
    Points<SimpleNumber> inputA = new Points<SimpleNumber>();
    inputA.add(new Points.Point<SimpleNumber>(1234L, new SimpleNumber(1L)));
    inputA.add(new Points.Point<SimpleNumber>(1235L, new SimpleNumber(2L)));
    inputA.add(new Points.Point<SimpleNumber>(1236L, new SimpleNumber(3L)));
    BluefloodCounterRollup rollupA = BluefloodCounterRollup.buildRollupFromRawSamples(inputA);

    Points<BluefloodCounterRollup> combined = new Points<BluefloodCounterRollup>();
    combined.add(new Points.Point<BluefloodCounterRollup>(1234L, rollupA));

    // when
    BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromCounterRollups(combined);

    // then
    Number count = rollup.getCount();
    assertNotNull(count);
    assertThat(count, is(CoreMatchers.<Number>instanceOf(Long.class)));
    assertEquals(6L, count.longValue()); // 1+2+3
    assertEquals(3.0d, rollup.getRate(), 0.00001d); // (1+2+3)/( (1236-1234) + 0 ) = 3
    assertEquals(3, rollup.getSampleCount());
}
 

@Test
public void testGetUserList() throws IOException {
  GetMethod get = httpGet("/security/userlist/admi", "admin", "password1");
  get.addRequestHeader("Origin", "http://localhost");
  Map<String, Object> resp = gson.fromJson(get.getResponseBodyAsString(),
      new TypeToken<Map<String, Object>>(){}.getType());
  List<String> userList = (List) ((Map) resp.get("body")).get("users");
  collector.checkThat("Search result size", userList.size(),
      CoreMatchers.equalTo(1));
  collector.checkThat("Search result contains admin", userList.contains("admin"),
      CoreMatchers.equalTo(true));
  get.releaseConnection();

  GetMethod notUser = httpGet("/security/userlist/randomString", "admin", "password1");
  notUser.addRequestHeader("Origin", "http://localhost");
  Map<String, Object> notUserResp = gson.fromJson(notUser.getResponseBodyAsString(),
      new TypeToken<Map<String, Object>>(){}.getType());
  List<String> emptyUserList = (List) ((Map) notUserResp.get("body")).get("users");
  collector.checkThat("Search result size", emptyUserList.size(),
      CoreMatchers.equalTo(0));

  notUser.releaseConnection();
}
 

@Test
public void assertFillParametersWithoutSetUpdatePrimaryKey() throws SQLException {
    setUpdateAssignments("t_order", "user_id", "status");
    setSnapshot(10, "user_id", "status", "order_id");
    sqlRevertExecutor = new UpdateSQLRevertExecutor(executorContext, snapshotAccessor);
    sqlRevertExecutor.fillParameters(revertSQLResult);
    assertThat(revertSQLResult.getParameters().size(), is(10));
    int offset = 1;
    for (Collection<Object> each : revertSQLResult.getParameters()) {
        assertThat(each.size(), is(3));
        List<Object> parameterRow = Lists.newArrayList(each);
        assertThat(parameterRow.get(0), CoreMatchers.<Object>is("user_id_" + offset));
        assertThat(parameterRow.get(1), CoreMatchers.<Object>is("status_" + offset));
        assertThat(parameterRow.get(2), CoreMatchers.<Object>is("order_id_" + offset));
        offset++;
    }
}
 

@Test
public void testActive() throws Exception {
    TypeResolutionStrategy.Resolved resolved = new TypeResolutionStrategy.Active().resolve();
    Field field = TypeResolutionStrategy.Active.Resolved.class.getDeclaredField("identification");
    field.setAccessible(true);
    int identification = (Integer) field.get(resolved);
    when(typeInitializer.expandWith(matchesPrototype(new NexusAccessor.InitializationAppender(identification)))).thenReturn(otherTypeInitializer);
    assertThat(resolved.injectedInto(typeInitializer), is(otherTypeInitializer));
    assertThat(resolved.initialize(dynamicType, classLoader, classLoadingStrategy),
            is(Collections.<TypeDescription, Class<?>>singletonMap(typeDescription, Foo.class)));
    try {
        verify(classLoadingStrategy).load(classLoader, Collections.singletonMap(typeDescription, FOO));
        verifyNoMoreInteractions(classLoadingStrategy);
        verify(loadedTypeInitializer).isAlive();
        verifyNoMoreInteractions(loadedTypeInitializer);
    } finally {
        Field initializers = Nexus.class.getDeclaredField("TYPE_INITIALIZERS");
        initializers.setAccessible(true);
        Constructor<Nexus> constructor = Nexus.class.getDeclaredConstructor(String.class, ClassLoader.class, ReferenceQueue.class, int.class);
        constructor.setAccessible(true);
        Object value = ((Map<?, ?>) initializers.get(null)).remove(constructor.newInstance(Foo.class.getName(), Foo.class.getClassLoader(), null, identification));
        assertThat(value, CoreMatchers.is((Object) loadedTypeInitializer));
    }
}
 

@Test
public void whenExecuteJobThenOk() throws Exception {
    jobWrapper.runJobLocked(dummyJob);
    assertThat(jobExecuted.get(), CoreMatchers.is(true));

    assertThat("lock node should be removed", CURATOR.checkExists().forPath(lockPath),
            CoreMatchers.is(CoreMatchers.nullValue()));

    final byte[] data = CURATOR.getData().forPath(latestPath);
    final DateTime lastCleaned = objectMapper.readValue(new String(data, Charsets.UTF_8), DateTime.class);
    final long msSinceCleaned = new DateTime().getMillis() - lastCleaned.getMillis();
    assertThat("job was executed less than 5 seconds ago", msSinceCleaned, lessThan(5000L));

}
 

@Test
public void testExecuteTimeout() throws Exception {
  try {
    // Use timeout in case we get stuck
    List<String> args = getWriterLoopCommand();
    new ProcessExecutor().command(args).timeout(1, TimeUnit.SECONDS).execute();
    Assert.fail("TimeoutException expected.");
  }
  catch (TimeoutException e) {
    Assert.assertThat(e.getMessage(), CoreMatchers.containsString("1 second"));
    Assert.assertThat(e.getMessage(), CoreMatchers.containsString(Loop.class.getName()));
  }
}
 

@Step
@Then("каждый элемент \"$elementName\" содержит любое из значений \"$template1\" или \"$template2\" без учета регистра")
public void eachElementContainsOneOfTwoValues(@Named("$elementName") String elementName, @Named("$template1") String templateOne, @Named("$template2") String templateTwo) {
    IElement element = getCurrentPage().getElementByName(elementName);
    List<WebElement> elementsFound = finder.findWebElements(element);
    String expectedValueOne = propertyUtils.injectProperties(templateOne);
    String expectedValueTwo = propertyUtils.injectProperties(templateTwo);
    elementsFound.forEach(elem -> {
        assertThat("Элемент не содержит ни одно из заданных значений", elem.getText().toLowerCase(), CoreMatchers.anyOf(
                containsString(expectedValueOne.toLowerCase()),
                containsString(expectedValueTwo.toLowerCase())
        ));

    });
}
 

public void ignoretestIt() throws IOException, InterruptedException {
	// Assert.assertNotNull(this.ctx);
	Assert.assertThat(this.ctx.isRunning(), CoreMatchers.is(true));

	final IMonitoringController monitoringController = MonitoringController.getInstance();
	Assume.assumeThat(monitoringController.getName(), CoreMatchers.is(CTRLNAME));

	final String getBookPattern = "public kieker.test.monitoring.junit.probe.spring.executions.jetty.bookstore.Book "
			+ "kieker.test.monitoring.junit.probe.spring.executions.jetty.bookstore.Catalog.getBook(boolean)";
	final String searchBookPattern = "public kieker.test.monitoring.junit.probe.spring.executions.jetty.bookstore.Book "
			+ "kieker.test.monitoring.junit.probe.spring.executions.jetty.bookstore.Bookstore.searchBook(java.lang.String)";

	NamedListWriter.awaitListSize(this.recordListFilledByListWriter, 0, TIMEOUT_IN_MS);

	UrlUtil.ping(BOOKSTORE_SEARCH_ANY_URL);
	NamedListWriter.awaitListSize(this.recordListFilledByListWriter, 3, TIMEOUT_IN_MS);

	monitoringController.deactivateProbe(getBookPattern);
	UrlUtil.ping(BOOKSTORE_SEARCH_ANY_URL);
	NamedListWriter.awaitListSize(this.recordListFilledByListWriter, 4, TIMEOUT_IN_MS);

	monitoringController.deactivateProbe(searchBookPattern);
	UrlUtil.ping(BOOKSTORE_SEARCH_ANY_URL);
	NamedListWriter.awaitListSize(this.recordListFilledByListWriter, 4, TIMEOUT_IN_MS);

	monitoringController.activateProbe(getBookPattern);
	UrlUtil.ping(BOOKSTORE_SEARCH_ANY_URL);
	NamedListWriter.awaitListSize(this.recordListFilledByListWriter, 6, TIMEOUT_IN_MS);

	monitoringController.activateProbe(searchBookPattern);
	UrlUtil.ping(BOOKSTORE_SEARCH_ANY_URL);
	NamedListWriter.awaitListSize(this.recordListFilledByListWriter, 9, TIMEOUT_IN_MS);
}
 

@Test
public void parseSubmitUnsupportedChildElement1() throws Exception {
    StringBuilder string0 = new StringBuilder(200)
        .append("<?xml version=\"1.0\"?>\n")
        .append("<operation type=\"submit\">\n")
        .append(" <account username=\"customer1\" password=\"test1\"/>\n")
        .append(" <submitRequest referenceId=\"MYREF102020022\">\n")
        .append("  <destinationAddress type=\"international\">+12065551212</destinationAddress>\n")
        .append("  <text encoding=\"ISO-8859-1\">48")
        .append("<badelement />\n")
        .append("</text>\n")
        .append(" </submitRequest>\n")
        .append("</operation>\n")
        .append("");

    ByteArrayInputStream is = new ByteArrayInputStream(string0.toString().getBytes());
    SxmpParser parser = new SxmpParser();

    try {
        Operation operation = parser.parse(is);
        Assert.fail();
    } catch (SxmpParsingException e) {
         // correct behavior
        Assert.assertEquals(SxmpErrorCode.UNSUPPORTED_ELEMENT, e.getErrorCode());
        Assert.assertThat(e.getMessage(), CoreMatchers.containsString("Unsupported [badelement] element found at depth"));
        Assert.assertNotNull(e.getOperation());
        SubmitRequest submitRequest = (SubmitRequest)e.getOperation();
        Assert.assertEquals(Operation.Type.SUBMIT, submitRequest.getType());
    }
}
 

@Test
public void shouldFailWhenActivatingUsingUnknownId() {
  try {
    managementService.activateBatchById("unknown");
    fail("Exception expected");
  }
  catch (BadUserRequestException e) {
    assertThat(e.getMessage(), CoreMatchers.containsString("Batch for id 'unknown' cannot be found"));
  }
}
 

@Test
public void getAllRunners() throws Exception {

    when(clientService.getAllRunners()).thenReturn(runners);

    String expected = "{\"runners\":" + objectMapper.writeValueAsString(runners) + "}";
    String result = ldRestService.dispatchCommand(credentials, "getAllRunners", null);
    assertThat(result, CoreMatchers.is(expected));
}
 

@Test
public void testCustomLocaleResolverWins() throws Exception {

    // the default resolver would resolve "it"
    webClient.addRequestHeader("Accept-Language", "it");

    // custom resolver uses "lang" query parameter
    HtmlPage page = webClient.getPage(webUrl + "resources/locale?lang=pl");

    // the customer resolver wins
    assertThat(page.getWebResponse().getContentAsString(),
            CoreMatchers.containsString("<p>Locale: pl</p>"));

}
 

@Test
public void testFlowFileNonDefaultException() {
    runner.setProperty(DebugFlow.FF_EXCEPTION_ITERATIONS, "1");
    runner.setProperty(DebugFlow.FF_EXCEPTION_CLASS, "java.lang.RuntimeException");
    runner.assertValid();

    runner.enqueue(contents.get(0).getBytes(), attribs.get(0));

    exception.expectMessage(CoreMatchers.containsString("forced by org.apache.nifi.processors.standard.DebugFlow"));
    exception.expectCause(CoreMatchers.isA(RuntimeException.class));
    runner.run(2);
}
 

@Test
public void testFlowFileExceptionRollover() {
    runner.setProperty(DebugFlow.FF_EXCEPTION_ITERATIONS, "2");
    runner.assertValid();

    for (int n = 0; n < 6; n++) {
        runner.enqueue(contents.get(n).getBytes(), attribs.get(n));
    }

    exception.expectMessage(CoreMatchers.containsString("forced by org.apache.nifi.processors.standard.DebugFlow"));
    exception.expectCause(CoreMatchers.isA(RuntimeException.class));
    runner.run(8);
}
 

/**
 * Test valid log directory.
 */
@Test
public void testValidLogFolder() throws IOException {
	final String passedConfigPathName = this.tmpFolder.getRoot().getAbsolutePath();
	this.configuration.setProperty(FileWriter.CONFIG_PATH, passedConfigPathName);

	new FileWriter(this.configuration);

	final Path kiekerPath = Files.list(Paths.get(passedConfigPathName)).findFirst().get();

	Assert.assertThat(kiekerPath.toAbsolutePath().toString(), CoreMatchers.startsWith(passedConfigPathName));
}
 

@Test
public void testFourArithmeticOperation() throws Exception {
    EnvironmentContext context = EnvironmentFactory.getContext();
    Future<?> task = context.doTask(() -> {
        RandomUtility.setSeed(0L);
        int dimension = 10;
        MathMatrix dataMatrix = getZeroMatrix(dimension);
        dataMatrix.iterateElement(MathCalculator.SERIAL, (scalar) -> {
            scalar.setValue(RandomUtility.randomFloat(10F));
        });
        MathMatrix copyMatrix = getZeroMatrix(dimension);
        float sum = dataMatrix.getSum(false);

        copyMatrix.copyMatrix(dataMatrix, false);
        Assert.assertThat(copyMatrix.getSum(false), CoreMatchers.equalTo(sum));

        dataMatrix.subtractMatrix(copyMatrix, false);
        Assert.assertThat(dataMatrix.getSum(false), CoreMatchers.equalTo(0F));

        dataMatrix.addMatrix(copyMatrix, false);
        Assert.assertThat(dataMatrix.getSum(false), CoreMatchers.equalTo(sum));

        dataMatrix.divideMatrix(copyMatrix, false);
        Assert.assertThat(dataMatrix.getSum(false), CoreMatchers.equalTo(dataMatrix.getElementSize() + 0F));

        dataMatrix.multiplyMatrix(copyMatrix, false);
        Assert.assertThat(dataMatrix.getSum(false), CoreMatchers.equalTo(sum));
    });
    task.get();
}