Example usage for junit.framework Assert assertFalse

List of usage examples for junit.framework Assert assertFalse

  1. HOME
  2. Java
  3. junit
  4. junit.framework.*
  5. Assert
  6. assertFalse

Introduction

In this page you can find the example usage for junit.framework Assert assertFalse.

Prototype

static public void assertFalse(boolean condition)

Source Link

Document

Asserts that a condition is false.

Usage

From source file:com.ebay.cloud.cms.query.service.QueryPaginationByIdTest.java

@Test
public void testQueryIte_join() {
    String query = "VPool[exists @environment]{*}.computes[@fqdns=~\".*.com\"]";
    QueryContext qc = newQueryContext(STRATUS_REPO, IBranch.DEFAULT_BRANCH);
    qc.setPaginationMode(PaginationMode.ID_BASED);
    qc.setAllowFullTableScan(true);/*from  ww  w .  j  a v  a2s .  c o m*/
    qc.setLimits(new int[] { 1, 6 });
    qc.setSourceIP("127.0.0.1");
    IQueryResult result = queryService.query(query, qc);
    Assert.assertTrue(result.hasMoreResults());

    int[] nLimit = result.getNextCursor().getLimits();
    int hint = result.getNextCursor().getHint();
    Assert.assertEquals(0, hint);
    List<String> nextCursorValues = result.getNextCursor().getJoinCursorValues();
    Assert.assertNotNull(nextCursorValues);
    Assert.assertEquals(2, nextCursorValues.size());
    Assert.assertEquals(2, nLimit.length);
    Assert.assertEquals(1, nLimit[0]);
    Assert.assertEquals(6, nLimit[1]);

    // continuing query using the next cursor
    List<String> fetchVPoolIds = new ArrayList<String>();
    int count = result.getEntities().size();
    System.out.println("fetch size:  " + count);
    // add to fetched ids
    for (IEntity entity : result.getEntities()) {
        fetchVPoolIds.add(entity.getId());
    }

    int iterateCount = 1;
    while (result.hasMoreResults()) {
        iterateCount++;
        System.out.println("iterate round: " + iterateCount + ", next skip _oid s: "
                + ArrayUtils.toString(result.getNextCursor().getJoinCursorValues()) + ",next limits: "
                + ArrayUtils.toString(result.getNextCursor().getLimits()));
        qc.setCursor(result.getNextCursor());

        result = queryService.query(query, qc);
        System.out.println("fetch size:  " + result.getEntities().size());
        count += result.getEntities().size();
        for (IEntity entity : result.getEntities()) {
            Assert.assertFalse(fetchVPoolIds.contains(entity.getId()));
            fetchVPoolIds.add(entity.getId());
        }
    }
    Assert.assertEquals(10, iterateCount);

    // assert the iterated query results with the no-limit results.
    List<String> fetchVPoolIds2 = new ArrayList<String>();
    QueryContext qc1 = newQueryContext(STRATUS_REPO, IBranch.DEFAULT_BRANCH);
    qc1.setPaginationMode(PaginationMode.ID_BASED);
    qc1.setAllowFullTableScan(true);
    qc1.setSourceIP("127.0.0.1");
    IQueryResult result1 = queryService.query(query, qc1);
    Assert.assertFalse(result1.hasMoreResults());
    Assert.assertTrue(2 >= result1.getEntities().size());
    for (IEntity entity : result1.getEntities()) {
        fetchVPoolIds2.add(entity.getId());
    }
    Assert.assertEquals(fetchVPoolIds, fetchVPoolIds2);
}

From source file:com.ebay.cloud.cms.query.service.QueryPaginationTest.java

/**
 * limit for embed version//from  w w  w  .  j  ava  2s  . c o m
 * 
 * hint for embed
 */
@Test
public void testQueryIterLimit02_embed() {
    String query = "Manifest.versions{*}";
    QueryContext qc = newQueryContext(DEPLOY_REPO, IBranch.DEFAULT_BRANCH);
    qc.setAllowFullTableScan(true);
    qc.setSkips(new int[] { 0, 0 });
    qc.setLimits(new int[] { 1, 0 });
    int hint = 1;
    qc.setHint(hint);
    qc.setSourceIP("127.0.0.1");
    IQueryResult result = queryService.query(query, qc);
    Assert.assertEquals(2, result.getEntities().size());
    Assert.assertFalse(result.hasMoreResults());
    Assert.assertNull(result.getNextCursor());
}

From source file:com.ebay.cloud.cms.query.service.QueryPaginationTest.java

@Test
public void testQueryIterLimit03_embed() {
    String query = "Manifest.versions{*}";
    QueryContext qc = newQueryContext(DEPLOY_REPO, IBranch.DEFAULT_BRANCH);
    qc.setAllowFullTableScan(true);//from  www . ja v a 2 s . com
    qc.setSkips(new int[] { 0, 0 });
    qc.setLimits(new int[] { 0 });
    qc.setSourceIP("127.0.0.1");
    IQueryResult result = queryService.query(query, qc);
    Assert.assertFalse(result.hasMoreResults());
}

From source file:BQJDBC.QueryResultTest.BQResultSetFunctionTest.java

@Test
public void TestResultSetRelative() {
    try {//from  w w w. j a  v  a2s.c  o m
        Assert.assertTrue(BQResultSetFunctionTest.Result.absolute(1));
        Assert.assertEquals("you", BQResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQResultSetFunctionTest.Result.relative(1));
        Assert.assertEquals("yet", BQResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQResultSetFunctionTest.Result.relative(2));
        Assert.assertEquals("world", BQResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQResultSetFunctionTest.Result.relative(5));
        Assert.assertEquals("words", BQResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQResultSetFunctionTest.Result.relative(-5));
        Assert.assertEquals("world", BQResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQResultSetFunctionTest.Result.relative(-2));
        Assert.assertEquals("yet", BQResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQResultSetFunctionTest.Result.relative(-1));
        Assert.assertEquals("you", BQResultSetFunctionTest.Result.getString(1));
    } catch (SQLException e) {
        this.logger.error("SQLexception" + e.toString());
        Assert.fail("SQLException" + e.toString());
    }
    try {
        Assert.assertTrue(BQResultSetFunctionTest.Result.first());
        Assert.assertFalse(BQResultSetFunctionTest.Result.relative(-1));
        Assert.assertEquals("", BQResultSetFunctionTest.Result.getString(1));
    } catch (SQLException e) {
        boolean ct = e.toString().contains("Cursor is not in a valid Position");
        if (ct == true) {
            Assert.assertTrue(ct);
        } else {
            this.logger.error("SQLexception" + e.toString());
            Assert.fail("SQLException" + e.toString());
        }
    }

    try {
        Assert.assertTrue(BQResultSetFunctionTest.Result.last());
        Assert.assertFalse(BQResultSetFunctionTest.Result.relative(1));
        Assert.assertEquals("", BQResultSetFunctionTest.Result.getString(1));
    } catch (SQLException e) {
        boolean ct = e.toString().contains("Cursor is not in a valid Position");
        if (ct == true) {
            Assert.assertTrue(ct);
        } else {
            this.logger.error("SQLexception" + e.toString());
            Assert.fail("SQLException" + e.toString());
        }
    }
}

From source file:es.tekniker.framework.ktek.questionnaire.mng.server.test.TestQuestionnaireMngServer.java

@org.junit.Test
public void testGetQuestionnaires4TypeMonitoringActivityFilterWithIds() {
    log.info("*************************************************************");
    log.info("testGetQuestionnaires4TypeMonitoringActivityFilterWithIds: START ");
    String result = TestDefines.RESULT_OK;

    QuestionnaireMngServer manager = new QuestionnaireMngServer();
    String token = null;//from   w  ww  . ja va  2  s  .  c om
    int idlang = 1;
    List<KtekResultQuestionnaireItemsEntity> array = null;
    boolean all = false;
    long datefrom = (long) 1420113600000.0;
    long dateto = (long) 1451649600000.0;
    int orderby = 2;
    short typemonitoringactivity = 3;
    String ids = "0";
    String codtelecareprogram = "BD";
    try {
        token = "token1";
        array = manager.getQuestionnaires4TypeMonitoringActivityFilterWithIds(token, idlang, all, datefrom,
                dateto, orderby, typemonitoringactivity, ids, codtelecareprogram);

        if (array != null) {
            log.info("testGetQuestionnaires4TypeMonitoringActivityFilterWithIds: array is NOT NULL "
                    + array.size());
            Assert.assertTrue(true);
        } else {
            log.error("testGetQuestionnaires4TypeMonitoringActivityFilterWithIds: array is NULL ");
            result = TestDefines.RESULT_ERROR;
            Assert.assertTrue(true);
        }

    } catch (KtekExceptionEntity e) {
        System.out.println(
                "testGetQuestionnaires4TypeMonitoringActivityFilterWithIds:  exception " + e.getMessage());
        e.printStackTrace();
        Assert.assertFalse(false);
    }

    log.info("testGetQuestionnaires4TypeMonitoringActivityFilterWithIds: RESULT " + result);
    log.info("testGetQuestionnaires4TypeMonitoringActivityFilterWithIds: END ");
    log.info("*************************************************************");
    log.info("");

}

From source file:BQJDBC.QueryResultTest.BQScrollableResultSetFunctionTest.java

@Test
public void TestResultSetRelative() {
    try {// ww  w.  ja v  a  2s.  co m
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.absolute(1));
        Assert.assertEquals("you", BQScrollableResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.relative(1));
        Assert.assertEquals("yet", BQScrollableResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.relative(2));
        Assert.assertEquals("world", BQScrollableResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.relative(5));
        Assert.assertEquals("words", BQScrollableResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.relative(-5));
        Assert.assertEquals("world", BQScrollableResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.relative(-2));
        Assert.assertEquals("yet", BQScrollableResultSetFunctionTest.Result.getString(1));
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.relative(-1));
        Assert.assertEquals("you", BQScrollableResultSetFunctionTest.Result.getString(1));
    } catch (SQLException e) {
        this.logger.error("SQLexception" + e.toString());
        Assert.fail("SQLException" + e.toString());
    }
    try {
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.first());
        Assert.assertFalse(BQScrollableResultSetFunctionTest.Result.relative(-1));
        Assert.assertEquals("", BQScrollableResultSetFunctionTest.Result.getString(1));
    } catch (SQLException e) {
        boolean ct = e.toString().contains("Cursor is not in a valid Position");
        if (ct == true) {
            Assert.assertTrue(ct);
        } else {
            this.logger.error("SQLexception" + e.toString());
            Assert.fail("SQLException" + e.toString());
        }
    }

    try {
        Assert.assertTrue(BQScrollableResultSetFunctionTest.Result.last());
        Assert.assertFalse(BQScrollableResultSetFunctionTest.Result.relative(1));
        Assert.assertEquals("", BQScrollableResultSetFunctionTest.Result.getString(1));
    } catch (SQLException e) {
        boolean ct = e.toString().contains("Cursor is not in a valid Position");
        if (ct == true) {
            Assert.assertTrue(ct);
        } else {
            this.logger.error("SQLexception" + e.toString());
            Assert.fail("SQLException" + e.toString());
        }
    }
}

From source file:com.test.onesignal.MainOneSignalClassRunner.java

@Test
public void testDeleteTags() throws Exception {
    OneSignalInit();/*from   w ww  . j a v a 2s  .  co m*/
    OneSignal.sendTags("{\"str\": \"str1\", \"int\": 122, \"bool\": true}");
    OneSignal.deleteTag("int");
    GetTags();

    Assert.assertFalse(lastGetTags.has("int"));
    lastGetTags = null;

    // Makes sure they get sent
    OneSignal.sendTags("{\"str\": \"str1\", \"int\": 122, \"bool\": true}");
    threadAndTaskWait();
    Assert.assertEquals("str1", ShadowOneSignalRestClient.lastPost.getJSONObject("tags").get("str"));

    OneSignal.deleteTag("int");

    GetTags();

    Assert.assertFalse(lastGetTags.has("int"));

    // After the success response it should not store a "" string when saving to storage.
    threadAndTaskWait();

    final SharedPreferences prefs = blankActivity.getSharedPreferences(OneSignal.class.getSimpleName(),
            Context.MODE_PRIVATE);
    String syncValues = prefs.getString("ONESIGNAL_USERSTATE_SYNCVALYES_CURRENT_STATE", null);
    Assert.assertFalse(new JSONObject(syncValues).has("tags"));
}

From source file:com.linkedin.pinot.core.data.manager.realtime.LLRealtimeSegmentDataManagerTest.java

@Test
public void testEndCriteriaChecking() throws Exception {
    // test reaching max row limit
    {/*from  w w  w  . ja va  2s .  c  om*/
        FakeLLRealtimeSegmentDataManager segmentDataManager = createFakeSegmentManager();
        segmentDataManager._state.set(segmentDataManager, LLRealtimeSegmentDataManager.State.INITIAL_CONSUMING);
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        segmentDataManager.setNumRowsIndexed(maxRowsInSegment - 1);
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        segmentDataManager.setNumRowsIndexed(maxRowsInSegment);
        Assert.assertTrue(segmentDataManager.invokeEndCriteriaReached());
        Assert.assertEquals(segmentDataManager.getStopReason(), SegmentCompletionProtocol.REASON_ROW_LIMIT);
    }
    // test reaching max time limit
    {
        FakeLLRealtimeSegmentDataManager segmentDataManager = createFakeSegmentManager();
        segmentDataManager._state.set(segmentDataManager, LLRealtimeSegmentDataManager.State.INITIAL_CONSUMING);
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        _timeNow += maxTimeForSegmentCloseMs + 1;
        // We should still get false, since the number of records in the realtime segment is 0
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        replaceRealtimeSegment(segmentDataManager, 10);
        // Now we can test when we are far ahead in time
        _timeNow += maxTimeForSegmentCloseMs;
        Assert.assertTrue(segmentDataManager.invokeEndCriteriaReached());
        Assert.assertEquals(segmentDataManager.getStopReason(), SegmentCompletionProtocol.REASON_TIME_LIMIT);
    }
    // In catching up state, test reaching final offset
    {
        FakeLLRealtimeSegmentDataManager segmentDataManager = createFakeSegmentManager();
        segmentDataManager._state.set(segmentDataManager, LLRealtimeSegmentDataManager.State.CATCHING_UP);
        final long finalOffset = _startOffset + 100;
        segmentDataManager.setFinalOffset(finalOffset);
        segmentDataManager.setCurrentOffset(finalOffset - 1);
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        segmentDataManager.setCurrentOffset(finalOffset);
        Assert.assertTrue(segmentDataManager.invokeEndCriteriaReached());
    }
    // In catching up state, test reaching final offset ignoring time
    {
        FakeLLRealtimeSegmentDataManager segmentDataManager = createFakeSegmentManager();
        _timeNow += maxTimeForSegmentCloseMs;
        segmentDataManager._state.set(segmentDataManager, LLRealtimeSegmentDataManager.State.CATCHING_UP);
        final long finalOffset = _startOffset + 100;
        segmentDataManager.setFinalOffset(finalOffset);
        segmentDataManager.setCurrentOffset(finalOffset - 1);
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        segmentDataManager.setCurrentOffset(finalOffset);
        Assert.assertTrue(segmentDataManager.invokeEndCriteriaReached());
    }
    // When we go from consuming to online state, time and final offset matter.
    // Case 1. We have reached final offset.
    {
        FakeLLRealtimeSegmentDataManager segmentDataManager = createFakeSegmentManager();
        _timeNow += 1;
        segmentDataManager._state.set(segmentDataManager,
                LLRealtimeSegmentDataManager.State.CONSUMING_TO_ONLINE);
        segmentDataManager.setConsumeEndTime(_timeNow + 10);
        final long finalOffset = _startOffset + 100;
        segmentDataManager.setFinalOffset(finalOffset);
        segmentDataManager.setCurrentOffset(finalOffset - 1);
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        segmentDataManager.setCurrentOffset(finalOffset);
        Assert.assertTrue(segmentDataManager.invokeEndCriteriaReached());
    }
    // Case 2. We have reached time limit.
    {
        FakeLLRealtimeSegmentDataManager segmentDataManager = createFakeSegmentManager();
        segmentDataManager._state.set(segmentDataManager,
                LLRealtimeSegmentDataManager.State.CONSUMING_TO_ONLINE);
        final long endTime = _timeNow + 10;
        segmentDataManager.setConsumeEndTime(endTime);
        final long finalOffset = _startOffset + 100;
        segmentDataManager.setFinalOffset(finalOffset);
        segmentDataManager.setCurrentOffset(finalOffset - 1);
        _timeNow = endTime - 1;
        Assert.assertFalse(segmentDataManager.invokeEndCriteriaReached());
        _timeNow = endTime;
        Assert.assertTrue(segmentDataManager.invokeEndCriteriaReached());
    }
}

From source file:com.ebay.cloud.cms.query.service.QueryPaginationByIdTest.java

/**
 * Count doesn't support join//from  w ww .  ja v a2  s  .  c o  m
 */
@Ignore
@Test
public void testQueryIter_count() {
    EntityContext raptorEntityContext = new EntityContext();
    raptorEntityContext.setSourceIp("127.0.0.1");
    for (int i = 0; i < 26; i++) {
        IEntity app = newServiceInstance("service_query_itr_count_");
        entityService.create(app, raptorEntityContext);
    }

    for (int i = 0; i < 16; i++) {
        IEntity app = newApplicationService("app_service_query_itr_count_");
        entityService.create(app, raptorEntityContext);
    }

    String query = "ServiceInstance.appService";
    QueryContext qc = newQueryContext(raptorContext);
    qc.setCountOnly(true);
    qc.setHint(1);
    qc.setAllowFullTableScan(true);
    qc.setLimits(new int[] { 12, 6 });
    IQueryResult result = queryService.query(query, qc);
    Assert.assertFalse(result.hasMoreResults());
}

From source file:com.ibm.jaggr.core.impl.modulebuilder.css.CSSModuleBuilderTest.java

@Test
public void testToRegexp() {
    CSSModuleBuilder builder = new CSSModuleBuilder() {
        @Override/*from w w w  .  j  a  v a  2 s. c o m*/
        public Pattern toRegexp(String filespec) {
            return super.toRegexp(filespec);
        }
    };
    Pattern regexp = builder.toRegexp("test?.*");
    Assert.assertEquals("(^|/)test[^/]\\.[^/]*?$", regexp.toString());
    Assert.assertTrue(regexp.matcher("test1.abc").find());
    Assert.assertFalse(regexp.matcher("test11.abc").find());
    Assert.assertTrue(regexp.matcher("/test1.abc").find());
    Assert.assertTrue(regexp.matcher("/some/path/test1.abc").find());
    regexp = builder.toRegexp("test/*/hello@$!.???");
    Assert.assertEquals("(^|/)test/[^/]*?/hello@\\$!\\.[^/][^/][^/]$", regexp.toString());
    Assert.assertTrue(regexp.matcher("test/abc/hello@$!.foo").find());
    Assert.assertTrue(regexp.matcher("/test/xyz/hello@$!.123").find());
    Assert.assertTrue(regexp.matcher("somepath/test/xyz/hello@$!.123").find());
    Assert.assertFalse(regexp.matcher("/test/xyz/hello@$!.ab").find());
    Assert.assertFalse(regexp.matcher("/test/hello@$!.123").find());
    regexp = builder.toRegexp("/a?c");
    Assert.assertEquals("/a[^/]c$", regexp.toString());
}