Fixes tab complete error with no island.

EWR ->  DEN

src/main/java/world/bentobox/bentobox/api/commands/island/IslandBanCommand.java

@@ -103,6 +103,7 @@ public class IslandBanCommand extends CompositeCommand {
             return Optional.empty();
         }
         Island island = getIslands().getIsland(getWorld(), user.getUniqueId());
+        if (island != null) {
             List<String> options = Bukkit.getOnlinePlayers().stream()
                     .filter(p -> !p.getUniqueId().equals(user.getUniqueId()))
                     .filter(p -> !island.isBanned(p.getUniqueId()))
@@ -110,5 +111,8 @@ public class IslandBanCommand extends CompositeCommand {
                     .map(Player::getName).collect(Collectors.toList());
             String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
             return Optional.of(Util.tabLimit(options, lastArg));
+        } else {
+            return Optional.empty();
+        }
     }
 }

src/main/java/world/bentobox/bentobox/api/commands/island/IslandUnbanCommand.java

@@ -82,8 +82,12 @@ public class IslandUnbanCommand extends CompositeCommand {
     @Override
     public Optional<List<String>> tabComplete(User user, String alias, List<String> args) {
         Island island = getIslands().getIsland(getWorld(), user.getUniqueId());
+        if (island != null) {
             List<String> options = island.getBanned().stream().map(getPlayers()::getName).collect(Collectors.toList());
             String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
             return Optional.of(Util.tabLimit(options, lastArg));
+        } else {
+            return Optional.empty();
+        }
     }
 }

src/main/java/world/bentobox/bentobox/api/commands/island/team/IslandTeamTrustCommand.java

@@ -3,10 +3,6 @@ package world.bentobox.bentobox.api.commands.island.team;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
-import java.util.stream.Collectors;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
 
 import world.bentobox.bentobox.api.commands.CompositeCommand;
 import world.bentobox.bentobox.api.localization.TextVariables;
@@ -96,13 +92,7 @@ public class IslandTeamTrustCommand extends CompositeCommand {
             // Don't show every player on the server. Require at least the first letter
             return Optional.empty();
         }
-        Island island = getIslands().getIsland(getWorld(), user.getUniqueId());
+        String lastArg = args.get(args.size()-1);
-        List<String> options  = Bukkit.getOnlinePlayers().stream()
+        return Optional.of(Util.tabLimit(Util.getOnlinePlayerList(user), lastArg));
-                .filter(p -> !p.getUniqueId().equals(user.getUniqueId()))
-                .filter(p -> !island.getMemberSet().contains(p.getUniqueId()))
-                .filter(p -> user.getPlayer().canSee(p))
-                .map(Player::getName).collect(Collectors.toList());
-        String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
-        return Optional.of(Util.tabLimit(options, lastArg));
     }
 }

src/main/java/world/bentobox/bentobox/api/commands/island/team/IslandTeamUncoopCommand.java

@@ -103,6 +103,7 @@ public class IslandTeamUncoopCommand extends CompositeCommand {
             return Optional.empty();
         }
         Island island = getIslands().getIsland(getWorld(), user.getUniqueId());
+        if (island != null) {
             List<String> options = island.getMemberSet().stream()
                     .filter(uuid -> island.getRank(User.getInstance(uuid)) == RanksManager.COOP_RANK)
                     .map(Bukkit::getOfflinePlayer)
@@ -110,5 +111,8 @@ public class IslandTeamUncoopCommand extends CompositeCommand {
 
             String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
             return Optional.of(Util.tabLimit(options, lastArg));
+        } else {
+            return Optional.empty();
+        }
     }
 }

src/main/java/world/bentobox/bentobox/api/commands/island/team/IslandTeamUntrustCommand.java

@@ -103,6 +103,7 @@ public class IslandTeamUntrustCommand extends CompositeCommand {
             return Optional.empty();
         }
         Island island = getIslands().getIsland(getWorld(), user.getUniqueId());
+        if (island != null) {
             List<String> options = island.getMemberSet().stream()
                     .filter(uuid -> island.getRank(User.getInstance(uuid)) == RanksManager.TRUSTED_RANK)
                     .map(Bukkit::getOfflinePlayer)
@@ -110,5 +111,8 @@ public class IslandTeamUntrustCommand extends CompositeCommand {
 
             String lastArg = !args.isEmpty() ? args.get(args.size()-1) : "";
             return Optional.of(Util.tabLimit(options, lastArg));
+        } else {
+            return Optional.empty();
+        }
     }
 }

src/test/java/world/bentobox/bentobox/api/commands/island/IslandBanCommandTest.java

@@ -292,6 +292,33 @@ public class IslandBanCommandTest {
         Mockito.verify(targetUser, Mockito.never()).sendMessage("commands.island.ban.owner-banned-you", "[owner]", user.getName());
     }
 
+    @Test
+    public void testTabCompleteNoIsland() {
+        // No island
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(null);
+        IslandBanCommand ibc = new IslandBanCommand(ic);
+        // Set up the user
+        User user = mock(User.class);
+        when(user.getUniqueId()).thenReturn(UUID.randomUUID());
+        // Get the tab-complete list with one argument
+        LinkedList<String> args = new LinkedList<>();
+        args.add("");
+        Optional<List<String>> result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("d");
+        result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("fr");
+        result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+    }
+    
     @Test
     public void testTabComplete() {
 

src/test/java/world/bentobox/bentobox/api/commands/island/IslandUnbanCommandTest.java

@@ -256,4 +256,31 @@ public class IslandUnbanCommandTest {
         String[] names = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
         assertTrue(Arrays.equals(names, result.get().toArray()));
     }
+    
+    @Test
+    public void testTabCompleteNoIsland() {
+        // No island
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(null);
+        IslandUnbanCommand iubc = new IslandUnbanCommand(ic);
+        // Set up the user
+        User user = mock(User.class);
+        when(user.getUniqueId()).thenReturn(UUID.randomUUID());
+        // Get the tab-complete list with one argument
+        LinkedList<String> args = new LinkedList<>();
+        args.add("");
+        Optional<List<String>> result = iubc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("d");
+        result = iubc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("fr");
+        result = iubc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+    }
 }

src/test/java/world/bentobox/bentobox/api/commands/island/team/IslandTeamUncoopCommandTest.java

@@ -4,6 +4,7 @@
 package world.bentobox.bentobox.api.commands.island.team;
 
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -11,9 +12,14 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.junit.Before;
@@ -25,6 +31,9 @@ import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 import org.powermock.reflect.Whitebox;
 
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+
 import world.bentobox.bentobox.BentoBox;
 import world.bentobox.bentobox.Settings;
 import world.bentobox.bentobox.api.commands.CompositeCommand;
@@ -215,5 +224,77 @@ public class IslandTeamUncoopCommandTest {
         itl.execute(user, itl.getLabel(), Arrays.asList(name));
     }
     
+    @Test
+    public void testTabCompleteNoIsland() {
+        // No island
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(null);
+        IslandTeamUncoopCommand ibc = new IslandTeamUncoopCommand(ic);
+        // Set up the user
+        User user = mock(User.class);
+        when(user.getUniqueId()).thenReturn(UUID.randomUUID());
+        // Get the tab-complete list with one argument
+        LinkedList<String> args = new LinkedList<>();
+        args.add("");
+        Optional<List<String>> result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("d");
+        result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("fr");
+        result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+    }
+    
+    @Test
+    public void testTabComplete() {
+
+        Builder<UUID> memberSet = new ImmutableSet.Builder<>();
+         for (int j = 0; j < 11; j++) {
+             memberSet.add(UUID.randomUUID());
+        }
+
+        when(island.getMemberSet()).thenReturn(memberSet.build());
+        // Return a set of players
+        PowerMockito.mockStatic(Bukkit.class);
+        OfflinePlayer offlinePlayer = mock(OfflinePlayer.class);
+        when(Bukkit.getOfflinePlayer(Mockito.any(UUID.class))).thenReturn(offlinePlayer);
+        when(offlinePlayer.getName()).thenReturn("adam", "ben", "cara", "dave", "ed", "frank", "freddy", "george", "harry", "ian", "joe");
+        when(island.getRank(Mockito.any())).thenReturn(
+                RanksManager.COOP_RANK, 
+                RanksManager.COOP_RANK, 
+                RanksManager.COOP_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK
+                );
+
+        IslandTeamUncoopCommand ibc = new IslandTeamUncoopCommand(ic);
+        // Get the tab-complete list with no argument
+        Optional<List<String>> result = ibc.tabComplete(user, "", new LinkedList<>());
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with no argument
+        LinkedList<String> args = new LinkedList<>();
+        args.add("");
+        result = ibc.tabComplete(user, "", args);
+        assertTrue(result.isPresent());
+        List<String> r = result.get().stream().sorted().collect(Collectors.toList());
+        // Compare the expected with the actual
+        String[] expectedNames = {"adam", "ben", "cara"};
+        
+        assertTrue(Arrays.equals(expectedNames, r.toArray()));
+
+    }
 
 }

src/test/java/world/bentobox/bentobox/api/commands/island/team/IslandTeamUntrustCommandTest.java

@@ -4,6 +4,7 @@
 package world.bentobox.bentobox.api.commands.island.team;
 
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -11,9 +12,14 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.junit.Before;
@@ -25,6 +31,9 @@ import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 import org.powermock.reflect.Whitebox;
 
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+
 import world.bentobox.bentobox.BentoBox;
 import world.bentobox.bentobox.Settings;
 import world.bentobox.bentobox.api.commands.CompositeCommand;
@@ -215,5 +224,76 @@ public class IslandTeamUntrustCommandTest {
         itl.execute(user, itl.getLabel(), Arrays.asList(name));
     }
     
+    @Test
+    public void testTabCompleteNoIsland() {
+        // No island
+        when(im.getIsland(Mockito.any(), Mockito.any(UUID.class))).thenReturn(null);
+        IslandTeamUntrustCommand ibc = new IslandTeamUntrustCommand(ic);
+        // Set up the user
+        User user = mock(User.class);
+        when(user.getUniqueId()).thenReturn(UUID.randomUUID());
+        // Get the tab-complete list with one argument
+        LinkedList<String> args = new LinkedList<>();
+        args.add("");
+        Optional<List<String>> result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
 
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("d");
+        result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with one letter argument
+        args = new LinkedList<>();
+        args.add("fr");
+        result = ibc.tabComplete(user, "", args);
+        assertFalse(result.isPresent());
+    }
+    
+    @Test
+    public void testTabComplete() {
+
+        Builder<UUID> memberSet = new ImmutableSet.Builder<>();
+         for (int j = 0; j < 11; j++) {
+             memberSet.add(UUID.randomUUID());
+        }
+
+        when(island.getMemberSet()).thenReturn(memberSet.build());
+        // Return a set of players
+        PowerMockito.mockStatic(Bukkit.class);
+        OfflinePlayer offlinePlayer = mock(OfflinePlayer.class);
+        when(Bukkit.getOfflinePlayer(Mockito.any(UUID.class))).thenReturn(offlinePlayer);
+        when(offlinePlayer.getName()).thenReturn("adam", "ben", "cara", "dave", "ed", "frank", "freddy", "george", "harry", "ian", "joe");
+        when(island.getRank(Mockito.any())).thenReturn(
+                RanksManager.TRUSTED_RANK, 
+                RanksManager.TRUSTED_RANK, 
+                RanksManager.TRUSTED_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK,
+                RanksManager.MEMBER_RANK
+                );
+
+        IslandTeamUntrustCommand ibc = new IslandTeamUntrustCommand(ic);
+        // Get the tab-complete list with no argument
+        Optional<List<String>> result = ibc.tabComplete(user, "", new LinkedList<>());
+        assertFalse(result.isPresent());
+
+        // Get the tab-complete list with no argument
+        LinkedList<String> args = new LinkedList<>();
+        args.add("");
+        result = ibc.tabComplete(user, "", args);
+        assertTrue(result.isPresent());
+        List<String> r = result.get().stream().sorted().collect(Collectors.toList());
+        // Compare the expected with the actual
+        String[] expectedNames = {"adam", "ben", "cara"};
+        
+        assertTrue(Arrays.equals(expectedNames, r.toArray()));
+
+    }
 }