@Test public void testSortWithFk() throws Exception { final ExecuteChangeCommand aTab1 = newIncrementalCommand(tableChangeType(), "ATab", "1", Sets.immutable.<String>of(), 1); final ExecuteChangeCommand aTab2 = newIncrementalCommand(tableChangeType(), "ATab", "2", Sets.immutable.<String>of(), 2); final ExecuteChangeCommand aTab3 = newIncrementalCommand(tableChangeType(), "ATab", "3", Sets.immutable.<String>of(), 3); final ExecuteChangeCommand bTab1 = newIncrementalCommand(tableChangeType(), "BTab", "1", Sets.immutable.<String>of(), 1); final ExecuteChangeCommand bTab2 = newIncrementalCommand(tableChangeType(), "BTab", "2", Sets.immutable.<String>of("ATab"), 2); final ExecuteChangeCommand bTab3 = newIncrementalCommand(tableChangeType(), "BTab", "3", Sets.immutable.<String>of(), 3); final ListIterable<ExecuteChangeCommand> sortedCommands = sorter.sort(Lists.mutable.of( aTab1 , aTab2 , aTab3 , bTab1 , bTab2 , bTab3 ), false); // assert basic order assertThat("aTab changes should be in order", sortedCommands.indexOf(aTab1), Matchers.lessThan(sortedCommands.indexOf(aTab2))); assertThat("aTab changes should be in order", sortedCommands.indexOf(aTab2), Matchers.lessThan(sortedCommands.indexOf(aTab3))); assertThat("bTab changes should be in order", sortedCommands.indexOf(bTab1), Matchers.lessThan(sortedCommands.indexOf(bTab2))); assertThat("bTab changes should be in order", sortedCommands.indexOf(bTab2), Matchers.lessThan(sortedCommands.indexOf(bTab3))); // assert cross-object dependency assertThat("assert bTab change depending on aTab comes after tabA", sortedCommands.indexOf(aTab1), Matchers.lessThan(sortedCommands.indexOf(bTab2))); }
@Test public void can_evaluate_pathed_datetime_against_current_datetime_minus_12_month() throws Exception { // /data[at0001]/items[at0003]/value/value>=($currentDateTime.value-12,mo) DataInstance[] dataInstances = new DataInstance[1]; dataInstances[0] = new DataInstance.Builder() .modelId("weight") .addValue("/data[at0001]/items[at0003]", DvDateTime.valueOf("2014-02-15T18:18:00")) .build(); interpreter = new Interpreter(DvDateTime.valueOf("2015-01-10T00:00:00")); BinaryExpression binaryExpression = new BinaryExpression( new Variable(CURRENT_DATETIME, null, null, "value"), new QuantityConstant(new DvQuantity("mo", 12.0, 0)), OperatorKind.SUBTRACTION); BinaryExpression predicate = new BinaryExpression(Variable.createByPath("/data[at0001]/items[at0003]/value/value"), binaryExpression, OperatorKind.GREATER_THAN_OR_EQUAL); List<DataInstance> result = interpreter.evaluateDataInstancesWithPredicate(Arrays.asList(dataInstances), predicate, null); assertThat(result.size(), Matchers.is(1)); assertThat(result.get(0).modelId(), is("weight")); }
/** * Make sure that equals and hash code are reflexive * and symmetric. */ @Test public void equalsAndHashCode() { final String val = "test scalar value"; final Scalar firstScalar = new Scalar(val); final Scalar secondScalar = new Scalar(val); MatcherAssert.assertThat(firstScalar, Matchers.equalTo(secondScalar)); MatcherAssert.assertThat(secondScalar, Matchers.equalTo(firstScalar)); MatcherAssert.assertThat(firstScalar, Matchers.equalTo(firstScalar)); MatcherAssert.assertThat(firstScalar, Matchers.not(Matchers.equalTo(null))); MatcherAssert.assertThat( firstScalar.hashCode() == secondScalar.hashCode(), is(true) ); }
@Test public void testStatusWithoutSummary() { Collection<AppStatusResource> data = new ArrayList<>(); data.add(appStatusResource1); data.add(appStatusResource2); PagedResources.PageMetadata metadata = new PagedResources.PageMetadata(data.size(), 1, data.size(), 1); PagedResources<AppStatusResource> result = new PagedResources<>(data, metadata); when(runtimeOperations.status()).thenReturn(result); Object[][] expected = new String[][] { {"1", "deployed", "2"}, {"10", "deployed"}, {"20", "deployed"}, {"2", "undeployed", "0"} }; TableModel model = runtimeCommands.list(false, null).getModel(); for (int row = 0; row < expected.length; row++) { for (int col = 0; col < expected[row].length; col++) { assertThat(String.valueOf(model.getValue(row + 1, col)), Matchers.is(expected[row][col])); } } }
@Test public final void testParsingFormattedStringWithOffsetToOffsetDateTime() { MatcherAssert.assertThat( "Can't parse a OffsetDateTime with custom format.", new OffsetDateTimeOf( "2017-12-13 14:15:16", "yyyy-MM-dd HH:mm:ss", ZoneOffset.ofHours(1) ).value(), Matchers.is( OffsetDateTime.of( LocalDateTime.of(2017, 12, 13, 14, 15, 16), ZoneOffset.ofHours(1) ) ) ); }
public void testEmptyAggregation() throws Exception { SearchResponse searchResponse = client().prepareSearch("empty_bucket_idx") .setQuery(matchAllQuery()) .addAggregation(histogram("histo").field("value").interval(1L).minDocCount(0) .subAggregation(dateHistogram("date_histo").field("value").interval(1))) .execute().actionGet(); assertThat(searchResponse.getHits().getTotalHits(), equalTo(2L)); Histogram histo = searchResponse.getAggregations().get("histo"); assertThat(histo, Matchers.notNullValue()); List<? extends Histogram.Bucket> buckets = histo.getBuckets(); assertThat(buckets.size(), equalTo(3)); Histogram.Bucket bucket = buckets.get(1); assertThat(bucket, Matchers.notNullValue()); assertThat(bucket.getKeyAsString(), equalTo("1.0")); Histogram dateHisto = bucket.getAggregations().get("date_histo"); assertThat(dateHisto, Matchers.notNullValue()); assertThat(dateHisto.getName(), equalTo("date_histo")); assertThat(dateHisto.getBuckets().isEmpty(), is(true)); }
@Test public void test() throws InstantiationException, IllegalAccessException { String url = getBaseUri() + "country/ch"; io.restassured.response.Response getResponse = RestAssured.get(url); Assert.assertEquals(200, getResponse.getStatusCode()); getResponse.then().assertThat().body("data.attributes.deText", Matchers.equalTo("Schweiz")); getResponse.then().assertThat().body("data.attributes.enText", Matchers.equalTo("Switzerland")); String patchData = "{'data':{'id':'ch','type':'country','attributes':{'deText':'Test','enText':'Switzerland','ctlActCd':true}}}".replaceAll("'", "\""); Response patchResponse = RestAssured.given().body(patchData.getBytes()).header("content-type", JsonApiMediaType.APPLICATION_JSON_API).when().patch(url); patchResponse.then().statusCode(HttpStatus.SC_OK); getResponse = RestAssured.get(url); Assert.assertEquals(200, getResponse.getStatusCode()); getResponse.then().assertThat().body("data.attributes.deText", Matchers.equalTo("Test")); getResponse.then().assertThat().body("data.attributes.enText", Matchers.equalTo("Switzerland")); }
/** * Confused can start an 'unknown' command. * @throws Exception If something goes wrong. */ @Test public void startsUnknownCommand() throws Exception { final Command com = Mockito.mock(Command.class); Mockito.when(com.type()).thenReturn("unknown"); Mockito.when(com.language()).thenReturn(new English()); final Knowledge confused = new Confused(); Steps steps = confused.start(com, Mockito.mock(Log.class)); MatcherAssert.assertThat(steps, Matchers.notNullValue()); MatcherAssert.assertThat( steps instanceof GithubSteps, Matchers.is(true) ); }
@Ignore @Test public void iteratedCorrectlyBetweenBlankSheet() throws IOException { MatcherAssert.assertThat( "Each rows are iterated correctly, between blank sheets", new IteratorIterable<>( new ExcelIterator( new XSSFWorkbook( new ResourceAsStream("excel/test-between-blank-sheet.xlsx").stream() ) ) ), Matchers.contains( Matchers.is("jed,24.0"), Matchers.is("aisyl,20.0"), Matchers.is("linux,23.0"), Matchers.is("juan,29.0") ) ); }
@Test public void mapResponse_withHeaders() { MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add("h", "v"); new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; jaxrsResponse.getHeaders(); result = headers; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertEquals(1, response.getHeaders().getHeaderMap().size()); Assert.assertThat(response.getHeaders().getHeader("h"), Matchers.contains("v")); }
@Test public void testAgentHeapAllocation() throws Exception { final Process process = createProcessBuilder(heapDumpFolder) // .withJvmArgument("-Xms8m") // .withJvmArgument("-Xmx8m") // .withSystemProperty(LOG_LEVEL, "ERROR") // .withSystemProperty(CHECK_INTERVAL, "1s") // .withSystemProperty(MAX_HEAP_DUMP_FREQUENCY, "1/3s") // .withSystemProperty(HEAP_MEMORY_USAGE_THRESHOLD, "1%") // .withSystemProperty("jma-test.mode", "direct_allocation") // .withSystemProperty("jma-test.allocation", "3MB") // .withSystemProperty("jma-test.log", "false") // .buildAndRunUntil(heapDumpCreatedIn(heapDumpFolder, 1, TimeUnit.MINUTES)); assertThat(process.getErr(), hasNoErrors()); assertThat(heapDumpFolder.listFiles(), is(not(Matchers.<File>emptyArray()))); }
@Test public void valid() throws InvalidDataException, IOException, UnsupportedTagException { final Path path = Paths.get("src/test/resources/album/test.mp3"); MatcherAssert.assertThat( new AdvancedTagVerifiedAlbumImage( new AdvancedTagFromMp3File( new Mp3File( path.toFile() ) ) ).construct().getAlbumImage(), Matchers.equalTo( Files.readAllBytes(this.image) ) ); }
/** * RtYamlMapping can return null if the specified key is missig. */ @Test public void returnsNullOnMissingKey() { Map<YamlNode, YamlNode> mappings = new HashMap<>(); mappings.put(new Scalar("key3"), Mockito.mock(YamlSequence.class)); mappings.put(new Scalar("key1"), Mockito.mock(YamlMapping.class)); RtYamlMapping map = new RtYamlMapping(mappings); MatcherAssert.assertThat( map.yamlSequence("key4"), Matchers.nullValue() ); MatcherAssert.assertThat( map.yamlMapping("key4"), Matchers.nullValue() ); MatcherAssert.assertThat( map.string("key4"), Matchers.nullValue() ); MatcherAssert.assertThat( map.yamlSequence("key1"), Matchers.nullValue() ); }
@Test public void testLogoutFailures() throws Exception { // PHONE_INVALID_FORMAT mockMvc.perform(post(URI_USER_LOGOUT) .param("phoneNum", TEST_PHONE_INVALID) .session(session)) .andExpect(status().isBadRequest()) .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE)) .andExpect(jsonPath("$.*").value(Matchers.hasSize(2))) .andExpect(jsonPath("$.info").isString()) .andExpect(jsonPath("$.code").value(100)); // SESSION_NOT_FOUND mockMvc.perform(post(URI_USER_LOGOUT) .param("phoneNum", TEST_PHONE_USER)) .andExpect(status().isForbidden()) .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE)) .andExpect(jsonPath("$.*").value(Matchers.hasSize(2))) .andExpect(jsonPath("$.info").isString()) .andExpect(jsonPath("$.code").value(403)); }
@Test public final void testParsingCustomFormattedStringToDate() { MatcherAssert.assertThat( "Can't parse a Date with custom format.", new DateOf( "2017-12-13 14:15:16.000000017", "yyyy-MM-dd HH:mm:ss.n" ).value(), Matchers.is( Date.from( LocalDateTime.of( 2017, 12, 13, 14, 15, 16, 17 ).toInstant(ZoneOffset.UTC) ) ) ); }
@Test public void testPropertiesRelationships() { // @formatter:off RestAssured .given() .when() .get(snitchURI) .then() .statusCode(200) .contentType(ContentType.JSON) .body("componentRelationships[0].component.name", Matchers.is("app-props-detector")) .body("componentRelationships[0].component.type", Matchers.is("properties/application")) .body("componentRelationships[0].dependencies", Matchers.hasSize(1)) .body("componentRelationships[0].dependencies[0].component.name", Matchers.is("dependency")) .body("componentRelationships[0].dependencies[0].component.type", Matchers.is("properties/dependency")) .body("componentRelationships[0].consumers", Matchers.hasSize(1)) .body("componentRelationships[0].consumers[0].component.name", Matchers.is("consumer")) .body("componentRelationships[0].consumers[0].component.type", Matchers.is("properties/consumer")); // @formatter:on }
@Test @Ignore public void testSendSms() throws Exception { // PHONE_INVALID_FORMAT mockMvc.perform(get(URI_SMS_GET, TEST_PHONE_INVALID)) .andExpect(status().isBadRequest()) .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE)) .andExpect(jsonPath("$.*").value(Matchers.hasSize(2))) .andExpect(jsonPath("$.code").value(100)); // Success mockMvc.perform(get(URI_SMS_GET, TEST_PHONE_USER)) .andExpect(status().isOk()) .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE)) .andExpect(jsonPath("$.*").value(Matchers.hasSize(1))) .andExpect(jsonPath("$.phoneNum").value(TEST_PHONE_USER)); }
public UrlConditions parse(String urlText) { try { UrlConditions conditions = new UrlConditions(); URL url = new URL(urlText); if (url.getRef() != null) { conditions.setReferenceConditions(equalTo(url.getRef())); } else { conditions.setReferenceConditions(isEmptyOrNullString()); } conditions.setSchemaConditions(Matchers.equalTo(url.getProtocol())); conditions.getHostConditions().add(equalTo(url.getHost())); conditions.getPortConditions().add(equalTo(url.getPort())); conditions.getPathConditions().add(equalTo(url.getPath())); List<NameValuePair> params = UrlParams.parse(url.getQuery(), Charset.forName("UTF-8")); for (NameValuePair param : params) { conditions.getParameterConditions().put(param.getName(), equalTo(param.getValue())); } return conditions; } catch (MalformedURLException e) { throw new IllegalArgumentException(e); } }
@Test public void should_throw_exception_when_multiple_definitions_found_by_name_and_class() { //given final String mockName = "mock"; final Class<?> mockClass = Service.class; final DoubleSearch search = new DoubleSearch(asList( doubleDefinition(mockClass, mockName), doubleDefinition(mockClass, mockName))); exception.expect(IllegalStateException.class); exception.expectMessage(Matchers.allOf( startsWith(MISSING_DOUBLE_EXCEPTION_PREFIX), containsString(MULTIPLE_DOUBLES_EXCEPTION_MESSAGE))); //when search.findOneDefinition(mockName, Service.class); }
private void assertBucketContents(Histogram.Bucket actual, Double expectedCount, Double expectedValue) { // This is a gap bucket SimpleValue countMovAvg = actual.getAggregations().get("movavg_counts"); if (expectedCount == null) { assertThat("[_count] movavg is not null", countMovAvg, nullValue()); } else if (Double.isNaN(expectedCount)) { assertThat("[_count] movavg should be NaN, but is ["+countMovAvg.value()+"] instead", countMovAvg.value(), equalTo(Double.NaN)); } else { assertThat("[_count] movavg is null", countMovAvg, notNullValue()); assertTrue("[_count] movavg does not match expected [" + countMovAvg.value() + " vs " + expectedCount + "]", nearlyEqual(countMovAvg.value(), expectedCount, 0.1)); } // This is a gap bucket SimpleValue valuesMovAvg = actual.getAggregations().get("movavg_values"); if (expectedValue == null) { assertThat("[value] movavg is not null", valuesMovAvg, Matchers.nullValue()); } else if (Double.isNaN(expectedValue)) { assertThat("[value] movavg should be NaN, but is ["+valuesMovAvg.value()+"] instead", valuesMovAvg.value(), equalTo(Double.NaN)); } else { assertThat("[value] movavg is null", valuesMovAvg, notNullValue()); assertTrue("[value] movavg does not match expected [" + valuesMovAvg.value() + " vs " + expectedValue + "]", nearlyEqual(valuesMovAvg.value(), expectedValue, 0.1)); } }
@SuppressWarnings("unchecked") @Test public void shouldDeleteEntitiesById() { DatastoreKeyTestEntity testEntity = new DatastoreKeyTestEntity(1, "name"); DatastoreKeyTestEntity testEntity2 = new DatastoreKeyTestEntity(2, "name2"); repository.putAsync(testEntity, testEntity2).complete(); assertThat(repository.get(testEntity.getKey()), is(testEntity)); assertThat(repository.get(testEntity2.getKey()), is(testEntity2)); assertThat(repository.search().field("key", list(testEntity.getKey(), testEntity2.getKey())).run().getResults().size(), is(2)); repository.deleteByKeyAsync(testEntity.getKey(), testEntity2.getKey()).complete(); assertThat(repository.get(testEntity.getKey(), testEntity2.getKey()), Matchers.hasItems(nullValue(), nullValue())); assertThat(repository.search().field("key", list(testEntity.getKey(), testEntity2.getKey())).run().getResults().isEmpty(), is(true)); }
@Test public void voidMethodNoArgsBodyThrowsCustomThrowable() throws Exception { expectedEx.expect(IllegalStateException.class); expectedEx.expectMessage(Matchers.startsWith("Error processing target method for LEP resource key")); MethodSignature signature = Mockito.mock(MethodSignature.class); when(signature.getParameterTypes()).thenReturn(new Class<?>[0]); when(signature.getMethod()).thenReturn(voidMethodNoArgsCustomThrowable); LepMethod method = Mockito.mock(LepMethod.class); when(method.getMethodSignature()).thenReturn(signature); when(method.getTarget()).thenReturn(this); TargetProceedingLep proceedingLep = new TargetProceedingLep(method, null); proceedingLep.proceed(); }
@Test public void failureCount() { MatcherAssert.assertThat( new JunitStatus(new FakeResult(false, 0, 2, 0)).failureCount(), Matchers.is(2) ); }
@Test public void testOfSettingMessageLevel() { // check if message level is set and if same TestFluentValidator is returned // info TestFluentValidator<Element> nextFluentValidator = unit.info(); MatcherAssert.assertThat(nextFluentValidator.getMessageLevel(), Matchers.is(Diagnostic.Kind.NOTE)); MatcherAssert.assertThat(nextFluentValidator, Matchers.equalTo(unit)); // warning nextFluentValidator = nextFluentValidator.warning(); MatcherAssert.assertThat(nextFluentValidator.getMessageLevel(), Matchers.is(Diagnostic.Kind.WARNING)); MatcherAssert.assertThat(nextFluentValidator, Matchers.equalTo(unit)); // mandatory warning nextFluentValidator = nextFluentValidator.mandatoryWarning(); MatcherAssert.assertThat(nextFluentValidator.getMessageLevel(), Matchers.is(Diagnostic.Kind.MANDATORY_WARNING)); MatcherAssert.assertThat(nextFluentValidator, Matchers.equalTo(unit)); // other nextFluentValidator = nextFluentValidator.other(); MatcherAssert.assertThat(nextFluentValidator.getMessageLevel(), Matchers.is(Diagnostic.Kind.OTHER)); MatcherAssert.assertThat(nextFluentValidator, Matchers.equalTo(unit)); // error nextFluentValidator = nextFluentValidator.error(); MatcherAssert.assertThat(nextFluentValidator.getMessageLevel(), Matchers.is(Diagnostic.Kind.ERROR)); MatcherAssert.assertThat(nextFluentValidator, Matchers.equalTo(unit)); }
@Test public void testNoOccurrence() throws ParseException { final String value = "stringLiteral"; final String ldPath = String.format("fn:keepAfterLast(<%s>, \"%s\") :: xsd:string", predicate.stringValue(), "/"); addStatement(repository.getValueFactory().createStatement(subject, predicate, repository.getValueFactory().createLiteral(value))); final ImmutableCollection<Object> values = evaluateRule(ldPath, subject); assertThat(values.size(), Matchers.equalTo(1)); assertThat(values, Matchers.contains(value)); }
@Test public void can_evaluate_fired_rule_expected_false() throws Exception { guideline = loadGuideline(BSA_CALCULATION_FIRED_RULE); ArrayList<DataInstance> dataInstances = new ArrayList<>(); dataInstances.add(toWeight("158.7,lbs")); dataInstances.add(toHeight("5.95,ft")); Map<String, Object> result = interpreter.execute(guideline, dataInstances); Object dataValue = result.get("gt0014"); assertThat(dataValue, Matchers.instanceOf(DvBoolean.class)); DvBoolean dvBoolean = (DvBoolean) dataValue; assertThat(dvBoolean.getValue(), is(false)); }
@Test public void withoutItemsIsEmpty() throws Exception { MatcherAssert.assertThat( new Filtered<String>( input -> input.length() > 16, new IterableOf<>("third", "fourth") ).isEmpty(), Matchers.equalTo(true) ); }
@Test(expected = IllegalStateException.class) public void testNoReuse() throws IOException { processor.attach(session); final Cmd.Result result = processor.submit(Cmd.builder("echo straw").build()).test().awaitDone(3, TimeUnit.SECONDS).assertNoTimeout().values().get(0); assertThat(result.getExitCode(), is(RxProcess.ExitCode.OK)); assertThat(result.getOutput(), Matchers.contains("straw")); session.cancel().test().awaitDone(1, TimeUnit.SECONDS).assertNoTimeout(); MockRxShellSession mockSession2 = new MockRxShellSession(); processor.attach(mockSession2.getSession()); }
public void testSpecifyOptionalSettings() throws Exception { DateIndexNameProcessor.Factory factory = new DateIndexNameProcessor.Factory(); Map<String, Object> config = new HashMap<>(); config.put("field", "_field"); config.put("index_name_prefix", "_prefix"); config.put("date_rounding", "y"); config.put("date_formats", Arrays.asList("UNIX", "UNIX_MS")); DateIndexNameProcessor processor = factory.create(null, null, config); assertThat(processor.getDateFormats().size(), Matchers.equalTo(2)); config = new HashMap<>(); config.put("field", "_field"); config.put("index_name_prefix", "_prefix"); config.put("date_rounding", "y"); config.put("index_name_format", "yyyyMMdd"); processor = factory.create(null, null, config); assertThat(processor.getIndexNameFormat(), Matchers.equalTo("yyyyMMdd")); config = new HashMap<>(); config.put("field", "_field"); config.put("index_name_prefix", "_prefix"); config.put("date_rounding", "y"); config.put("timezone", "+02:00"); processor = factory.create(null, null, config); assertThat(processor.getTimezone(), Matchers.equalTo(DateTimeZone.forOffsetHours(2))); config = new HashMap<>(); config.put("field", "_field"); config.put("index_name_prefix", "_prefix"); config.put("date_rounding", "y"); processor = factory.create(null, null, config); assertThat(processor.getIndexNamePrefix(), Matchers.equalTo("_prefix")); }
@Test public void idsMap() throws IOException, ClientException, ApiException { final Map<Integer, String> expected = new HashMap<>(); expected.put(0, "1"); expected.put(1, "2"); MatcherAssert.assertThat( this.queries.idsMap(), Matchers.equalTo(expected) ); }
@Override public boolean matchesSafely(final Map<K, V> map) { MatcherAssert.assertThat(map, Matchers.hasKey(this.key)); MatcherAssert.assertThat(map, Matchers.hasValue(this.value)); MatcherAssert.assertThat(map.keySet(), Matchers.hasItem(this.key)); MatcherAssert.assertThat(map.values(), Matchers.hasItem(this.value)); return true; }
/** * ReadPipeScalar can compare itself to other ReadPipeScalar. */ @Test public void comparesToReadPipeScalar() { final List<YamlLine> lines = new ArrayList<>(); lines.add(new RtYamlLine("Java", 1)); final ReadPipeScalar first = new ReadPipeScalar(new RtYamlLines(lines)); final ReadPipeScalar second = new ReadPipeScalar(new RtYamlLines(lines)); MatcherAssert.assertThat(first.compareTo(second), Matchers.is(0)); }
@Test public final void testZonedDateTimeFormattedAsIsoDateTime() { final ZonedDateTime date = ZonedDateTime.of( 2017, 12, 13, 14, 15, 16, 17, ZoneId.of("Europe/Berlin") ); MatcherAssert.assertThat( "Can't format a ZonedDateTime with default/ISO format.", new DateAsText(date).asString(), Matchers.is("2017-12-13T14:15:16.000000017+01:00") ); }
@Test public void whenNoThreadContextThenThrowException() { expectedEx.expect(IllegalStateException.class); expectedEx.expectMessage(Matchers.startsWith("LEP manager thread context doesn't initialized.")); when(contextsHolder.getContext(eq(ContextScopes.THREAD))).thenReturn(null); LepContextUtils.getTenantKey(contextsHolder); }
/** * The bot understands a mention using the first language. * @throws Exception If something goes wrong. */ @Test public void understandsWithFirstLanguage() throws Exception { final MkStorage storage = new MkStorage.Synced(new MkStorage.InFile()); final Repo repoMihai = new MkGithub(storage, "amihaiemil") .repos().create( new Repos.RepoCreate("amihaiemil.github.io", false) ); final Issue mihai = repoMihai.issues().create("test issue", "body"); mihai.comments().post("@comdor hello!"); final Issue comdor = new MkGithub(storage, "comdor").repos() .get(repoMihai.coordinates()) .issues() .get(mihai.number()); final Command last = new LastMention(comdor); MatcherAssert.assertThat( last.type(), Matchers.equalTo("unknown") ); final Language first = Mockito.mock(Language.class); Mockito.when(first.categorize(last)).thenReturn("hello"); final Language second = Mockito.mock(Language.class); Mockito.when(second.categorize(last)).thenReturn("hello"); last.understand(first, second, Mockito.mock(Language.class)); MatcherAssert.assertThat( last.type(), Matchers.equalTo("hello") ); MatcherAssert.assertThat( last.language(), Matchers.is(first) ); }
@Test public void can_evaluation_sum_in_condition_with_dv_ordinal() throws Exception { Guideline guideline = loadGuideline("Sum_in_condition_test.v1.gdl2"); ArrayList<DataInstance> dataInstances = new ArrayList<>(); dataInstances.add(withOrdinal(50)); dataInstances.add(withOrdinal(60)); Map<String, Object> result = interpreter.execute(guideline, dataInstances); Object dataValue = result.get("gt0007"); assertThat(dataValue, Matchers.instanceOf(DvText.class)); DvText dvText = (DvText) dataValue; assertThat(dvText.getValue(), is("Overdose")); }
@Test public void size() throws Exception { MatcherAssert.assertThat( new Joined<Integer>( new ListOf<>(1, 2), new ListOf<>(3, 4) ).size(), Matchers.equalTo(4) ); }
public void testSimple() throws Exception { SearchResponse response = client().prepareSearch("idx") .addAggregation(adjacencyMatrix("tags", newMap("tag1", termQuery("tag", "tag1")).add("tag2", termQuery("tag", "tag2")))) .execute().actionGet(); assertSearchResponse(response); AdjacencyMatrix matrix = response.getAggregations().get("tags"); assertThat(matrix, notNullValue()); assertThat(matrix.getName(), equalTo("tags")); int expected = numMultiTagDocs > 0 ? 3 : 2; assertThat(matrix.getBuckets().size(), equalTo(expected)); AdjacencyMatrix.Bucket bucket = matrix.getBucketByKey("tag1"); assertThat(bucket, Matchers.notNullValue()); assertThat(bucket.getDocCount(), equalTo((long) numTag1Docs)); bucket = matrix.getBucketByKey("tag2"); assertThat(bucket, Matchers.notNullValue()); assertThat(bucket.getDocCount(), equalTo((long) numTag2Docs)); bucket = matrix.getBucketByKey("tag1&tag2"); if (numMultiTagDocs == 0) { assertThat(bucket, Matchers.nullValue()); } else { assertThat(bucket, Matchers.notNullValue()); assertThat(bucket.getDocCount(), equalTo((long) numMultiTagDocs)); } }
/** * StringYamlSequence can fetch a YamlMapping based in its index. */ @Test public void returnsMapping() { YamlSequence origin = Mockito.mock(YamlSequence.class); YamlMapping found = Mockito.mock(YamlMapping.class); Mockito.when(origin.yamlMapping(1)).thenReturn(found); YamlSequence strict = new StrictYamlSequence(origin); MatcherAssert.assertThat( strict.yamlMapping(1), Matchers.equalTo(found) ); }