Java Code Examples for org.testng.annotations.Test

@Test
public void testTransformer() throws TransformerException {
    String xml = "<?xml version='1.0'?><root/>";
    ReaderStub.used = false;

    TransformerFactory transFactory = TransformerFactory.newInstance();
    Transformer transformer = transFactory.newTransformer();
    InputSource in = new InputSource(new StringReader(xml));
    SAXSource source = new SAXSource(in);
    StreamResult result = new StreamResult(new StringWriter());

    transformer.transform(source, result);

    assertTrue(ReaderStub.used);

}
 

/**
 * Use a DocumentBuilder to create a DOM object and see how does the Secure
 * Processing feature and entityExpansionLimit value affects output.
 * Negative test that when entityExpansionLimit is too small.
 *
 * @throws Exception If any errors occur.
 */
@Test(expectedExceptions = SAXParseException.class)
public void testEntityExpansionDOMNeg() throws Exception {
    DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
    dfactory.setFeature(FEATURE_SECURE_PROCESSING, true);
    setSystemProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(2));
    DocumentBuilder dBuilder = dfactory.newDocumentBuilder();
    MyErrorHandler eh = new MyErrorHandler();
    dBuilder.setErrorHandler(eh);
    dBuilder.parse(ENTITY_XML);
}
 

@Test
public void shouldSynchronizeConcurrentAddsOfSameElement() {
    // given:
    final String element = "Hello World";
    replica2.disconnect(replica3);

    // when:
    orSet1.add(element);
    orSet3.add(element);

    // then:
    assertThat(orSet1, contains(element));
    assertThat(orSet2, equalTo(orSet1));
    assertThat(orSet3, equalTo(orSet1));

    // when:
    replica2.connect(replica3);

    // then:
    assertThat(orSet1, contains(element));
    assertThat(orSet2, equalTo(orSet1));
    assertThat(orSet3, equalTo(orSet1));
}
 

@Test(dataProvider="calendars")
public void test_badMinusTemporalUnitChrono(Chronology chrono) {
    LocalDate refDate = LocalDate.of(2013, 1, 1);
    ChronoLocalDateTime<?> cdt = chrono.date(refDate).atTime(LocalTime.NOON);
    for (Chronology[] clist : data_of_calendars()) {
        Chronology chrono2 = clist[0];
        ChronoLocalDateTime<?> cdt2 = chrono2.date(refDate).atTime(LocalTime.NOON);
        TemporalUnit adjuster = new FixedTemporalUnit(cdt2);
        if (chrono != chrono2) {
            try {
                cdt.minus(1, adjuster);
                Assert.fail("TemporalUnit.doPlus minus should have thrown a ClassCastException" + cdt.getClass()
                        + ", can not be cast to " + cdt2.getClass());
            } catch (ClassCastException cce) {
                // Expected exception; not an error
            }
        } else {
            // Same chronology,
            ChronoLocalDateTime<?> result = cdt.minus(1, adjuster);
            assertEquals(result, cdt2, "WithAdjuster failed to replace date");
        }
    }
}
 

/**
 * namespace processing is enabled. namespace-prefix is also is enabled.
 * So it is a True-True combination.
 * The test is to test SAXParser with these conditions.
 *
 * @throws Exception If any errors occur.
 */
@Test
public void testWithTrueTrue() throws Exception {
    String outputFile = USER_DIR + "SPNSTableTT.out";
    String goldFile = GOLDEN_DIR + "NSTableTTGF.out";
    String xmlFile = XML_DIR + "namespace1.xml";
    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setNamespaceAware(true);
    spf.setFeature("http://xml.org/sax/features/namespace-prefixes",
                                true);
    try (MyNSContentHandler handler = new MyNSContentHandler(outputFile)) {
        spf.newSAXParser().parse(new File(xmlFile), handler);
    }
    assertTrue(compareWithGold(goldFile, outputFile));

}
 

/**
   * Simple test for record-writer where number of rows are written to Geode, based on
   * the specified block-size.
   * The sample file contains 30 lines/rows. Here with block-size 10 total four blocks
   * are stored each with max 10 records/rows.
   *
   * @throws Exception
   */
  @Test
  public void testWrite_SingleWriter() throws Exception {
//    System.out.println("MonarchRecordWriterTest.testWrite_SingleWriter");
    final List<String> lines = TestHelper.getResourceAsString(resourceFile);
    final Map<String, Integer> expectedMap = new HashMap<String, Integer>(4) {{
      put("0", 10);
      put("1", 10);
      put("2", 10);
      put("3", 1);
    }};
    final int blockSize = 10;

    assertOnRecordWriter(lines, expectedMap, "", blockSize);

    Configuration conf = new Configuration();
    conf.set("monarch.locator.port", testBase.getLocatorPort());
  }
 

@Test
public void returnsResultsFromEveryHandler() {
    BogusMavenInvocationOutputHandler handler1 = Mockito.mock(BogusMavenInvocationOutputHandler.class);
    Mockito.doReturn("data0").when(mockHandler).getResult();
    Mockito.doReturn("data1").when(handler1).getResult();
    multiHandler.register(mockHandler);
    multiHandler.register(handler1);
    multiHandler.consumeLine("line1");
    multiHandler.consumeLine("line2");
    Map<Class<? extends MavenInvocationOutputHandler>, Object> results = multiHandler.getResult();

    Assert.assertEquals(2, results.size());

    Assert.assertEquals(results.get(mockHandler.getClass()), "data0");
    Assert.assertEquals(results.get(handler1.getClass()), "data1");
}
 

@Test
public void test_isBeforeIsAfterIsEqual2nanos() {
    OffsetTime a = OffsetTime.of(11, 30, 59, 4, ZoneOffset.ofTotalSeconds(OFFSET_PONE.getTotalSeconds() + 1));
    OffsetTime b = OffsetTime.of(11, 30, 59, 3, OFFSET_PONE);  // a is before b due to offset
    assertEquals(a.isBefore(b), true);
    assertEquals(a.isEqual(b), false);
    assertEquals(a.isAfter(b), false);

    assertEquals(b.isBefore(a), false);
    assertEquals(b.isEqual(a), false);
    assertEquals(b.isAfter(a), true);

    assertEquals(a.isBefore(a), false);
    assertEquals(b.isBefore(b), false);

    assertEquals(a.isEqual(a), true);
    assertEquals(b.isEqual(b), true);

    assertEquals(a.isAfter(a), false);
    assertEquals(b.isAfter(b), false);
}
 

@Test
public void testIndexedCorola() throws IOException, SAXException, ParserConfigurationException, GGSException {
    IndexedLuceneCorpus t;
    try {
        t = new IndexedLuceneCorpus(new File("TestData/inputCorpora/corola.index"));
    } catch (IOException e) {
        throw new SkipException("indexed corola not present");
    }
    Grammar g = new Grammar();
    //g.load(new FileInputStream("TestData/inputGrammars/roNPchunker_grammar.ggf"));
    //g.load(new FileInputStream("TestData/inputGrammars/npexample.ggf"));
    g.load(new FileInputStream("TestData/inputGrammars/verysimplegrammar.ggf"));

    SparseBitSet.compressionPolicy = SparseBitSet.SparseBitSetCompressionPolicy.none;
    CompiledGrammar compiledGrammar = new CompiledGrammar(g);
    List<Match> matches = compiledGrammar.GetMatches(t, true);

    assert (matches.size() == matches.size());
}
 

@Test
public void testSubtraction() {
  b1 = rampdouble(-1,1,n1);               assertEqual(b1,sub(a1,1));
  b2 = rampdouble(-1,1,10,n1,n2);         assertEqual(b2,sub(a2,1));
  b3 = rampdouble(-1,1,10,100,n1,n2,n3);  assertEqual(b3,sub(a3,1));

  b1 = rampdouble(1,-1,n1);               assertEqual(b1,sub(1,a1));
  b2 = rampdouble(1,-1,-10,n1,n2);        assertEqual(b2,sub(1,a2));
  b3 = rampdouble(1,-1,-10,-100,n1,n2,n3);assertEqual(b3,sub(1,a3));

  zero(b1);                               assertEqual(b1,sub(a1,a1));
  zero(b2);                               assertEqual(b2,sub(a2,a2));
  zero(b3);                               assertEqual(b3,sub(a3,a3));

  sub(a1,a1,a1);                          assertEqual(b1,a1);
  sub(a2,a2,a2);                          assertEqual(b2,a2);
  sub(a3,a3,a3);                          assertEqual(b3,a3);
}
 

@Deprecated
@Test(enabled = false)
public void testResourceMonthDetailDAOCount() throws Exception {
  String environemntName = environemntNames[0];

  long statusOnlineCount = aggregatedStatusDAO.getStatusCount(environemntName, resource.getId(), Status.Online, startDate, endDate);
  Assert.assertTrue(statusOnlineCount > 0);
  Assert.assertEquals(statusOnlineCount, 100);

  long statusUnavailableCount = aggregatedStatusDAO.getStatusCount(environemntName, resource.getId(), Status.Unavailable, startDate, endDate);
  Assert.assertTrue(statusUnavailableCount > 0);
  Assert.assertEquals(statusUnavailableCount, 100);

  long statusUnknownCount = aggregatedStatusDAO.getStatusCount(environemntName, resource.getId(), Status.Unknown, startDate, endDate);
  Assert.assertTrue(statusUnknownCount > 0);
  Assert.assertEquals(statusUnknownCount, 100);

}
 

@Test
public void testGetSecretsGroupIdentifiers() throws Exception {
    ListPoliciesRequest request = new ListPoliciesRequest().withMaxItems(1000).withPathPrefix("/strongbox/");
    Policy policyUS1 = new Policy().withPolicyName("strongbox_us-west-1_test-group1_admin");
    Policy policyUS2 = new Policy().withPolicyName("strongbox_us-west-1_test-group2_admin");
    Policy policyEU1 = new Policy().withPolicyName("strongbox_eu-west-1_test-group1_admin");
    Policy policyEU1readonly = new Policy().withPolicyName("strongbox_eu-west-1_test-group1_readonly");
    ListPoliciesResult result = new ListPoliciesResult()
            .withPolicies(policyUS1, policyUS2, policyEU1, policyEU1readonly);
    when(mockClient.listPolicies(request)).thenReturn(new ListPoliciesResult()
            .withPolicies(policyUS1, policyUS2, policyEU1, policyEU1readonly));

    Set<SecretsGroupIdentifier> identifiers = partiallyMockedPolicyManager.getSecretsGroupIdentifiers();
    assertEquals(identifiers.size(), 3);
    assertTrue(identifiers.contains(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group1")));
    assertTrue(identifiers.contains(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2")));
    assertTrue(identifiers.contains(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group1")));

    verify(mockClient, times(1)).listPolicies(request);
}
 

@Test
public void test_next() {
    for (Month month : Month.values()) {
        for (int i = 1; i <= month.length(false); i++) {
            LocalDate date = date(2007, month, i);

            for (DayOfWeek dow : DayOfWeek.values()) {
                LocalDate test = (LocalDate) TemporalAdjusters.next(dow).adjustInto(date);

                assertSame(test.getDayOfWeek(), dow, date + " " + test);

                if (test.getYear() == 2007) {
                    int dayDiff = test.getDayOfYear() - date.getDayOfYear();
                    assertTrue(dayDiff > 0 && dayDiff < 8);
                } else {
                    assertSame(month, Month.DECEMBER);
                    assertTrue(date.getDayOfMonth() > 24);
                    assertEquals(test.getYear(), 2008);
                    assertSame(test.getMonth(), Month.JANUARY);
                    assertTrue(test.getDayOfMonth() < 8);
                }
            }
        }
    }
}
 

@Test
public void testNotEqualsHashCode() throws Exception {
  final Route route1 = ImmutableRoute.builder()
    .targetPrefix(GLOBAL_TARGET_PREFIX)
    .nextHopLedgerAccount(DEFAULT_CONNECTOR_ACCOUNT)
    .build();
  final Route route2 = ImmutableRoute.builder()
    .targetPrefix(GLOBAL_TARGET_PREFIX)
    .nextHopLedgerAccount(DEFAULT_CONNECTOR_ACCOUNT)
    .sourcePrefixRestrictionRegex(ACCEPT_NO_SOURCES_PATTERN)
    .build();

  assertThat(route1, is(not(route2)));
  assertThat(route2, is(not(route1)));
  assertThat(route1.hashCode(), is(not(route2.hashCode())));
}
 

@Test(expectedExceptions = AssertionError.class)
public void performTestResultsVerificationFailTest() {
    Map<String, String> testResults =
            new HashMap<>();

    testResults.
            put("SomeField:",
                    "TestMe");
    testResults.
            put("Status:",
                    "QWE");

    performTestResultsVerification(
            generateVerificationEntities(
                    UI_COMMON_RULES),
            testResults,
            UI_COMMON.name());
}
 

@Test
public void testUriVariablePositive() {
    HashSet<Attribute> attributes = new HashSet<Attribute>(
            Arrays.asList(new Attribute("acs", "site", "boston"), new Attribute("acs", "department", "sales")));
    ResourceHandler handler = new ResourceHandler(attributes,
            "http://assets.predix.io/site/boston/department/sales", "site/{site_id}/department/{department_id}");
    Assert.assertEquals("boston", handler.uriVariable("site_id"));
    Assert.assertEquals("sales", handler.uriVariable("department_id"));
    Assert.assertNotEquals("hr", handler.uriVariable("department_id"));
}
 

@Test(expectedExceptions = NullPointerException.class)
public void testGetNullProperty() throws SAXNotRecognizedException, SAXNotSupportedException {
    ValidatorHandler validatorHandler = getValidatorHandler();
    assertNotNull(validatorHandler);
    validatorHandler.getProperty(null);

}
 

@Test
public void test_plusMonths_zero() {
    LocalDateTime ldt = LocalDateTime.of(2008, 6, 30, 23, 30, 59, 0);
    ZonedDateTime base = ZonedDateTime.of(ldt, ZONE_0100);
    ZonedDateTime test = base.plusMonths(0);
    assertEquals(test, base);
}
 

@Test
public void equals() {
    // Wrong type.
    assertFalse(rawSecretEntry.equals(secretIdentifier));

    // Doesn't equal
    RawSecretEntry rawSecretEntry2 = new RawSecretEntry(
            secretIdentifier, version, state, Optional.empty(), Optional.empty(), secret);
    assertFalse(rawSecretEntry.equals(rawSecretEntry2));

    // Equals
    RawSecretEntry rawSecretEntry3 = new RawSecretEntry(
            secretIdentifier, version, state, Optional.empty(), Optional.empty(), secret);
    assertTrue(rawSecretEntry2.equals(rawSecretEntry3));
}
 

@Test
public void accessStaticFieldByteBoxing() throws ScriptException {
    e.eval("var ps_byte = SharedObject.publicStaticByte;");
    assertEqualsDouble(SharedObject.publicStaticByte, "ps_byte");
    e.eval("SharedObject.publicStaticByte = 16;");
    assertEquals(16, SharedObject.publicStaticByte);
}
 

@Test(groups = { "Getters" })
void getDuration_should_return_duration_of_video_in_ms_of_Type_Integer_StockFile()
        throws NoSuchFieldException, IllegalAccessException {
    Field f = stockFile.getClass().getDeclaredField("mDuration");
    f.setAccessible(true);
    f.set(stockFile, 100);
    Assert.assertEquals(100, stockFile.getDuration().intValue());
}
 

@Test
public void testWithDefaultArgumentValues() {
    ReadXml readXml = new ReadXml();
    String xml = "<root attr1=\"value1\"><child1 attr1=\"value1\">child1 text</child1></root>";
    readXml.writeArgument("xml", xml);
    readXml.run();
    assertEquals(readXml.readOutputValue("value"), "child1 text");
    assertEquals(readXml.readOutputValue("object"), null);
}
 

/**
 * Validate that the ordering of the returned SQLWarning is correct using
 * for-each loop
 */
@Test
public void test13() {
    SQLWarning ex = new SQLWarning("Warning 1", t1);
    SQLWarning ex1 = new SQLWarning("Warning 2");
    SQLWarning ex2 = new SQLWarning("Warning 3", t2);
    ex.setNextWarning(ex1);
    ex.setNextWarning(ex2);
    int num = 0;
    for (Throwable e : ex) {
        assertTrue(warnings[num++].equals(e.getMessage()));
    }
}
 

@Test
public void testGetWithCacheMissForPolicyEvaluation() {

    PolicyEvaluationRequestV1 request = new PolicyEvaluationRequestV1();
    request.setAction(ACTION_GET);
    request.setSubjectIdentifier(AGENT_MULDER);
    request.setResourceIdentifier(XFILES_ID);
    PolicyEvaluationRequestCacheKey key = new PolicyEvaluationRequestCacheKey.Builder().zoneId(ZONE_NAME)
            .request(request).build();
    assertNull(this.cache.get(key));
}
 

@Test
public void test_get_TemporalField() {
    Instant test = TEST_12345_123456789;
    assertEquals(test.get(ChronoField.NANO_OF_SECOND), 123456789);
    assertEquals(test.get(ChronoField.MICRO_OF_SECOND), 123456);
    assertEquals(test.get(ChronoField.MILLI_OF_SECOND), 123);
}
 

@Test
public void test_withOffsetSameInstant() {
    OffsetDateTime base = OffsetDateTime.of(LocalDate.of(2008, 6, 30), LocalTime.of(11, 30, 59), OFFSET_PONE);
    OffsetDateTime test = base.withOffsetSameInstant(OFFSET_PTWO);
    OffsetDateTime expected = OffsetDateTime.of(LocalDate.of(2008, 6, 30), LocalTime.of(12, 30, 59), OFFSET_PTWO);
    assertEquals(test, expected);
}
 

@Test
public void testReadDeprecatedOutputValue() {
    TestAction instance = new TestActionImpl();
    instance.writeOutput("output1", "value1");
    instance.markOutputAsDeprecated("output1");
    Object result = instance.readOutputValue("output1");
    assertEquals(result, "value1");
    assertEquals(instance.isOutputDeprecated("output1"), true);
}
 

@Test
public void userEngineScopeBindingsNoLeakTest() throws ScriptException {
    final ScriptEngineManager m = new ScriptEngineManager();
    final ScriptEngine e = m.getEngineByName("nashorn");
    final ScriptContext newContext = new SimpleScriptContext();
    newContext.setBindings(new SimpleBindings(), ScriptContext.ENGINE_SCOPE);
    e.eval("function foo() {}", newContext);

    // in the default context's ENGINE_SCOPE, 'foo' shouldn't exist
    assertTrue(e.eval("typeof foo").equals("undefined"));
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testOps(String name, TestData.OfInt data) {
    exerciseTerminalOps(data, s -> s.sum());

    withData(data).
            terminal(s -> (long) s.sum()).
            expectedResult(data.stream().asLongStream().reduce(0, LambdaTestHelpers.lrPlus)).
            exercise();
}
 

@Test
public void testExplicitPropertyMappings()
{
    Map<String, String> properties = new ImmutableMap.Builder<String, String>()
            .put("thrift.client.transport", "HEADER")
            .put("thrift.client.protocol", "COMPACT")
            .put("thrift.client.connect-timeout", "99ms")
            .put("thrift.client.request-timeout", "33m")
            .put("thrift.client.socks-proxy", "localhost:11")
            .put("thrift.client.max-frame-size", "55MB")
            .put("thrift.client.max-string-size", "66MB")
            .put("thrift.client.ssl.enabled", "true")
            .put("thrift.client.ssl.trust-certificate", "trust")
            .put("thrift.client.ssl.key", "key")
            .put("thrift.client.ssl.key-password", "key_password")
            .build();

    ApacheThriftClientConfig expected = new ApacheThriftClientConfig()
            .setTransport(HEADER)
            .setProtocol(COMPACT)
            .setConnectTimeout(new Duration(99, MILLISECONDS))
            .setRequestTimeout(new Duration(33, MINUTES))
            .setSocksProxy(HostAndPort.fromParts("localhost", 11))
            .setMaxFrameSize(new DataSize(55, MEGABYTE))
            .setMaxStringSize(new DataSize(66, MEGABYTE))
            .setSslEnabled(true)
            .setTrustCertificate(new File("trust"))
            .setKey(new File("key"))
            .setKeyPassword("key_password");

    assertFullMapping(properties, expected);
}
 

@Test
public void json_multiple_secret_entries() throws IOException {
    outputStream.reset();

    Renderer renderer = new Renderer(OutputFormat.JSON, printStream, null, null);
    renderer.render(Arrays.asList(secretEntryView, secretEntryViewBinary));

    String expected = String.format("[ %s, %s ]\n", loadExpectedValue("expected_secret_entry.json"), loadExpectedValue("expected_secret_entry_binary.json"));
    assertThat(outputStream.toString(), equalTo(expected));
}
 

@Test(expectedExceptions = IllegalArgumentException.class)
public void postNullMessageTest() {
    svc.setBotName("postMessageExerciseTest");
    svc.setTimeout(1);
    XMPPSubscriber sub = new XMPPSubscriber();
    sub.setChatServer("notarealaddressOK");
    sub.setChatPort(9);
    svc.postMessage(null, sub);
}
 

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testGroupingByWithMapping(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Function<Integer, Integer> classifier = i -> i % 3;
    Function<Integer, Integer> mapper = i -> i * 2;

    exerciseMapCollection(data,
                          groupingBy(classifier, mapping(mapper, toList())),
                          new GroupingByAssertion<>(classifier, HashMap.class,
                                                    new MappingAssertion<>(mapper,
                                                                           new ToListAssertion<>())));
}
 

@Test
public void testGetFundingNegativeThreshold() throws Exception {

    assertEquals(target.getFundingNegativeThreshold(site, inst), new BigDecimal("0.0"));

    // Specific
    doReturn(new BigDecimal("2.3456")).when(conf).getBigDecimal(FUNDING_NEGATIVE_THRESHOLD.getKey());
    assertEquals(target.getFundingNegativeThreshold(site, inst), new BigDecimal("2.3456"));

    // Ceiling
    doReturn(valueOf(Integer.MAX_VALUE)).when(conf).getBigDecimal(FUNDING_NEGATIVE_THRESHOLD.getKey());
    assertEquals(target.getFundingNegativeThreshold(site, inst), valueOf(Integer.MAX_VALUE));

    // Floor
    doReturn(valueOf(Integer.MIN_VALUE)).when(conf).getBigDecimal(FUNDING_NEGATIVE_THRESHOLD.getKey());
    assertEquals(target.getFundingNegativeThreshold(site, inst), valueOf(Integer.MIN_VALUE));

    // Error
    doThrow(new RuntimeException("test")).when(conf).getBigDecimal(FUNDING_NEGATIVE_THRESHOLD.getKey());
    assertEquals(target.getFundingNegativeThreshold(site, inst), ONE);
    reset(conf);

    // Override
    target.setFundingNegativeThreshold(site, inst, TEN);
    assertEquals(target.getFundingNegativeThreshold(site, inst), TEN);

    // Clear
    target.setFundingNegativeThreshold(site, inst, null);
    assertEquals(target.getFundingNegativeThreshold(site, inst), new BigDecimal("0.0"));

}
 

/**
 * Test the functionality of setFeature and getFeature methods
 * for namespaces property.
 * @throws Exception If any errors occur.
 */
@Test
public void testFeature02() throws Exception {
    SAXParserFactory spf = SAXParserFactory.newInstance();

    spf.setFeature(NAMESPACES, true);
    assertTrue(spf.getFeature(NAMESPACES));

    spf.setFeature(NAMESPACES, false);
    assertFalse(spf.getFeature(NAMESPACES));
}
 

@Test(dataProvider="minusSeconds_fromZero")
public void test_minusSeconds_fromZero(int seconds, int hour, int min, int sec) {
    LocalTime base = LocalTime.MIDNIGHT;
    LocalTime t = base.minusSeconds(seconds);

    assertEquals(t.getHour(), hour);
    assertEquals(t.getMinute(), min);
    assertEquals(t.getSecond(), sec);
}
 

@Test
public void testInstantTypeConversionWithString(){
	InstantTypeConversion instantTypeConversion = new InstantTypeConversion();
	String instantStr = new String("2014-12-03T10:15:30.00Z");
	InstantFormat obj = new InstantFormat(instantStr);
	Instant convertedInstant = instantTypeConversion.convert(obj);
	assertEquals(convertedInstant.getNano(), Instant.parse(instantStr).getNano());
}
 

@Test
public void testFieldWithMatchingIdlAnnotationMaps()
        throws Exception
{
    // Single field with matching IDL annotation maps on setter vs getter: should be okay
    ThriftStructMetadata metadata = testStructMetadataBuild(BeanWithMatchingIdlAnnotationsMapsForField.class, 0, 1);
    Map<String, String> idlAnnotations = metadata.getField(2).getIdlAnnotations();
    assertEquals(idlAnnotations.size(), 2);
    assertEquals(idlAnnotations.get("testkey1"), "testvalue1");
    assertEquals(idlAnnotations.get("testkey2"), "testvalue2");
}
 

@Test
public void testOrderByReturnsResultsInStableOrder() throws Exception {
    Map<String, Object> vars = buildVariableMap(ORDERED_TYPE_NAME);
    vars.put("orderBy", OrderBy.UPDATE_DATE.getFieldName());
    vars.put("orderByDirection", OrderByDirection.DESC);

    List<Long> updateDates1 = fetchUpdateDates(vars);
    List<Long> updateDates2 = fetchUpdateDates(vars);

    assertEquals(updateDates1, updateDates2);
}
 

@Test(dataProvider="sample_isoLocalTime")
public void test_parse_isoLocalTime(
        Integer hour, Integer min, Integer sec, Integer nano, String offsetId, String zoneId,
        String input, Class<?> invalid) {
    if (input != null) {
        Expected expected = createTime(hour, min, sec, nano);
        // offset/zone not expected to be parsed
        assertParseMatch(DateTimeFormatter.ISO_LOCAL_TIME.parseUnresolved(input, new ParsePosition(0)), expected);
    }
}
 

@Test
public void stringArrayToStringTest(){
  final String text = "DejaGnu version 1.6\n" +
         "Expect version  5.45\n" +
         "Tcl version     8.6";
  Assert.assertEquals(AutotoolsToolProvider.stringArrayToString(text.split("\n")), text);
}
 

@Test
public void testSetTrueFragment() {
    try {
        reset();
        fValidator.setFeature(IGNORE_XSI_TYPE, true);
        validateFragment();
    } catch (Exception e) {
        fail("Validation failed: " + e.getMessage());
    }

    checkTrueResult();
}
 

@Test(groups = { "Setters" })
void setFilterContentTypePhoto_should_set_media_Filter_ContentTypePhoto_and_should_return_instanceof_SearchParameters()
        throws IllegalAccessException,
        NoSuchFieldException {
    Assert.assertNotNull(param.setFilterContentTypePhoto(true));
    Field f = param.getClass().getDeclaredField("mFilterContentTypePhoto");
    f.setAccessible(true);
    Assert.assertTrue((f.get(param)).equals(true));
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testSkipOps(String name, TestData.OfInt data) {
    List<Integer> skips = sizes(data.size());

    for (int s : skips) {
        setContext("skip", s);
        Collection<Integer> sr = exerciseOps(data, st -> st.skip(s));
        assertEquals(sr.size(), sliceSize(data.size(), s));

        sr = exerciseOps(data, st -> st.skip(s).skip(s / 2));
        assertEquals(sr.size(), sliceSize(sliceSize(data.size(), s), s / 2));
    }
}
 

@Test
public void test_epochSecond_2() {
    assertEquals(IsoChronology.INSTANCE.epochSecond(2008, 3, 3, 1, 2, 2, OFFSET_P0100),
                 ZonedDateTime.of(2008, 3, 3, 1, 2, 2, 0, ZoneId.of("+01:00")).toEpochSecond());
    assertEquals(IsoChronology.INSTANCE.epochSecond(1969, 3, 3, 1, 2, 2, OFFSET_P0100),
                 ZonedDateTime.of(1969, 3, 3, 1, 2, 2, 0, ZoneId.of("+01:00")).toEpochSecond());
}
 

@Test(groups = "StockConfig.setTargetEnvironment")
public void setTargetEnvironment_should_set_target_environment_and_endpoints_config_params_as_per_environment_parameter_passed()
        throws StockException {
    StockConfig config = new StockConfig();

    try {
        Field fEnv = StockConfig.class
                .getDeclaredField("mTargetEnvironment");
        fEnv.setAccessible(true);

        Field fEndpoints = StockConfig.class.getDeclaredField("mEndpoints");
        fEndpoints.setAccessible(true);

        Field fEndpointsEnv = Endpoints.class
                .getDeclaredField("mEnvironment");
        fEndpointsEnv.setAccessible(true);

        config.setTargetEnvironment(Environment.PROD);

        Assert.assertEquals((Environment) fEnv.get(config),
                Environment.PROD);
        Endpoints endpoints = (Endpoints) fEndpoints.get(config);
        Assert.assertEquals(fEndpointsEnv.get(endpoints), Environment.PROD);

        config.setTargetEnvironment(Environment.STAGE);

        Assert.assertEquals((Environment) fEnv.get(config),
                Environment.STAGE);

        endpoints = (Endpoints) fEndpoints.get(config);
        Assert.assertEquals(fEndpointsEnv.get(endpoints), Environment.STAGE);

    } catch (Exception e) {
        Assert.fail("Didn't expect the exception here!", e);
    }

}
 

@Test
public void test_parse_endOfDay() {
    Instant expected = OffsetDateTime.of(1970, 2, 4, 0, 0, 0, 0, ZoneOffset.UTC).toInstant();
    DateTimeFormatter f = new DateTimeFormatterBuilder().appendInstant(-1).toFormatter();
    for (ResolverStyle style : ResolverStyle.values()) {
        TemporalAccessor parsed = f.withResolverStyle(style).parse("1970-02-03T24:00:00Z");
        assertEquals(parsed.query(Instant::from), expected);
        assertEquals(parsed.query(DateTimeFormatter.parsedExcessDays()), Period.ZERO);
        assertEquals(parsed.query(DateTimeFormatter.parsedLeapSecond()), Boolean.FALSE);
    }
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses", enabled = false)
public void commonCachedRowSetTest0019(CachedRowSet rs) throws Exception {
    int[] expectedCols = {1, 3};
    String[] expectedColNames = {"COF_ID", "SUP_ID"};
    rs.setMatchColumn(expectedColNames);
    int[] actualCols = rs.getMatchColumnIndexes();
    String[] actualColNames = rs.getMatchColumnNames();
    assertEquals(actualCols, expectedCols);
    assertEquals(actualColNames, expectedColNames);
    rs.close();
}
 

@Test
public void findRelation_withTwoTypesWithAnotherInstanceReference_successCase() throws Exception {
    actualGraphQLResult = executeSchemaQuery(withAnotherInstanceReferenceOne);
    assertSuccess(actualGraphQLResult);

    actualGraphQLResult = executeSchemaQuery(withAnotherInstanceReferenceTwo);
    assertSuccess(actualGraphQLResult);

    actualGraphQLResult = executeSchemaQuery(viewElements);
    // Each type only is referred by itself
    assertResult(actualGraphQLResult, withTwoTypesWithAnotherInstanceReferenceResult);
}
 

@Test(dataProvider = "topLevelPkgDirs")
public void testNotExists(String path) throws Exception {
    FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
    Path dir = fs.getPath(path);

    // package directories should not be there at top level
    assertTrue(Files.notExists(dir));
}
 

@Test
public void factFromNtriplesTest() throws IOException {
    Stargraph core = new Stargraph(config, false);
    core.setModelFactory(new NTriplesModelFactory(core));
    core.initialize();

    KBId kbId = KBId.of("obama", "facts");
    FactProviderFactory factory = new FactProviderFactory(core);
    DataProvider<?> provider = factory.create(kbId);
    Assert.assertEquals(provider.getStream().count(), 1877);
}
 

@Test(dataProvider="error")
public void test_parse_error(TemporalField field, int min, int max, SignStyle style, String text, int pos, Class<?> expected) {
    try {
        getFormatter(field, min, max, style).parseUnresolved(text, new ParsePosition(pos));
        fail();
    } catch (RuntimeException ex) {
        assertTrue(expected.isInstance(ex));
    }
}
 

@Test
public void testRegularSend() {		
	consumer.startRecording();
	String text = "{\"deploymentId\":546589,\"releaseId\":546559,\"maxExecOrder\":6,\"nsPath\":\"/local-dev/prod1/dev/bom\",\"deploymentState\":\"paused\",\"processId\":\"87820!87820\",\"createdBy\":\"bannama\",\"updatedBy\":\"bannama\",\"comments\":\"\",\"created\":\"Jan 5, 2016 7:15:37 PM\",\"updated\":\"Jan 8, 2016 3:56:55 PM\"}";
	Map<String, String> headers = new HashMap<String, String>();
	headers.put("messageId", "1");
	headers.put("source", "test");
	MessageData data = new MessageData(text, headers);
	searchPublisher.publish(data);
	await().atMost(5, TimeUnit.SECONDS).until(() -> (consumer.getCounter() == 1));
	Assert.assertEquals(consumer.getMessages().getFirst().getPayload(), text);
	Assert.assertEquals(consumer.getMessages().getFirst().getHeaders(), headers);
}
 

@Test
public void test_toFormat_parseObject_StringParsePosition_invalidPosition_tooSmall() throws Exception {
    // SimpleDateFormat throws StringIndexOutOfBoundException
    DateTimeFormatter dtf = fmt.withLocale(Locale.ENGLISH).withDecimalStyle(DecimalStyle.STANDARD);
    ParsePosition pos = new ParsePosition(-1);
    Format test = dtf.toFormat();
    assertNull(test.parseObject("ONE30", pos));
    assertTrue(pos.getErrorIndex() >= 0);
}
 

@Test
    public void detectJpaInjection() throws Exception {
        //Locate test code
//        String[] files = {
//                getClassFilePath("testcode/sqli/JpaSql")
//        };
//
//        //Run the analysis
//        EasyBugReporter reporter = spy(new SecurityReporter());
//        analyze(files, reporter);
//
//        verify(reporter).doReportBug(
//                bugDefinition()
//                        .bugType("SQL_INJECTION_JPA")
//                        .inClass("JpaSql").inMethod("getUserByUsername").atLine(16)
//                        .build()
//        );
//        verify(reporter).doReportBug(
//                bugDefinition()
//                        .bugType("SQL_INJECTION_JPA")
//                        .inClass("JpaSql").inMethod("getUserByUsernameAlt2").atLine(24)
//                        .build()
//        );
//
//        //Only the previous 5 cases should be marked as vulnerable
//        //2 createQuery + 3 createNativeQuery detect
//        verify(reporter, times(2+3)).doReportBug(
//                bugDefinition()
//                        .bugType("SQL_INJECTION_JPA")
//                        .build()
//        );
    }
 

@Test
public void testMatchByJavaNameWithThriftNameOverride()
        throws Exception
{
    ThriftCatalog catalog = readCodecManager.getCatalog();
    ThriftType thriftType = catalog.getThriftType(BonkConstructorNameOverride.class);
    ThriftStructMetadata structMetadata = thriftType.getStructMetadata();
    assertEquals(structMetadata.getField(1).getName(), "myMessage");
    assertEquals(structMetadata.getField(2).getName(), "myType");

    BonkConstructorNameOverride bonk = new BonkConstructorNameOverride("message", 42);
    testRoundTripSerialize(bonk);
}
 

@Test
public void test_SplitAndTokenize_collon_elipse() throws IllegalAccessException, InstantiationException {
    String input = "Elena Udrea înainte de a exprima o anumită grijă de-a binelea care-i muncește în aceste zile pe multi dintre pedelisti: ce se-ntâmplă dacă-și ia mâna ... de pe noi?";

    UaicTokenizer tokenizer = new UaicTokenizer(morphologicalDictionary);
    InmemoryCorpus rez = tokenizer.splitAndTokenize(input);
    assertEquals(rez.getTokenCount(), 31);
    assertEquals(rez.getToken(22).getWordForm(), "-ntâmplă");
}
 

/**
 * Test that returning null from a filter causes deserialization to fail.
 */
@Test(expectedExceptions=InvalidClassException.class)
static void testNullStatus() throws IOException {
    byte[] bytes = writeObjects(0); // an Integer
    try {
        Object o = validate(bytes, new ObjectInputFilter() {
            public ObjectInputFilter.Status checkInput(ObjectInputFilter.FilterInfo f) {
                return null;
            }
        });
    } catch (InvalidClassException ice) {
        System.out.printf("    success exception: %s%n", ice);
        throw ice;
    }
}
 

@Test
public void testDecrementAndGet() {
  double val = 10.0;
  ad.set(val);
  for (int i=10; i>0; --i) {
    val = ad.get();             assertEquals((double)(i  ),val,1.0E-8);
    val = ad.decrementAndGet(); assertEquals((double)(i-1),val,1.0E-8);
    val = ad.get();             assertEquals((double)(i-1),val,1.0E-8);
  }
}
 

@Test
public void test_atTime_int_int_int() {
    LocalDate t = LocalDate.of(2008, 6, 30);
    assertEquals(t.atTime(11, 30, 40), LocalDateTime.of(2008, 6, 30, 11, 30, 40));
}