Java LogLevel.ALL属性代码示例

/**
 * Ensures, that a {@link NullPointerException} is thrown by the method, which allows to
 * retrieve the state of a specific item, if the item is null.
 */
public final void testGetItemStateThrowsExceptionWhenItemIsNull() {
    try {
        AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
                new AbstractItemStateListAdapterImplementation(getContext(),
                        new ListDecoratorImplementation(), LogLevel.ALL,
                        new ArrayList<Item<Object>>(), false, true,
                        new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                        new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                        new LinkedHashSet<ListAdapterListener<Object>>(),
                        new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                        new LinkedHashSet<ListItemStateListener<Object>>());
        abstractItemStateListAdapter.getItemState(null);
        Assert.fail();
    } catch (NullPointerException e) {

    }
}
 

/**
 * Tests the functionality of the method, which allows to trigger the state of the item, which
 * belongs to a specific index, if the item's state is not already the maximum state.
 */
@SuppressWarnings("unchecked")
public final void testTriggerItemStateByIndexWhenStateIsNotMaxState() {
    Object item = new Object();
    DataSetObserver dataSetObserver = new DataSetObserver();
    ListItemStateListener<Object> listItemStateListener = mock(ListItemStateListener.class);
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    abstractItemStateListAdapter.registerDataSetObserver(dataSetObserver);
    abstractItemStateListAdapter.addItemStateListener(listItemStateListener);
    abstractItemStateListAdapter.addItem(item);
    dataSetObserver.reset();
    int previousState = abstractItemStateListAdapter.triggerItemState(0);
    assertEquals(0, previousState);
    assertEquals(1, abstractItemStateListAdapter.getItemState(0));
    verify(listItemStateListener, times(1))
            .onItemStateChanged(abstractItemStateListAdapter, item, 0, 1);
    assertTrue(dataSetObserver.hasOnChangedBeenCalled());
}
 

/**
 * Ensures, that an {@link IndexOutOfBoundsException} is thrown by the method, which allows to
 * retrieve the unfiltered index, which corresponds to a specific filtered index, if the index
 * is less than 0.
 */
public final void testGetUnfilteredIndexThrowsExceptionWhenIndexIsLessThanZero() {
    try {
        AbstractFilterableListAdapterImplementation abstractFilterableListAdapter =
                new AbstractFilterableListAdapterImplementation(getContext(),
                        new ListDecoratorImplementation(), LogLevel.ALL,
                        new ArrayList<Item<FilterableImplementation>>(), false, true,
                        new LinkedHashSet<ListAdapterItemClickListener<FilterableImplementation>>(),
                        new LinkedHashSet<ListAdapterItemLongClickListener<FilterableImplementation>>(),
                        new LinkedHashSet<ListAdapterListener<FilterableImplementation>>(),
                        new LinkedHashSet<ListEnableStateListener<FilterableImplementation>>(),
                        1, false,
                        new LinkedHashSet<ListItemStateListener<FilterableImplementation>>(),
                        new LinkedHashSet<ListSortingListener<FilterableImplementation>>(),
                        new LinkedHashSet<ListFilterListener<FilterableImplementation>>(),
                        new LinkedHashSet<AppliedFilter<FilterableImplementation>>());
        abstractFilterableListAdapter.getUnfilteredIndex(-1);
        Assert.fail();
    } catch (IndexOutOfBoundsException e) {

    }
}
 

/**
 * Tests the functionality of the method, which allows to trigger the state of a specific item,
 * if the item's state is not already the maximum state.
 */
@SuppressWarnings("unchecked")
public final void testTriggerItemStateWhenStateIsNotMaxState() {
    Object item = new Object();
    DataSetObserver dataSetObserver = new DataSetObserver();
    ListItemStateListener<Object> listItemStateListener = mock(ListItemStateListener.class);
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    abstractItemStateListAdapter.registerDataSetObserver(dataSetObserver);
    abstractItemStateListAdapter.addItemStateListener(listItemStateListener);
    abstractItemStateListAdapter.addItem(item);
    dataSetObserver.reset();
    int previousState = abstractItemStateListAdapter.triggerItemState(item);
    assertEquals(0, previousState);
    assertEquals(1, abstractItemStateListAdapter.getItemState(item));
    verify(listItemStateListener, times(1))
            .onItemStateChanged(abstractItemStateListAdapter, item, 0, 1);
    assertTrue(dataSetObserver.hasOnChangedBeenCalled());
}
 

/**
 * Tests the functionality of the method, which allows to retrieve the number of items, which
 * have a specific state.
 */
public final void testGetItemStateCountWithSpecificState() {
    Object item1 = new Object();
    Object item2 = new Object();
    Object item3 = new Object();
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    abstractItemStateListAdapter.addItem(item1);
    abstractItemStateListAdapter.addItem(item2);
    abstractItemStateListAdapter.addItem(item3);
    abstractItemStateListAdapter.setItemState(item2, 1);
    assertEquals(2, abstractItemStateListAdapter.getItemStateCount(0));
}
 

/**
 * Tests, if all properties are set correctly by the constructor.
 */
public final void testConstructor() {
    boolean selectItemOnClick = true;
    Set<ListSelectionListener<Object>> selectionListeners =
            new LinkedHashSet<ListSelectionListener<Object>>();
    AbstractSelectableListAdapterImplementation abstractSelectableListAdapter =
            new AbstractSelectableListAdapterImplementation(getContext(),
                    new SelectableListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 1, false,
                    new LinkedHashSet<ListItemStateListener<Object>>(),
                    new LinkedHashSet<ListSortingListener<Object>>(),
                    new LinkedHashSet<ListFilterListener<Object>>(),
                    new LinkedHashSet<AppliedFilter<Object>>(), selectItemOnClick,
                    selectionListeners);
    assertEquals(selectItemOnClick, abstractSelectableListAdapter.isItemSelectedOnClick());
    assertEquals(selectionListeners, abstractSelectableListAdapter.getSelectionListeners());
}
 

/**
 * Tests the functionality of the method, which allows to retrieve a collection, which contains
 * all items, which have a specific state.
 */
public final void testGetItemsWithSpecificState() {
    Object item1 = new Object();
    Object item2 = new Object();
    Object item3 = new Object();
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    abstractItemStateListAdapter.addItem(item1);
    abstractItemStateListAdapter.addItem(item2);
    abstractItemStateListAdapter.addItem(item3);
    abstractItemStateListAdapter.setItemState(item2, 1);
    Collection<Object> items = abstractItemStateListAdapter.getItemsWithSpecificState(0);
    assertEquals(2, items.size());
    Iterator<Object> iterator = items.iterator();
    assertEquals(item1, iterator.next());
    assertEquals(item3, iterator.next());
}
 

/**
 * Ensures, that an {@link NullPointerException} is thrown by the method, which allows to set
 * the state of a specific item, if the item is null.
 */
public final void testSetItemStateThrowsExceptionWhenItemIsNull() {
    try {
        AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
                new AbstractItemStateListAdapterImplementation(getContext(),
                        new ListDecoratorImplementation(), LogLevel.ALL,
                        new ArrayList<Item<Object>>(), false, true,
                        new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                        new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                        new LinkedHashSet<ListAdapterListener<Object>>(),
                        new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                        new LinkedHashSet<ListItemStateListener<Object>>());
        abstractItemStateListAdapter.setItemState(null, 0);
        Assert.fail();
    } catch (NullPointerException e) {

    }
}
 

/**
 * Tests the functionality of the method, which allows to retrieve the index of the last item,
 * which has a specific state.
 */
public final void testGetLastIndexWithSpecificState() {
    Object item1 = new Object();
    Object item2 = new Object();
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    abstractItemStateListAdapter.addItem(item1);
    abstractItemStateListAdapter.addItem(item2);
    assertEquals(1, abstractItemStateListAdapter.getLastIndexWithSpecificState(0));
}
 

/**
 * Tests the functionality of the method, which allows to set the enable state of the item,
 * which belongs to a specific index, if the item is already enabled.
 */
@SuppressWarnings("unchecked")
public final void testSetEnabledByIndexWhenItemIsAlreadyEnabled() {
    Object item = new Object();
    DataSetObserver dataSetObserver = new DataSetObserver();
    ListEnableStateListener<Object> listEnableStateListener =
            mock(ListEnableStateListener.class);
    AbstractEnableStateListAdapterImplementation abstractEnableStateListAdapter =
            new AbstractEnableStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>());
    abstractEnableStateListAdapter.registerDataSetObserver(dataSetObserver);
    abstractEnableStateListAdapter.addEnableStateListener(listEnableStateListener);
    abstractEnableStateListAdapter.addItem(item);
    dataSetObserver.reset();
    abstractEnableStateListAdapter.setEnabled(0, true);
    assertTrue(abstractEnableStateListAdapter.isEnabled(0));
    verify(listEnableStateListener, times(0))
            .onItemDisabled(abstractEnableStateListAdapter, item, 0);
    assertFalse(dataSetObserver.hasOnChangedBeenCalled());
}
 

/**
 * Ensures, that a {@link NullPointerException} is thrown, if the set, which contains the
 * sorting listeners, which is passed to the constructor, is null.
 */
public final void testConstructorThrowsExceptionWhenSortingListenersIsNull() {
    try {
        new AbstractSortableListAdapterImplementation(getContext(),
                new ListDecoratorImplementation(), LogLevel.ALL,
                new ArrayList<Item<ComparableImplementation>>(), false, true,
                new LinkedHashSet<ListAdapterItemClickListener<ComparableImplementation>>(),
                new LinkedHashSet<ListAdapterItemLongClickListener<ComparableImplementation>>(),
                new LinkedHashSet<ListAdapterListener<ComparableImplementation>>(),
                new LinkedHashSet<ListEnableStateListener<ComparableImplementation>>(), 1,
                false, new LinkedHashSet<ListItemStateListener<ComparableImplementation>>(),
                null);
        Assert.fail();
    } catch (NullPointerException e) {

    }
}
 

/**
 * Ensures, that an {@link IllegalArgumentException} is thrown by the method, which allows to
 * set the states of all items to a specific state, if the state is less than 0.
 */
public final void testSetAllItemStatesThrowsExceptionWhenStateIsLessThanZero() {
    try {
        AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
                new AbstractItemStateListAdapterImplementation(getContext(),
                        new ListDecoratorImplementation(), LogLevel.ALL,
                        new ArrayList<Item<Object>>(), false, true,
                        new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                        new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                        new LinkedHashSet<ListAdapterListener<Object>>(),
                        new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                        new LinkedHashSet<ListItemStateListener<Object>>());
        abstractItemStateListAdapter.setAllItemStates(-1);
        Assert.fail();
    } catch (IllegalArgumentException e) {

    }
}
 

/**
 * Tests the functionality of the method, which allows to retrieve the first item, which has a
 * specific state, if no item has the state.
 */
public final void testGetFirstItemWithSpecificStateWhenNoItemHasState() {
    Object item1 = new Object();
    Object item2 = new Object();
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    abstractItemStateListAdapter.addItem(item1);
    abstractItemStateListAdapter.addItem(item2);
    assertNull(abstractItemStateListAdapter.getFirstItemWithSpecificState(1));
}
 

/**
 * Ensures, that the order of the adapter's items is invalidated, when an item is added to the
 * adapter.
 */
public final void testAddItemInvalidatesOrder() {
    AbstractSortableListAdapterImplementation abstractSortableListAdapter =
            new AbstractSortableListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<ComparableImplementation>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<ComparableImplementation>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<ComparableImplementation>>(),
                    new LinkedHashSet<ListAdapterListener<ComparableImplementation>>(),
                    new LinkedHashSet<ListEnableStateListener<ComparableImplementation>>(), 1,
                    false, new LinkedHashSet<ListItemStateListener<ComparableImplementation>>(),
                    new LinkedHashSet<ListSortingListener<ComparableImplementation>>());
    ComparableImplementation item1 = new ComparableImplementation(2);
    ComparableImplementation item2 = new ComparableImplementation(1);
    abstractSortableListAdapter.addItem(item1);
    abstractSortableListAdapter.addItem(item2);
    abstractSortableListAdapter.sort();
    assertEquals(Order.ASCENDING, abstractSortableListAdapter.getOrder());
    abstractSortableListAdapter.addItem(new ComparableImplementation(0));
    assertNull(abstractSortableListAdapter.getOrder());
}
 

/**
 * Tests the functionality of the method, which allows to retrieve the first item, which has a
 * specific state, if the adapter is empty.
 */
public final void testGetFirstItemWithSpecificStateWhenAdapterIsEmpty() {
    AbstractItemStateListAdapterImplementation abstractItemStateListAdapter =
            new AbstractItemStateListAdapterImplementation(getContext(),
                    new ListDecoratorImplementation(), LogLevel.ALL,
                    new ArrayList<Item<Object>>(), false, true,
                    new LinkedHashSet<ListAdapterItemClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterItemLongClickListener<Object>>(),
                    new LinkedHashSet<ListAdapterListener<Object>>(),
                    new LinkedHashSet<ListEnableStateListener<Object>>(), 2, false,
                    new LinkedHashSet<ListItemStateListener<Object>>());
    assertNull(abstractItemStateListAdapter.getFirstItemWithSpecificState(0));
}