Java BuildConfig.DEBUG属性代码示例

public ArrayList<ScheduleItem> getScheduleData(long start, long end) {
    // get sessions in my schedule and blocks, starting anytime in the conference day
    ArrayList<ScheduleItem> mutableItems = new ArrayList<ScheduleItem>();
    ArrayList<ScheduleItem> immutableItems = new ArrayList<ScheduleItem>();
    addBlocks(start, end, mutableItems, immutableItems);
    addSessions(start, end, mutableItems, immutableItems);

    ArrayList<ScheduleItem> result = ScheduleItemHelper.processItems(mutableItems, immutableItems);
    if (BuildConfig.DEBUG || Log.isLoggable(TAG, Log.DEBUG)) {
        ScheduleItem previous = null;
        for (ScheduleItem item: result) {
            if ((item.flags & ScheduleItem.FLAG_CONFLICTS_WITH_PREVIOUS) != 0) {
                Log.d(TAG, "Schedule Item conflicts with previous. item="+item+" previous="+previous);
            }
            previous = item;
        }
    }

    setSessionCounters(result, start, end);
    return result;
}
 

/**
 * Initialize the analytics tracker in use by the application. This should only be called
 * once, when the TOS is signed. The {@code applicationContext} parameter MUST be the
 * application context or an object leak could occur.
 */
private static synchronized void initializeAnalyticsTracker(Context applicationContext) {
    sAppContext = applicationContext;
    if (mTracker == null) {
        int useProfile;
        if (BuildConfig.DEBUG) {
            LOGD(TAG, "Analytics manager using DEBUG ANALYTICS PROFILE.");
            useProfile = R.xml.analytics_debug;
        } else {
            useProfile = R.xml.analytics_release;
        }

        try {
            mTracker = GoogleAnalytics.getInstance(applicationContext).newTracker(useProfile);
        } catch (Exception e) {
            // If anything goes wrong, force an opt-out of tracking. It's better to accidentally
            // protect privacy than accidentally collect data.
            setAnalyticsEnabled(false);
        }
    }
}
 

@Test
public void isSessionOngoing_OngoingSession_ReturnsTrue() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in progress
        initMockCursorWithOngoingSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is ongoing
        assertThat(spyModel.isSessionOngoing(), is(true));
    }
}
 

@Test
public void isSessionOngoing_SessionNotStarted_ReturnsFalse() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in future
        initMockCursorWithNotStartedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is not ongoing
        assertThat(spyModel.isSessionOngoing(), is(false));
    }
}
 

@Test
public void isSessionOngoing_SessionEnded_ReturnsFalse() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session that has ended
        initMockCursorWithEndedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is not ongoing
        assertThat(spyModel.isSessionOngoing(), is(false));
    }
}
 

@Test
public void hasSessionStarted_OnGoingSession_ReturnsTrue() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in progress
        initMockCursorWithOngoingSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session has started
        assertThat(spyModel.hasSessionStarted(), is(true));
    }
}
 

@Test
public void hasSessionStarted_SessionNotStarted_ReturnsFalse() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in future
        initMockCursorWithNotStartedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session has not started
        assertThat(spyModel.hasSessionStarted(), is(false));
    }
}
 

@Test
public void hasSessionStarted_SessionEnded_ReturnsTrue() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session that has ended
        initMockCursorWithEndedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session has started
        assertThat(spyModel.hasSessionStarted(), is(true));
    }
}
 

@Test
public void hasSessionEnded_SessionNotStarted_ReturnsFalse() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in progress
        initMockCursorWithNotStartedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session has not ended
        assertThat(spyModel.hasSessionEnded(), is(false));
    }
}
 

@Test
public void hasSessionEnded_OngoingSession_ReturnsFalse() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in progress
        initMockCursorWithOngoingSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session has not ended
        assertThat(spyModel.hasSessionEnded(), is(false));
    }
}
 

@Test
public void hasSessionEnded_SessionEnded_ReturnsTrue() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session that has ended
        initMockCursorWithEndedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session has ended
        assertThat(spyModel.hasSessionEnded(), is(true));
    }
}
 

@Test
public void minutesSinceSessionStarted_SessionNotStarted_ReturnsCorrectMinutes() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session not started
        initMockCursorWithNotStartedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is ongoing
        assertThat(spyModel.minutesSinceSessionStarted(), is(0l));
    }
}
 

@Test
public void isSessionReadyForFeedback_SessionEnded_ReturnsTrue() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session that has ended
        initMockCursorWithEndedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is ongoing
        assertThat(spyModel.isSessionReadyForFeedback(), is(true));
    }
}
 

@Test
public void minutesUntilSessionStarts_SessionNotStarted_ReturnsCorrectMinutes() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session starting in 1 hour
        initMockCursorWithNotStartedSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is ongoing
        assertThat(spyModel.minutesUntilSessionStarts(), is(60l));
    }
}
 

@Test
public void minutesUntilSessionStarts_SessionStarted_ReturnsCorrectMinutes() {
    // Only possible to mock current time in debug build
    if (BuildConfig.DEBUG) {
        // Given a mock cursor for a session in progress
        initMockCursorWithOngoingSession(mMockCursor);
        SessionDetailModel spyModel = setSpyModelForSessionLoading();

        // When session is loaded
        spyModel.readDataFromCursor(mMockCursor,
                SessionDetailModel.SessionDetailQueryEnum.SESSIONS);

        // Then session is ongoing
        assertThat(spyModel.minutesUntilSessionStarts(), is(0l));
    }
}