Java AbsentMatcher类代码示例

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testBackReferences()
{
    // Single matching
    Predicate.Argument argumentA = when(mock(Predicate.Argument.class).backReference()).thenReturn(new Present<>(1)).getMock();
    assertTrue(backReferences(isPresent(1)).matches(
            when(mock(Predicate.class).arguments(any(TransactionContext.class))).thenReturn(new ArrayIterable<>(argumentA)).getMock()));
    // Single non-matching
    assertFalse(backReferences(isPresent(2)).matches(
            when(mock(Predicate.class).arguments(any(TransactionContext.class))).thenReturn(new ArrayIterable<>(argumentA)).getMock()));

    // Multiple
    Predicate.Argument aB = when(mock(Predicate.Argument.class).backReference()).thenReturn(new Present<>(1)).getMock();
    Predicate.Argument aC = when(mock(Predicate.Argument.class).backReference()).thenReturn(Absent.<Integer>absent()).getMock();
    Predicate.Argument aD = when(mock(Predicate.Argument.class).backReference()).thenReturn(new Present<>(3)).getMock();
    assertTrue(backReferences(isPresent(1), AbsentMatcher.<Integer>isAbsent(), isPresent(3)).matches(
            when(mock(Predicate.class).arguments(any(TransactionContext.class))).thenReturn(new ArrayIterable<>(aB, aC, aD)).getMock()));

    // Single with TC
    TransactionContext dummyTc = dummy(TransactionContext.class);
    Predicate.Argument argumentE = when(mock(Predicate.Argument.class).backReference()).thenReturn(new Present<>(1)).getMock();
    assertTrue(backReferences(dummyTc, isPresent(1)).matches(
            when(mock(Predicate.class).arguments(dummyTc)).thenReturn(new ArrayIterable<>(argumentE)).getMock()));
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testSelection() throws Exception
{
    TransactionContext mockTc = failingMock(TransactionContext.class);
    SoftRowReference<CalendarContract.Calendars> dummyReference = dummy(SoftRowReference.class);
    RowSnapshot<CalendarContract.Calendars> mockCalendarRow = failingMock(RowSnapshot.class);

    doReturn(dummyReference).when(mockCalendarRow).reference();
    doReturn(new BackReference<>(dummy(Uri.class), 12)).when(mockTc).resolved(dummyReference);

    assertThat(new CalendarScoped(mockCalendarRow, new EqArg("x", "y")),
            predicateWith(
                    selection(mockTc, "( x = ? ) and ( calendar_id = ? )"),
                    argumentValues(mockTc, "y", "-1"),
                    backReferences(mockTc, AbsentMatcher.<Integer>isAbsent(), isPresent(12))
            ));
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference()
{
    assertThat(new BulkAssert<Object>(dummy(Table.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());

    assertThat(new BulkAssert<Object>(dummy(Table.class), dummy(Predicate.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());

    assertThat(new BulkAssert<Object>(dummy(Table.class), dummy(RowData.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());

    assertThat(new BulkAssert<Object>(dummy(Table.class), dummy(RowData.class), dummy(Predicate.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference()
{
    assertThat(new BulkUpdate<Object>(dummy(Table.class), dummy(RowData.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());

    assertThat(new BulkUpdate<Object>(dummy(Table.class), dummy(RowData.class), dummy(Predicate.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testVirtualReference() throws Exception
{
    RowSnapshot<Object> dummyRowSnapshot = dummy(RowSnapshot.class);

    assertThat(new Delete<>(dummyRowSnapshot).reference(), AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference() throws Exception
{
    Table<Object> mockTable = failingMock(Table.class);

    assertThat(new Insert<Object>(mockTable).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());

    assertThat(new Insert<Object>(mockTable, dummy(RowData.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference()
{
    assertThat(new BulkDelete<Object>(dummy(Table.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());

    assertThat(new BulkDelete<Object>(dummy(Table.class), dummy(Predicate.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void test()
{
    Object mockValue = failingMock(Object.class);
    doReturn("val").when(mockValue).toString();

    Predicate.Argument underTest = new ValueArgument(mockValue);
    assertThat(underTest.value(), is("val"));
    assertThat(underTest.backReference(), AbsentMatcher.<Integer>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void test_whenColumnValueIsAbsent_shouldBeAbsent()
{
    RowDataSnapshot<Tasks> mockData = failingMock(RowDataSnapshot.class);
    doReturn(absent()).when(mockData).data(eq(Tasks.DTSTART), any());

    assertThat(new TaskDateTime(Tasks.DTSTART, mockData), AbsentMatcher.<DateTime>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void test_whenDueIsAbsent_startIsAbsent_durationIsAbsent_shouldBeAbsent()
{
    RowDataSnapshot<Tasks> mockData = failingMock(RowDataSnapshot.class);
    doReturn(absent()).when(mockData).data(eq(Tasks.DUE), any());
    doReturn(absent()).when(mockData).data(eq(Tasks.DTSTART), any());
    doReturn(absent()).when(mockData).data(eq(Tasks.DURATION), any());
    doReturn(new Present<>(false)).when(mockData).data(eq(Tasks.IS_ALLDAY), any());
    doReturn(new Present<>(TimeZone.getTimeZone("UTC"))).when(mockData).data(eq(Tasks.TZ), any());

    assertThat(new EffectiveDueDate(mockData), AbsentMatcher.<DateTime>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void test_whenDueIsAbsent_startIsPresent_durationIsAbsent_shouldBeAbsent()
{
    RowDataSnapshot<Tasks> mockData = failingMock(RowDataSnapshot.class);
    doReturn(absent()).when(mockData).data(eq(Tasks.DUE), any());
    doReturn(new Present<>(234234)).when(mockData).data(eq(Tasks.DTSTART), any());
    doReturn(absent()).when(mockData).data(eq(Tasks.DURATION), any());
    doReturn(new Present<>(false)).when(mockData).data(eq(Tasks.IS_ALLDAY), any());
    doReturn(new Present<>(TimeZone.getTimeZone("UTC"))).when(mockData).data(eq(Tasks.TZ), any());

    assertThat(new EffectiveDueDate(mockData), AbsentMatcher.<DateTime>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void test_whenDueIsAbsent_startIsAbsent_durationIsPresent_shouldBeAbsent()
{
    RowDataSnapshot<Tasks> mockData = failingMock(RowDataSnapshot.class);
    doReturn(absent()).when(mockData).data(eq(Tasks.DUE), any());
    doReturn(absent()).when(mockData).data(eq(Tasks.DTSTART), any());
    doReturn(new Present<>(Duration.parse("P7W"))).when(mockData).data(eq(Tasks.DURATION), any());
    doReturn(new Present<>(false)).when(mockData).data(eq(Tasks.IS_ALLDAY), any());
    doReturn(new Present<>(TimeZone.getTimeZone("UTC"))).when(mockData).data(eq(Tasks.TZ), any());

    assertThat(new EffectiveDueDate(mockData), AbsentMatcher.<DateTime>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference() throws Exception
{
    assertThat(new Assert<Object>(dummy(RowSnapshot.class), dummy(RowData.class)).reference(),
            AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference() throws Exception
{
    assertThat(new RawDelete<>(dummy(Uri.class)).reference(), AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}
 

import org.dmfs.jems.hamcrest.matchers.AbsentMatcher; //导入依赖的package包/类
@Test
public void testReference() throws Exception
{
    assertThat(new RawAssert<>(dummy(Uri.class)).reference(), AbsentMatcher.<SoftRowReference<Object>>isAbsent());
}