Home | History | Annotate | Download | only in files 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.documentsui.files;
     18 
     19 import static junit.framework.Assert.assertEquals;
     20 import static org.junit.Assert.assertTrue;
     21 
     22 import android.net.Uri;
     23 import android.provider.DocumentsContract.Document;
     24 import android.provider.DocumentsContract.Root;
     25 import android.support.test.filters.SmallTest;
     26 import android.support.test.runner.AndroidJUnit4;
     27 import android.test.AndroidTestCase;
     28 
     29 import com.android.documentsui.R;
     30 import com.android.documentsui.base.DocumentInfo;
     31 import com.android.documentsui.base.RootInfo;
     32 import com.android.documentsui.base.State;
     33 import com.android.documentsui.dirlist.TestContext;
     34 import com.android.documentsui.dirlist.TestData;
     35 import com.android.documentsui.selection.SelectionManager;
     36 import com.android.documentsui.testing.SelectionManagers;
     37 import com.android.documentsui.testing.TestDirectoryDetails;
     38 import com.android.documentsui.testing.TestEnv;
     39 import com.android.documentsui.testing.TestFeatures;
     40 import com.android.documentsui.testing.TestMenu;
     41 import com.android.documentsui.testing.TestMenuInflater;
     42 import com.android.documentsui.testing.TestMenuItem;
     43 import com.android.documentsui.testing.TestScopedPreferences;
     44 import com.android.documentsui.testing.TestSearchViewManager;
     45 import com.android.documentsui.testing.TestSelectionDetails;
     46 
     47 import org.junit.Before;
     48 import org.junit.Test;
     49 import org.junit.runner.RunWith;
     50 
     51 @RunWith(AndroidJUnit4.class)
     52 @SmallTest
     53 public final class MenuManagerTest {
     54 
     55     private TestMenu testMenu;
     56 
     57     /* Directory Context Menu items */
     58     private TestMenuItem dirShare;
     59     private TestMenuItem dirOpen;
     60     private TestMenuItem dirOpenWith;
     61     private TestMenuItem dirCutToClipboard;
     62     private TestMenuItem dirCopyToClipboard;
     63     private TestMenuItem dirPasteFromClipboard;
     64     private TestMenuItem dirCreateDir;
     65     private TestMenuItem dirSelectAll;
     66     private TestMenuItem dirRename;
     67     private TestMenuItem dirDelete;
     68     private TestMenuItem dirViewInOwner;
     69     private TestMenuItem dirOpenInNewWindow;
     70     private TestMenuItem dirPasteIntoFolder;
     71 
     72     /* Root List Context Menu items */
     73     private TestMenuItem rootEjectRoot;
     74     private TestMenuItem rootOpenInNewWindow;
     75     private TestMenuItem rootPasteIntoFolder;
     76     private TestMenuItem rootSettings;
     77 
     78     /* Action Mode menu items */
     79     private TestMenuItem actionModeOpen;
     80     private TestMenuItem actionModeOpenWith;
     81     private TestMenuItem actionModeShare;
     82     private TestMenuItem actionModeDelete;
     83     private TestMenuItem actionModeSelectAll;
     84     private TestMenuItem actionModeCopyTo;
     85     private TestMenuItem actionModeExtractTo;
     86     private TestMenuItem actionModeMoveTo;
     87     private TestMenuItem actionModeCompress;
     88     private TestMenuItem actionModeRename;
     89     private TestMenuItem actionModeViewInOwner;
     90     private TestMenuItem actionModeInspector;
     91 
     92     /* Option Menu items */
     93     private TestMenuItem optionSearch;
     94     private TestMenuItem optionDebug;
     95     private TestMenuItem optionGrid;
     96     private TestMenuItem optionList;
     97     private TestMenuItem optionNewWindow;
     98     private TestMenuItem optionCreateDir;
     99     private TestMenuItem optionSelectAll;
    100     private TestMenuItem optionAdvanced;
    101     private TestMenuItem optionSettings;
    102 
    103     private TestFeatures features;
    104     private TestSelectionDetails selectionDetails;
    105     private TestDirectoryDetails dirDetails;
    106     private TestSearchViewManager testSearchManager;
    107     private TestScopedPreferences preferences;
    108     private RootInfo testRootInfo;
    109     private DocumentInfo testDocInfo;
    110     private State state = new State();
    111     private MenuManager mgr;
    112     private TestActivity activity = TestActivity.create(TestEnv.create());
    113     private SelectionManager selectionManager;
    114 
    115     @Before
    116     public void setUp() {
    117         testMenu = TestMenu.create();
    118         dirShare = testMenu.findItem(R.id.dir_menu_share);
    119         dirOpen = testMenu.findItem(R.id.dir_menu_open);
    120         dirOpenWith = testMenu.findItem(R.id.dir_menu_open_with);
    121         dirCutToClipboard = testMenu.findItem(R.id.dir_menu_cut_to_clipboard);
    122         dirCopyToClipboard = testMenu.findItem(R.id.dir_menu_copy_to_clipboard);
    123         dirPasteFromClipboard = testMenu.findItem(R.id.dir_menu_paste_from_clipboard);
    124         dirCreateDir = testMenu.findItem(R.id.dir_menu_create_dir);
    125         dirSelectAll = testMenu.findItem(R.id.dir_menu_select_all);
    126         dirRename = testMenu.findItem(R.id.dir_menu_rename);
    127         dirDelete = testMenu.findItem(R.id.dir_menu_delete);
    128         dirViewInOwner = testMenu.findItem(R.id.dir_menu_view_in_owner);
    129         dirOpenInNewWindow = testMenu.findItem(R.id.dir_menu_open_in_new_window);
    130         dirPasteIntoFolder = testMenu.findItem(R.id.dir_menu_paste_into_folder);
    131 
    132         rootEjectRoot = testMenu.findItem(R.id.root_menu_eject_root);
    133         rootOpenInNewWindow = testMenu.findItem(R.id.root_menu_open_in_new_window);
    134         rootPasteIntoFolder = testMenu.findItem(R.id.root_menu_paste_into_folder);
    135         rootSettings = testMenu.findItem(R.id.root_menu_settings);
    136 
    137         actionModeOpen = testMenu.findItem(R.id.action_menu_open);
    138         actionModeOpenWith = testMenu.findItem(R.id.action_menu_open_with);
    139         actionModeShare = testMenu.findItem(R.id.action_menu_share);
    140         actionModeDelete = testMenu.findItem(R.id.action_menu_delete);
    141         actionModeSelectAll = testMenu.findItem(R.id.action_menu_select_all);
    142         actionModeCopyTo = testMenu.findItem(R.id.action_menu_copy_to);
    143         actionModeExtractTo = testMenu.findItem(R.id.action_menu_extract_to);
    144         actionModeMoveTo = testMenu.findItem(R.id.action_menu_move_to);
    145         actionModeCompress = testMenu.findItem(R.id.action_menu_compress);
    146         actionModeRename = testMenu.findItem(R.id.action_menu_rename);
    147         actionModeInspector = testMenu.findItem(R.id.action_menu_inspector);
    148         actionModeViewInOwner = testMenu.findItem(R.id.action_menu_view_in_owner);
    149 
    150         optionSearch = testMenu.findItem(R.id.option_menu_search);
    151         optionDebug = testMenu.findItem(R.id.option_menu_debug);
    152         optionGrid = testMenu.findItem(R.id.option_menu_grid);
    153         optionList = testMenu.findItem(R.id.option_menu_list);
    154         optionNewWindow = testMenu.findItem(R.id.option_menu_new_window);
    155         optionCreateDir = testMenu.findItem(R.id.option_menu_create_dir);
    156         optionSelectAll = testMenu.findItem(R.id.option_menu_select_all);
    157         optionAdvanced = testMenu.findItem(R.id.option_menu_advanced);
    158         optionSettings = testMenu.findItem(R.id.option_menu_settings);
    159 
    160         features = new TestFeatures();
    161 
    162         // These items by default are visible
    163         testMenu.findItem(R.id.dir_menu_select_all).setVisible(true);
    164         testMenu.findItem(R.id.option_menu_select_all).setVisible(true);
    165         testMenu.findItem(R.id.option_menu_list).setVisible(true);
    166 
    167         selectionDetails = new TestSelectionDetails();
    168         dirDetails = new TestDirectoryDetails();
    169         testSearchManager = new TestSearchViewManager();
    170         preferences = new TestScopedPreferences();
    171         selectionManager = SelectionManagers.createTestInstance(TestData.create(1));
    172         selectionManager.toggleSelection("0");
    173 
    174         mgr = new MenuManager(
    175                 features,
    176                 testSearchManager,
    177                 state,
    178                 dirDetails,
    179                 activity,
    180                 selectionManager,
    181                 this::getApplicationNameFromAuthority,
    182                 this::getUriFromModelId);
    183 
    184         testRootInfo = new RootInfo();
    185         testDocInfo = new DocumentInfo();
    186     }
    187 
    188     private Uri getUriFromModelId(String id) {
    189         return Uri.EMPTY;
    190     }
    191     private String getApplicationNameFromAuthority(String authority) {
    192         return "TestApp";
    193     }
    194 
    195     @Test
    196     public void testActionMenu() {
    197         selectionDetails.canDelete = true;
    198         selectionDetails.canRename = true;
    199         dirDetails.canCreateDoc = true;
    200 
    201         mgr.updateActionMenu(testMenu, selectionDetails);
    202 
    203         actionModeRename.assertEnabled();
    204         actionModeDelete.assertVisible();
    205         actionModeShare.assertVisible();
    206         actionModeCopyTo.assertEnabled();
    207         actionModeCompress.assertEnabled();
    208         actionModeExtractTo.assertInvisible();
    209         actionModeMoveTo.assertEnabled();
    210         actionModeViewInOwner.assertInvisible();
    211     }
    212 
    213     @Test
    214     public void testActionMenu_ContainsPartial() {
    215         selectionDetails.containPartial = true;
    216         dirDetails.canCreateDoc = true;
    217         mgr.updateActionMenu(testMenu, selectionDetails);
    218 
    219         actionModeRename.assertDisabled();
    220         actionModeShare.assertInvisible();
    221         actionModeCopyTo.assertDisabled();
    222         actionModeCompress.assertDisabled();
    223         actionModeExtractTo.assertDisabled();
    224         actionModeMoveTo.assertDisabled();
    225         actionModeViewInOwner.assertInvisible();
    226     }
    227 
    228     @Test
    229     public void testActionMenu_CreateArchives_ReflectsFeatureState() {
    230         features.archiveCreation = false;
    231         dirDetails.canCreateDoc = true;
    232         mgr.updateActionMenu(testMenu, selectionDetails);
    233 
    234         actionModeCompress.assertInvisible();
    235         actionModeCompress.assertDisabled();
    236     }
    237 
    238     @Test
    239     public void testActionMenu_CreateArchive() {
    240         dirDetails.canCreateDoc = true;
    241         mgr.updateActionMenu(testMenu, selectionDetails);
    242 
    243         actionModeCompress.assertEnabled();
    244     }
    245 
    246     @Test
    247     public void testActionMenu_NoCreateArchive() {
    248         dirDetails.canCreateDoc = false;
    249         mgr.updateActionMenu(testMenu, selectionDetails);
    250 
    251         actionModeCompress.assertDisabled();
    252     }
    253 
    254     @Test
    255     public void testActionMenu_cantRename() {
    256         selectionDetails.canRename = false;
    257         mgr.updateActionMenu(testMenu, selectionDetails);
    258 
    259         actionModeRename.assertDisabled();
    260     }
    261 
    262     @Test
    263     public void testActionMenu_cantDelete() {
    264         selectionDetails.canDelete = false;
    265         mgr.updateActionMenu(testMenu, selectionDetails);
    266 
    267         actionModeDelete.assertInvisible();
    268         // We shouldn't be able to move files if we can't delete them
    269         actionModeMoveTo.assertDisabled();
    270     }
    271 
    272     @Test
    273     public void testActionsMenu_canViewInOwner() {
    274         selectionDetails.canViewInOwner = true;
    275         mgr.updateActionMenu(testMenu, selectionDetails);
    276 
    277         actionModeViewInOwner.assertVisible();
    278     }
    279 
    280     @Test
    281     public void testActionMenu_changeToCanDelete() {
    282         selectionDetails.canDelete = false;
    283         mgr.updateActionMenu(testMenu, selectionDetails);
    284 
    285         selectionDetails.canDelete = true;
    286         mgr.updateActionMenu(testMenu, selectionDetails);
    287 
    288         actionModeDelete.assertVisible();
    289         actionModeDelete.assertEnabled();
    290         actionModeMoveTo.assertVisible();
    291         actionModeMoveTo.assertEnabled();
    292     }
    293 
    294     @Test
    295     public void testActionMenu_ContainsDirectory() {
    296         selectionDetails.containDirectories = true;
    297         mgr.updateActionMenu(testMenu, selectionDetails);
    298 
    299         // We can't share directories
    300         actionModeShare.assertInvisible();
    301     }
    302 
    303     @Test
    304     public void testActionMenu_RemovesDirectory() {
    305         selectionDetails.containDirectories = true;
    306         mgr.updateActionMenu(testMenu, selectionDetails);
    307 
    308         selectionDetails.containDirectories = false;
    309         mgr.updateActionMenu(testMenu, selectionDetails);
    310 
    311         actionModeShare.assertVisible();
    312         actionModeShare.assertEnabled();
    313     }
    314 
    315     @Test
    316     public void testActionMenu_CantExtract() {
    317         selectionDetails.canExtract = false;
    318         mgr.updateActionMenu(testMenu, selectionDetails);
    319 
    320         actionModeExtractTo.assertInvisible();
    321     }
    322 
    323     @Test
    324     public void testActionMenu_CanExtract_hidesCopyToAndCompressAndShare() {
    325         features.archiveCreation = true;
    326         selectionDetails.canExtract = true;
    327         dirDetails.canCreateDoc = true;
    328         mgr.updateActionMenu(testMenu, selectionDetails);
    329 
    330         actionModeExtractTo.assertEnabled();
    331         actionModeCopyTo.assertDisabled();
    332         actionModeCompress.assertDisabled();
    333     }
    334 
    335     @Test
    336     public void testActionMenu_CanOpenWith() {
    337         selectionDetails.canOpenWith = true;
    338         mgr.updateActionMenu(testMenu, selectionDetails);
    339 
    340         actionModeOpenWith.assertVisible();
    341         actionModeOpenWith.assertEnabled();
    342     }
    343 
    344     @Test
    345     public void testActionMenu_NoOpenWith() {
    346         selectionDetails.canOpenWith = false;
    347         mgr.updateActionMenu(testMenu, selectionDetails);
    348 
    349         actionModeOpenWith.assertVisible();
    350         actionModeOpenWith.assertDisabled();
    351     }
    352 
    353     @Test
    354     public void testOptionMenu() {
    355         mgr.updateOptionMenu(testMenu);
    356 
    357         optionAdvanced.assertInvisible();
    358         optionAdvanced.assertTitle(R.string.menu_advanced_show);
    359         optionCreateDir.assertDisabled();
    360         optionDebug.assertInvisible();
    361         assertTrue(testSearchManager.updateMenuCalled());
    362     }
    363 
    364     @Test
    365     public void testOptionMenu_ShowAdvanced() {
    366         state.showAdvanced = true;
    367         state.showDeviceStorageOption = true;
    368         mgr.updateOptionMenu(testMenu);
    369 
    370         optionAdvanced.assertVisible();
    371         optionAdvanced.assertTitle(R.string.menu_advanced_hide);
    372     }
    373 
    374     @Test
    375     public void testOptionMenu_CanCreateDirectory() {
    376         dirDetails.canCreateDirectory = true;
    377         mgr.updateOptionMenu(testMenu);
    378 
    379         optionCreateDir.assertEnabled();
    380     }
    381 
    382     @Test
    383     public void testOptionMenu_HasRootSettings() {
    384         dirDetails.hasRootSettings = true;
    385         mgr.updateOptionMenu(testMenu);
    386 
    387         optionSettings.assertVisible();
    388     }
    389 
    390     @Test
    391     public void testInflateContextMenu_Files() {
    392         TestMenuInflater inflater = new TestMenuInflater();
    393 
    394         selectionDetails.containFiles = true;
    395         selectionDetails.containDirectories = false;
    396         mgr.inflateContextMenuForDocs(testMenu, inflater, selectionDetails);
    397 
    398         assertEquals(R.menu.file_context_menu, inflater.lastInflatedMenuId);
    399     }
    400 
    401     @Test
    402     public void testInflateContextMenu_Dirs() {
    403         TestMenuInflater inflater = new TestMenuInflater();
    404 
    405         selectionDetails.containFiles = false;
    406         selectionDetails.containDirectories = true;
    407         mgr.inflateContextMenuForDocs(testMenu, inflater, selectionDetails);
    408 
    409         assertEquals(R.menu.dir_context_menu, inflater.lastInflatedMenuId);
    410     }
    411 
    412     @Test
    413     public void testInflateContextMenu_Mixed() {
    414         TestMenuInflater inflater = new TestMenuInflater();
    415 
    416         selectionDetails.containFiles = true;
    417         selectionDetails.containDirectories = true;
    418         mgr.inflateContextMenuForDocs(testMenu, inflater, selectionDetails);
    419 
    420         assertEquals(R.menu.mixed_context_menu, inflater.lastInflatedMenuId);
    421     }
    422 
    423     @Test
    424     public void testContextMenu_EmptyArea() {
    425         mgr.updateContextMenuForContainer(testMenu);
    426 
    427         dirSelectAll.assertVisible();
    428         dirSelectAll.assertEnabled();
    429         dirPasteFromClipboard.assertVisible();
    430         dirPasteFromClipboard.assertDisabled();
    431         dirCreateDir.assertVisible();
    432         dirCreateDir.assertDisabled();
    433     }
    434 
    435     @Test
    436     public void testContextMenu_EmptyArea_NoItemToPaste() {
    437         dirDetails.hasItemsToPaste = false;
    438         dirDetails.canCreateDoc = true;
    439 
    440         mgr.updateContextMenuForContainer(testMenu);
    441 
    442         dirSelectAll.assertVisible();
    443         dirSelectAll.assertEnabled();
    444         dirPasteFromClipboard.assertVisible();
    445         dirPasteFromClipboard.assertDisabled();
    446         dirCreateDir.assertVisible();
    447         dirCreateDir.assertDisabled();
    448     }
    449 
    450     @Test
    451     public void testContextMenu_EmptyArea_CantCreateDoc() {
    452         dirDetails.hasItemsToPaste = true;
    453         dirDetails.canCreateDoc = false;
    454 
    455         mgr.updateContextMenuForContainer(testMenu);
    456 
    457         dirSelectAll.assertVisible();
    458         dirSelectAll.assertEnabled();
    459         dirPasteFromClipboard.assertVisible();
    460         dirPasteFromClipboard.assertDisabled();
    461         dirCreateDir.assertVisible();
    462         dirCreateDir.assertDisabled();
    463     }
    464 
    465     @Test
    466     public void testContextMenu_EmptyArea_CanPaste() {
    467         dirDetails.hasItemsToPaste = true;
    468         dirDetails.canCreateDoc = true;
    469 
    470         mgr.updateContextMenuForContainer(testMenu);
    471 
    472         dirSelectAll.assertVisible();
    473         dirSelectAll.assertEnabled();
    474         dirPasteFromClipboard.assertVisible();
    475         dirPasteFromClipboard.assertEnabled();
    476         dirCreateDir.assertVisible();
    477         dirCreateDir.assertDisabled();
    478     }
    479 
    480     @Test
    481     public void testContextMenu_EmptyArea_CanCreateDirectory() {
    482         dirDetails.canCreateDirectory = true;
    483 
    484         mgr.updateContextMenuForContainer(testMenu);
    485 
    486         dirSelectAll.assertVisible();
    487         dirSelectAll.assertEnabled();
    488         dirPasteFromClipboard.assertVisible();
    489         dirPasteFromClipboard.assertDisabled();
    490         dirCreateDir.assertVisible();
    491         dirCreateDir.assertEnabled();
    492     }
    493 
    494     @Test
    495     public void testContextMenu_OnFile() {
    496         selectionDetails.size = 1;
    497         mgr.updateContextMenuForFiles(testMenu, selectionDetails);
    498         dirOpen.assertVisible();
    499         dirOpen.assertEnabled();
    500         dirCutToClipboard.assertVisible();
    501         dirCopyToClipboard.assertVisible();
    502         dirRename.assertVisible();
    503         dirCreateDir.assertVisible();
    504         dirDelete.assertVisible();
    505     }
    506 
    507     @Test
    508     public void testContextMenu_OnFile_CanOpenWith() {
    509         selectionDetails.canOpenWith = true;
    510         mgr.updateContextMenuForFiles(testMenu, selectionDetails);
    511         dirOpenWith.assertVisible();
    512         dirOpenWith.assertEnabled();
    513     }
    514 
    515     @Test
    516     public void testContextMenu_OnFile_NoOpenWith() {
    517         selectionDetails.canOpenWith = false;
    518         mgr.updateContextMenuForFiles(testMenu, selectionDetails);
    519         dirOpenWith.assertVisible();
    520         dirOpenWith.assertDisabled();
    521     }
    522 
    523     @Test
    524     public void testContextMenu_OnMultipleFiles() {
    525         selectionDetails.size = 3;
    526         mgr.updateContextMenuForFiles(testMenu, selectionDetails);
    527         dirOpen.assertVisible();
    528         dirOpen.assertDisabled();
    529     }
    530 
    531     @Test
    532     public void testContextMenu_OnWritableDirectory() {
    533         selectionDetails.size = 1;
    534         selectionDetails.canPasteInto = true;
    535         dirDetails.hasItemsToPaste = true;
    536         mgr.updateContextMenuForDirs(testMenu, selectionDetails);
    537         dirOpenInNewWindow.assertVisible();
    538         dirOpenInNewWindow.assertEnabled();
    539         dirCutToClipboard.assertVisible();
    540         dirCopyToClipboard.assertVisible();
    541         dirPasteIntoFolder.assertVisible();
    542         dirPasteIntoFolder.assertEnabled();
    543         dirRename.assertVisible();
    544         dirDelete.assertVisible();
    545     }
    546 
    547     @Test
    548     public void testContextMenu_OnNonWritableDirectory() {
    549         selectionDetails.size = 1;
    550         selectionDetails.canPasteInto = false;
    551         mgr.updateContextMenuForDirs(testMenu, selectionDetails);
    552         dirOpenInNewWindow.assertVisible();
    553         dirOpenInNewWindow.assertEnabled();
    554         dirCutToClipboard.assertVisible();
    555         dirCopyToClipboard.assertVisible();
    556         dirPasteIntoFolder.assertVisible();
    557         dirPasteIntoFolder.assertDisabled();
    558         dirRename.assertVisible();
    559         dirDelete.assertVisible();
    560     }
    561 
    562     @Test
    563     public void testContextMenu_OnWritableDirectory_NothingToPaste() {
    564         selectionDetails.canPasteInto = true;
    565         selectionDetails.size = 1;
    566         dirDetails.hasItemsToPaste = false;
    567         mgr.updateContextMenuForDirs(testMenu, selectionDetails);
    568         dirPasteIntoFolder.assertVisible();
    569         dirPasteIntoFolder.assertDisabled();
    570     }
    571 
    572     @Test
    573     public void testContextMenu_OnMultipleDirectories() {
    574         selectionDetails.size = 3;
    575         mgr.updateContextMenuForDirs(testMenu, selectionDetails);
    576         dirOpenInNewWindow.assertVisible();
    577         dirOpenInNewWindow.assertDisabled();
    578     }
    579 
    580     @Test
    581     public void testContextMenu_OnMixedDocs() {
    582         selectionDetails.containDirectories = true;
    583         selectionDetails.containFiles = true;
    584         selectionDetails.size = 2;
    585         selectionDetails.canDelete = true;
    586         mgr.updateContextMenu(testMenu, selectionDetails);
    587         dirCutToClipboard.assertVisible();
    588         dirCutToClipboard.assertEnabled();
    589         dirCopyToClipboard.assertVisible();
    590         dirCopyToClipboard.assertEnabled();
    591         dirDelete.assertVisible();
    592         dirDelete.assertEnabled();
    593     }
    594 
    595     @Test
    596     public void testContextMenu_OnMixedDocs_hasPartialFile() {
    597         selectionDetails.containDirectories = true;
    598         selectionDetails.containFiles = true;
    599         selectionDetails.size = 2;
    600         selectionDetails.containPartial = true;
    601         selectionDetails.canDelete = true;
    602         mgr.updateContextMenu(testMenu, selectionDetails);
    603         dirCutToClipboard.assertVisible();
    604         dirCutToClipboard.assertDisabled();
    605         dirCopyToClipboard.assertVisible();
    606         dirCopyToClipboard.assertDisabled();
    607         dirDelete.assertVisible();
    608         dirDelete.assertEnabled();
    609     }
    610 
    611     @Test
    612     public void testContextMenu_OnMixedDocs_hasUndeletableFile() {
    613         selectionDetails.containDirectories = true;
    614         selectionDetails.containFiles = true;
    615         selectionDetails.size = 2;
    616         selectionDetails.canDelete = false;
    617         mgr.updateContextMenu(testMenu, selectionDetails);
    618         dirCutToClipboard.assertVisible();
    619         dirCutToClipboard.assertDisabled();
    620         dirCopyToClipboard.assertVisible();
    621         dirCopyToClipboard.assertEnabled();
    622         dirDelete.assertVisible();
    623         dirDelete.assertDisabled();
    624     }
    625 
    626     @Test
    627     public void testRootContextMenu() {
    628         testRootInfo.flags = Root.FLAG_SUPPORTS_CREATE;
    629 
    630         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    631 
    632         rootEjectRoot.assertInvisible();
    633 
    634         rootOpenInNewWindow.assertVisible();
    635         rootOpenInNewWindow.assertEnabled();
    636 
    637         rootPasteIntoFolder.assertVisible();
    638         rootPasteIntoFolder.assertDisabled();
    639 
    640         rootSettings.assertVisible();
    641         rootSettings.assertDisabled();
    642     }
    643 
    644     @Test
    645     public void testRootContextMenu_HasRootSettings() {
    646         testRootInfo.flags = Root.FLAG_HAS_SETTINGS;
    647         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    648 
    649         rootSettings.assertEnabled();
    650     }
    651 
    652     @Test
    653     public void testRootContextMenu_NonWritableRoot() {
    654         dirDetails.hasItemsToPaste = true;
    655         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    656 
    657         rootPasteIntoFolder.assertVisible();
    658         rootPasteIntoFolder.assertDisabled();
    659     }
    660 
    661     @Test
    662     public void testRootContextMenu_NothingToPaste() {
    663         testRootInfo.flags = Root.FLAG_SUPPORTS_CREATE;
    664         testDocInfo.flags = Document.FLAG_DIR_SUPPORTS_CREATE;
    665         dirDetails.hasItemsToPaste = false;
    666         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    667 
    668         rootPasteIntoFolder.assertVisible();
    669         rootPasteIntoFolder.assertDisabled();
    670     }
    671 
    672     @Test
    673     public void testRootContextMenu_PasteIntoWritableRoot() {
    674         testRootInfo.flags = Root.FLAG_SUPPORTS_CREATE;
    675         testDocInfo.flags = Document.FLAG_DIR_SUPPORTS_CREATE;
    676         dirDetails.hasItemsToPaste = true;
    677         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    678 
    679         rootPasteIntoFolder.assertVisible();
    680         rootPasteIntoFolder.assertEnabled();
    681     }
    682 
    683     @Test
    684     public void testRootContextMenu_Eject() {
    685         testRootInfo.flags = Root.FLAG_SUPPORTS_EJECT;
    686         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    687 
    688         rootEjectRoot.assertEnabled();
    689     }
    690 
    691     @Test
    692     public void testRootContextMenu_EjectInProcess() {
    693         testRootInfo.flags = Root.FLAG_SUPPORTS_EJECT;
    694         testRootInfo.ejecting = true;
    695         mgr.updateRootContextMenu(testMenu, testRootInfo, testDocInfo);
    696 
    697         rootEjectRoot.assertDisabled();
    698     }
    699 }
    700