| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.widget.cts; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| import static org.mockito.Mockito.any; |
| import static org.mockito.Mockito.eq; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.reset; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.verifyZeroInteractions; |
| |
| import android.app.Instrumentation; |
| import android.content.Context; |
| import android.database.DataSetObserver; |
| import android.graphics.Canvas; |
| import android.graphics.drawable.BitmapDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.os.Parcelable; |
| import android.util.AttributeSet; |
| import android.util.Xml; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.ExpandableListAdapter; |
| import android.widget.ExpandableListView; |
| import android.widget.ListAdapter; |
| import android.widget.TextView; |
| import android.widget.cts.util.ExpandableListScenario; |
| |
| import androidx.test.InstrumentationRegistry; |
| import androidx.test.annotation.UiThreadTest; |
| import androidx.test.filters.MediumTest; |
| import androidx.test.rule.ActivityTestRule; |
| import androidx.test.runner.AndroidJUnit4; |
| |
| import com.android.compatibility.common.util.WidgetTestUtils; |
| import com.android.compatibility.common.util.WindowUtil; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.xmlpull.v1.XmlPullParser; |
| |
| @MediumTest |
| @RunWith(AndroidJUnit4.class) |
| public class ExpandableListViewTest { |
| private Instrumentation mInstrumentation; |
| private ExpandableListScenario mActivity; |
| private ExpandableListView mExpandableListView; |
| |
| @Rule |
| public ActivityTestRule<ExpandableList> mActivityRule = |
| new ActivityTestRule<>(ExpandableList.class); |
| |
| @Before |
| public void setup() { |
| mInstrumentation = InstrumentationRegistry.getInstrumentation(); |
| mActivity = mActivityRule.getActivity(); |
| WindowUtil.waitForFocus(mActivity); |
| mExpandableListView = mActivity.getExpandableListView(); |
| } |
| |
| @Test |
| public void testConstructor() { |
| new ExpandableListView(mActivity); |
| |
| new ExpandableListView(mActivity, null); |
| |
| new ExpandableListView(mActivity, null, android.R.attr.expandableListViewStyle); |
| |
| new ExpandableListView(mActivity, null, 0, |
| android.R.style.Widget_DeviceDefault_ExpandableListView); |
| |
| new ExpandableListView(mActivity, null, 0, |
| android.R.style.Widget_DeviceDefault_Light_ExpandableListView); |
| |
| new ExpandableListView(mActivity, null, 0, |
| android.R.style.Widget_Material_ExpandableListView); |
| |
| new ExpandableListView(mActivity, null, 0, |
| android.R.style.Widget_Material_Light_ExpandableListView); |
| |
| XmlPullParser parser = |
| mActivity.getResources().getXml(R.layout.expandablelistview_layout); |
| AttributeSet attrs = Xml.asAttributeSet(parser); |
| new ExpandableListView(mActivity, attrs); |
| new ExpandableListView(mActivity, attrs, 0); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorWithNullContext1() { |
| new ExpandableListView(null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorWithNullContext2() { |
| new ExpandableListView(null, null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorWithNullContext3() { |
| new ExpandableListView(null, null, 0); |
| } |
| |
| @Test |
| public void testSetChildDivider() { |
| Drawable drawable = mActivity.getResources().getDrawable(R.drawable.scenery); |
| mExpandableListView.setChildDivider(drawable); |
| } |
| |
| @Test(expected=RuntimeException.class) |
| public void testSetAdapterOfWrongType() { |
| mExpandableListView.setAdapter((ListAdapter) null); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testGetAdapter() { |
| assertNull(mExpandableListView.getAdapter()); |
| |
| ExpandableListAdapter expandableAdapter = new MockExpandableListAdapter(); |
| mExpandableListView.setAdapter(expandableAdapter); |
| assertNotNull(mExpandableListView.getAdapter()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessExpandableListAdapter() { |
| ExpandableListAdapter expandableAdapter = new MockExpandableListAdapter(); |
| |
| assertNull(mExpandableListView.getExpandableListAdapter()); |
| mExpandableListView.setAdapter(expandableAdapter); |
| assertSame(expandableAdapter, mExpandableListView.getExpandableListAdapter()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testPerformItemClick() { |
| assertFalse(mExpandableListView.performItemClick(null, 100, 99)); |
| |
| ExpandableListView.OnItemClickListener mockOnItemClickListener = |
| mock(ExpandableListView.OnItemClickListener.class); |
| mExpandableListView.setOnItemClickListener(mockOnItemClickListener); |
| assertTrue(mExpandableListView.performItemClick(null, 100, 99)); |
| verify(mockOnItemClickListener, times(1)).onItemClick(eq(mExpandableListView), |
| any(), eq(100), eq(99L)); |
| } |
| |
| @Test |
| public void testSetOnItemClickListener() { |
| ExpandableListView.OnItemClickListener mockOnItemClickListener = |
| mock(ExpandableListView.OnItemClickListener.class); |
| |
| assertNull(mExpandableListView.getOnItemClickListener()); |
| mExpandableListView.setOnItemClickListener(mockOnItemClickListener); |
| assertSame(mockOnItemClickListener, mExpandableListView.getOnItemClickListener()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testExpandGroup() { |
| ExpandableListAdapter expandableAdapter = new MockExpandableListAdapter(); |
| mExpandableListView.setAdapter(expandableAdapter); |
| |
| ExpandableListView.OnGroupExpandListener mockOnGroupExpandListener = |
| mock(ExpandableListView.OnGroupExpandListener.class); |
| mExpandableListView.setOnGroupExpandListener(mockOnGroupExpandListener); |
| |
| verifyZeroInteractions(mockOnGroupExpandListener); |
| |
| assertTrue(mExpandableListView.expandGroup(0)); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(0); |
| assertTrue(mExpandableListView.isGroupExpanded(0)); |
| |
| reset(mockOnGroupExpandListener); |
| assertFalse(mExpandableListView.expandGroup(0)); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(0); |
| assertTrue(mExpandableListView.isGroupExpanded(0)); |
| |
| reset(mockOnGroupExpandListener); |
| assertTrue(mExpandableListView.expandGroup(1)); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(1); |
| assertTrue(mExpandableListView.isGroupExpanded(1)); |
| |
| reset(mockOnGroupExpandListener); |
| assertFalse(mExpandableListView.expandGroup(1)); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(1); |
| assertTrue(mExpandableListView.isGroupExpanded(1)); |
| |
| reset(mockOnGroupExpandListener); |
| mExpandableListView.setAdapter((ExpandableListAdapter) null); |
| try { |
| mExpandableListView.expandGroup(0); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| @Test |
| public void testExpandGroupSmooth() throws Throwable { |
| mActivityRule.runOnUiThread( |
| () -> mExpandableListView.setAdapter(new MockExpandableListAdapter())); |
| |
| ExpandableListView.OnGroupExpandListener mockOnGroupExpandListener = |
| mock(ExpandableListView.OnGroupExpandListener.class); |
| mExpandableListView.setOnGroupExpandListener(mockOnGroupExpandListener); |
| |
| verifyZeroInteractions(mockOnGroupExpandListener); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mExpandableListView, |
| () -> assertTrue(mExpandableListView.expandGroup(0, true))); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(0); |
| assertTrue(mExpandableListView.isGroupExpanded(0)); |
| |
| reset(mockOnGroupExpandListener); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mExpandableListView, |
| () -> assertFalse(mExpandableListView.expandGroup(0, true))); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(0); |
| assertTrue(mExpandableListView.isGroupExpanded(0)); |
| |
| reset(mockOnGroupExpandListener); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mExpandableListView, |
| () -> assertTrue(mExpandableListView.expandGroup(1, true))); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(1); |
| assertTrue(mExpandableListView.isGroupExpanded(1)); |
| |
| reset(mockOnGroupExpandListener); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mExpandableListView, |
| () -> assertFalse(mExpandableListView.expandGroup(1, true))); |
| verify(mockOnGroupExpandListener, times(1)).onGroupExpand(1); |
| assertTrue(mExpandableListView.isGroupExpanded(1)); |
| |
| reset(mockOnGroupExpandListener); |
| mActivityRule.runOnUiThread(() -> { |
| mExpandableListView.setAdapter((ExpandableListAdapter) null); |
| try { |
| mExpandableListView.expandGroup(0); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| } |
| }); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testCollapseGroup() { |
| ExpandableListAdapter expandableAdapter = new MockExpandableListAdapter(); |
| mExpandableListView.setAdapter(expandableAdapter); |
| |
| ExpandableListView.OnGroupCollapseListener mockOnGroupCollapseListener = |
| mock(ExpandableListView.OnGroupCollapseListener.class); |
| mExpandableListView.setOnGroupCollapseListener(mockOnGroupCollapseListener); |
| |
| verifyZeroInteractions(mockOnGroupCollapseListener); |
| assertFalse(mExpandableListView.collapseGroup(0)); |
| verify(mockOnGroupCollapseListener, times(1)).onGroupCollapse(0); |
| assertFalse(mExpandableListView.isGroupExpanded(0)); |
| |
| reset(mockOnGroupCollapseListener); |
| mExpandableListView.expandGroup(0); |
| assertTrue(mExpandableListView.collapseGroup(0)); |
| verify(mockOnGroupCollapseListener, times(1)).onGroupCollapse(0); |
| assertFalse(mExpandableListView.isGroupExpanded(0)); |
| |
| reset(mockOnGroupCollapseListener); |
| assertFalse(mExpandableListView.collapseGroup(1)); |
| verify(mockOnGroupCollapseListener, times(1)).onGroupCollapse(1); |
| assertFalse(mExpandableListView.isGroupExpanded(1)); |
| |
| reset(mockOnGroupCollapseListener); |
| mExpandableListView.setAdapter((ExpandableListAdapter) null); |
| try { |
| mExpandableListView.collapseGroup(0); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetOnGroupClickListener() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| ExpandableListView.OnGroupClickListener mockOnGroupClickListener = |
| mock(ExpandableListView.OnGroupClickListener.class); |
| |
| mExpandableListView.setOnGroupClickListener(mockOnGroupClickListener); |
| verifyZeroInteractions(mockOnGroupClickListener); |
| |
| mExpandableListView.performItemClick(null, 0, 0); |
| verify(mockOnGroupClickListener, times(1)).onGroupClick(eq(mExpandableListView), |
| any(), eq(0), eq(0L)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetOnChildClickListener() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| ExpandableListView.OnChildClickListener mockOnChildClickListener = |
| mock(ExpandableListView.OnChildClickListener.class); |
| |
| mExpandableListView.setOnChildClickListener(mockOnChildClickListener); |
| verifyZeroInteractions(mockOnChildClickListener); |
| |
| // first let the list expand |
| mExpandableListView.expandGroup(0); |
| // click on the child list of the first group |
| mExpandableListView.performItemClick(null, 1, 0); |
| verify(mockOnChildClickListener, times(1)).onChildClick(eq(mExpandableListView), |
| any(), eq(0), eq(0), eq(0L)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testGetExpandableListPosition() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| assertEquals(0, mExpandableListView.getExpandableListPosition(0)); |
| |
| // Group 0 is not expanded, position 1 is invalid |
| assertEquals(ExpandableListView.PACKED_POSITION_VALUE_NULL, |
| mExpandableListView.getExpandableListPosition(1)); |
| |
| // Position 1 becomes valid when group 0 is expanded |
| mExpandableListView.expandGroup(0); |
| assertEquals(ExpandableListView.getPackedPositionForChild(0, 0), |
| mExpandableListView.getExpandableListPosition(1)); |
| |
| // Position 2 is still invalid (only one child). |
| assertEquals(ExpandableListView.PACKED_POSITION_VALUE_NULL, |
| mExpandableListView.getExpandableListPosition(2)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testGetFlatListPosition() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| try { |
| mExpandableListView.getFlatListPosition(ExpandableListView.PACKED_POSITION_VALUE_NULL); |
| } catch (NullPointerException e) { |
| } |
| assertEquals(0, mExpandableListView.getFlatListPosition( |
| ExpandableListView.PACKED_POSITION_TYPE_CHILD<<32)); |
| // 0x8000000100000000L means this is a child and group position is 1. |
| assertEquals(1, mExpandableListView.getFlatListPosition(0x8000000100000000L)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testGetSelectedPosition() { |
| assertEquals(ExpandableListView.PACKED_POSITION_VALUE_NULL, |
| mExpandableListView.getSelectedPosition()); |
| |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| mExpandableListView.setSelectedGroup(0); |
| assertEquals(0, mExpandableListView.getSelectedPosition()); |
| |
| mExpandableListView.setSelectedGroup(1); |
| assertEquals(0, mExpandableListView.getSelectedPosition()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testGetSelectedId() { |
| assertEquals(-1, mExpandableListView.getSelectedId()); |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| mExpandableListView.setSelectedGroup(0); |
| assertEquals(0, mExpandableListView.getSelectedId()); |
| |
| mExpandableListView.setSelectedGroup(1); |
| assertEquals(0, mExpandableListView.getSelectedId()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetSelectedGroup() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| mExpandableListView.setSelectedGroup(0); |
| assertEquals(0, mExpandableListView.getSelectedPosition()); |
| |
| mExpandableListView.setSelectedGroup(1); |
| assertEquals(0, mExpandableListView.getSelectedPosition()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetSelectedChild() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| assertTrue(mExpandableListView.setSelectedChild(0, 0, false)); |
| assertTrue(mExpandableListView.setSelectedChild(0, 1, true)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testIsGroupExpanded() { |
| mExpandableListView.setAdapter(new MockExpandableListAdapter()); |
| |
| mExpandableListView.expandGroup(1); |
| assertFalse(mExpandableListView.isGroupExpanded(0)); |
| assertTrue(mExpandableListView.isGroupExpanded(1)); |
| } |
| |
| @Test |
| public void testGetPackedPositionType() { |
| assertEquals(ExpandableListView.PACKED_POSITION_TYPE_NULL, |
| ExpandableListView.getPackedPositionType( |
| ExpandableListView.PACKED_POSITION_VALUE_NULL)); |
| |
| assertEquals(ExpandableListView.PACKED_POSITION_TYPE_GROUP, |
| ExpandableListView.getPackedPositionType(0)); |
| |
| // 0x8000000000000000L is PACKED_POSITION_MASK_TYPE, but it is private, |
| // so we just use its value. |
| assertEquals(ExpandableListView.PACKED_POSITION_TYPE_CHILD, |
| ExpandableListView.getPackedPositionType(0x8000000000000000L)); |
| } |
| |
| @Test |
| public void testGetPackedPositionGroup() { |
| assertEquals(-1, ExpandableListView.getPackedPositionGroup( |
| ExpandableListView.PACKED_POSITION_VALUE_NULL)); |
| |
| assertEquals(0, ExpandableListView.getPackedPositionGroup(0)); |
| |
| // 0x123400000000L means its group position is 0x1234 |
| assertEquals(0x1234, ExpandableListView.getPackedPositionGroup(0x123400000000L)); |
| |
| // 0x7FFFFFFF00000000L means its group position is 0x7FFFFFFF |
| assertEquals(0x7FFFFFFF, ExpandableListView.getPackedPositionGroup(0x7FFFFFFF00000000L)); |
| } |
| |
| @Test |
| public void testGetPackedPositionChild() { |
| assertEquals(-1, ExpandableListView.getPackedPositionChild( |
| ExpandableListView.PACKED_POSITION_VALUE_NULL)); |
| |
| assertEquals(-1, ExpandableListView.getPackedPositionChild(1)); |
| |
| // 0x8000000000000000L means its child position is 0 |
| assertEquals(0, ExpandableListView.getPackedPositionChild(0x8000000000000000L)); |
| |
| // 0x80000000ffffffffL means its child position is 0xffffffff |
| assertEquals(0xffffffff, ExpandableListView.getPackedPositionChild(0x80000000ffffffffL)); |
| } |
| |
| @Test |
| public void testGetPackedPositionForChild() { |
| assertEquals(0x8000000000000000L, |
| ExpandableListView.getPackedPositionForChild(0, 0)); |
| |
| assertEquals(0xffffffffffffffffL, |
| ExpandableListView.getPackedPositionForChild(Integer.MAX_VALUE, 0xffffffff)); |
| } |
| |
| @Test |
| public void testGetPackedPositionForGroup() { |
| assertEquals(0, ExpandableListView.getPackedPositionForGroup(0)); |
| |
| assertEquals(0x7fffffff00000000L, |
| ExpandableListView.getPackedPositionForGroup(Integer.MAX_VALUE)); |
| } |
| |
| @Test |
| public void testSetChildIndicator() { |
| mExpandableListView.setChildIndicator(null); |
| } |
| |
| @Test |
| public void testSetChildIndicatorBounds() { |
| mExpandableListView.setChildIndicatorBounds(10, 20); |
| } |
| |
| @Test |
| public void testSetChildIndicatorBoundsRelative() { |
| mExpandableListView.setChildIndicatorBoundsRelative(10, 20); |
| } |
| |
| @Test |
| public void testSetGroupIndicator() { |
| Drawable drawable = new BitmapDrawable(); |
| mExpandableListView.setGroupIndicator(drawable); |
| } |
| |
| @Test |
| public void testSetIndicatorBounds() { |
| mExpandableListView.setIndicatorBounds(10, 30); |
| } |
| |
| @Test |
| public void testSetIndicatorBoundsRelative() { |
| mExpandableListView.setIndicatorBoundsRelative(10, 30); |
| } |
| |
| @Test |
| public void testOnSaveInstanceState() { |
| ExpandableListView src = new ExpandableListView(mActivity); |
| Parcelable p1 = src.onSaveInstanceState(); |
| |
| ExpandableListView dest = new ExpandableListView(mActivity); |
| dest.onRestoreInstanceState(p1); |
| Parcelable p2 = dest.onSaveInstanceState(); |
| |
| assertNotNull(p1); |
| assertNotNull(p2); |
| } |
| |
| @Test |
| public void testDispatchDraw() { |
| MockExpandableListView expandableListView = new MockExpandableListView(mActivity); |
| expandableListView.dispatchDraw(new Canvas()); |
| } |
| |
| private class MockExpandableListAdapter implements ExpandableListAdapter { |
| private final LayoutInflater mLayoutInflater; |
| |
| public MockExpandableListAdapter() { |
| mLayoutInflater = LayoutInflater.from(mActivity); |
| } |
| |
| public void registerDataSetObserver(DataSetObserver observer) { |
| } |
| |
| public void unregisterDataSetObserver(DataSetObserver observer) { |
| } |
| |
| public int getGroupCount() { |
| return 1; |
| } |
| |
| public int getChildrenCount(int groupPosition) { |
| switch (groupPosition) { |
| case 0: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| public Object getGroup(int groupPosition) { |
| switch (groupPosition) { |
| case 0: |
| return "Data"; |
| default: |
| return null; |
| } |
| } |
| |
| public Object getChild(int groupPosition, int childPosition) { |
| if (groupPosition == 0 && childPosition == 0) |
| return "child data"; |
| else |
| return null; |
| } |
| |
| public long getGroupId(int groupPosition) { |
| return 0; |
| } |
| |
| public long getChildId(int groupPosition, int childPosition) { |
| return 0; |
| } |
| |
| public boolean hasStableIds() { |
| return true; |
| } |
| |
| public View getGroupView(int groupPosition, boolean isExpanded, |
| View convertView, ViewGroup parent) { |
| TextView result = (TextView) convertView; |
| if (result == null) { |
| result = (TextView) mLayoutInflater.inflate( |
| R.layout.expandablelistview_group, parent, false); |
| } |
| result.setText("Group " + groupPosition); |
| return result; |
| } |
| |
| public View getChildView(int groupPosition, int childPosition, |
| boolean isLastChild, View convertView, ViewGroup parent) { |
| TextView result = (TextView) convertView; |
| if (result == null) { |
| result = (TextView) mLayoutInflater.inflate( |
| R.layout.expandablelistview_child, parent, false); |
| } |
| result.setText("Child " + childPosition); |
| return result; |
| } |
| |
| public boolean isChildSelectable(int groupPosition, int childPosition) { |
| return true; |
| } |
| |
| public boolean areAllItemsEnabled() { |
| return true; |
| } |
| |
| public boolean isEmpty() { |
| return true; |
| } |
| |
| public void onGroupExpanded(int groupPosition) { |
| } |
| |
| public void onGroupCollapsed(int groupPosition) { |
| } |
| |
| public long getCombinedChildId(long groupId, long childId) { |
| return 0; |
| } |
| |
| public long getCombinedGroupId(long groupId) { |
| return 0; |
| } |
| } |
| |
| private class MockExpandableListView extends ExpandableListView { |
| public MockExpandableListView(Context context) { |
| super(context); |
| } |
| |
| public MockExpandableListView(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| |
| public MockExpandableListView(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| } |
| |
| @Override |
| protected void dispatchDraw(Canvas canvas) { |
| super.dispatchDraw(canvas); |
| } |
| } |
| } |