@Test
    public void getmayor() {
        System.out.println("actualizeMayor");
        Cidades city1 = new Cidades("Porto", 10, "ofa", "rqe");
        Cidades city2 = new Cidades("Lisboa", 5, "rwewe", "rewq");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addCity(city2);
        Utilizadores user1 = instance.addUser("user1", "user1@user", city1.getName());
        Utilizadores user2 = instance.addUser("user2", "user2@user", city1.getName());
        instance.checkInUserToCity(user1.getNickname(), city2.getName());
        instance.checkInUserToCity(user1.getNickname(), city1.getName());
        instance.actualizeMayor(city1);
        Utilizadores result = city1.getMayor();
        Utilizadores expRes = user1;
        int expRes1 = instance.getUserPointsInACity(user1, city1);
        int result1 = city1.getUsersCheckInList().get(user1.getNickname());
        assertEquals(result, expRes);
        assertEquals(result1, expRes1);
    }

    @Test
    public void MayorCityList() {
        System.out.println("getCityMayorList");
        Cidades city1 = new Cidades("Porto", 10, "23", "11");
        Cidades city2 = new Cidades("Lisboa", 5, "1123", "331");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addCity(city2);
        Utilizadores user1 = instance.addUser("user1", "user1@email", city1.getName());
        Utilizadores user2 = instance.addUser("user2", "user2@email", city1.getName());
        user1 = instance.checkInUserToCity(user1.getNickname(), city2.getName());
        user1 = instance.checkInUserToCity(user1.getNickname(), city1.getName());
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put(user2.getNickname(), instance.getUserPointsInACity(user2, city1));
        map.put(user1.getNickname(), instance.getUserPointsInACity(user1, city1));
        List<Map.Entry<String, Integer>> expResult = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
        List<Map.Entry<String, Integer>> result = instance.getCityMayorList(city1.getName());
        assertEquals(expResult, result);
    }

    @Test
    public void ReturnListaOrdenada() {
        System.out.println("returnSortedList");
        Map<String, Integer> usersCheckInList = new HashMap<String, Integer>();
        usersCheckInList.put("User1", 12);
        usersCheckInList.put("User1", 1);
        usersCheckInList.put("User1", 42);
        usersCheckInList.put("User1", 22);
        usersCheckInList.put("User1", 32);
        RedeSocial instance = new RedeSocial();
        boolean expResult = true;
        boolean result = true;
        List<Map.Entry<String, Integer>> list = instance.returnSortedList(usersCheckInList);
        if (list.size() > 1) {
            for (int i = 0; i < list.size(); i++) {
                for (int j = 0; j < 10; j++) {
                    int value1 = list.get(i).getValue();
                    int value2 = list.get(j).getValue();
                    if (value1 < value2) {
                        result = false;
                    }
                }
            }
        }

        assertEquals(expResult, result);
    }

    /*@Test
    public void testRemoveFriend() {
        System.out.println("removeFriend");
        Cidades city1 = new Cidades("city1", 10, "sad", "fsdaf");
        Utilizadores user1 = new Utilizadores("user1", "user1", city1);
        Utilizadores user2 = new Utilizadores("user2", "user2", city1);
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addUser("user1", "user1", city1.getName());
        instance.addUser("user2", "user2", city1.getName());
        instance.addFriendToUser(user1, user2);
        ArrayList<Utilizadores> expResult = user1.getFriendsList();
        instance.removeFriend(user1.getNickname(), user2.getNickname());
        ArrayList<Utilizadores> result = user1.getFriendsList();
        expResult.remove(user2);
        boolean result2 = false;
        boolean expResult2 = false;
        if (result.contains(user2)) {
            result2 = true;
        }
        assertEquals(expResult, result);
        assertEquals(expResult, result);
    }*/
    /*@Test
    public void testRemoveUserFromFriendsLists() {
        System.out.println("removeUserFromFriendsLists");
        Cidades city1 = new Cidades("city1", 10, "eqw ", "weq ");
        Utilizadores user1 = new Utilizadores("user1", "user1", city1);
        Utilizadores user2 = new Utilizadores("user2", "user2", city1);
        Utilizadores user3 = new Utilizadores("user3", "user3", city1);
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addUser("user1", "user1", city1.getName());
        instance.addUser("user2", "user2", city1.getName());
        instance.addUser("user3", "user3", city1.getName());
        instance.addFriendToUser(user1, user2);
        instance.addFriendToUser(user1, user3);
        instance.addFriendToUser(user3, user2);
        ArrayList<Utilizadores> expResultUser1 = user1.getFriendsList();
        ArrayList<Utilizadores> expResultUser3 = user3.getFriendsList();
        instance.removeUserFromFriendsLists(user2);
        ArrayList<Utilizadores> resultUser1 = user1.getFriendsList();
        ArrayList<Utilizadores> resultUser3 = user3.getFriendsList();
        expResultUser1.remove(user2);
        expResultUser3.remove(user2);
        boolean expResult = false;
        boolean result = false;
        if (resultUser1.contains(user2) || resultUser3.contains(user3)) {
            result = true;
        }

        assertEquals(expResult, result);
        assertEquals(expResultUser1, resultUser1);
        assertEquals(expResultUser3, resultUser3);
    }*/

    /*@Test
    public void testAreWeFriends() {
        System.out.println("areWeFriends");
        Cidades city1 = new Cidades("city1", 10, "ewq", "weq");
        Utilizadores user1 = new Utilizadores("user1", "user1", city1);
        Utilizadores friend = new Utilizadores("user2", "user2", city1);
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addUser("user1", "user1", city1.getName());
        instance.addUser("user2", "user2", city1.getName());
        instance.addFriendToUser(user1, friend);
        boolean expResult = true;
        boolean result = instance.areWeFriends(user1, friend);
        assertEquals(expResult, result);
    }*/

   /* @Test
    public void testAddFriendToUser() {
        System.out.println("addFriendToUser");
        Cidades city1 = new Cidades("city1", 10, "fsaf", "fdsa");
        Utilizadores user1 = new Utilizadores("user1", "user1", city1);
        Utilizadores friend = new Utilizadores("user2", "user2", city1);
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addUser("user1", "user1", city1.getName());
        instance.addUser("user2", "user2", city1.getName());
        boolean expResult = true;
        boolean result = false;
        instance.addFriendToUser(user1, friend);
        if (user1.getFriendsList().contains(friend)) {
            result = true;
        }
        assertEquals(expResult, result);
    }*/

    @Test
    public void testCity() {
        System.out.println("testCity");
        Cidades city1 = new Cidades("Porto", 10, "fdas", "fsa423");
        Cidades city2 = new Cidades("Lisboa", 5, "421", "4312");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        boolean expResult = false;
        boolean result = instance.testCity(city2);
        assertEquals(expResult, result);
    }

    @Test
    public void testCityByName() {
        System.out.println("TestCityByName");
        Cidades city = new Cidades("Porto", 10, "343", "4321");
        String city1 = "";
        String city2 = "Porto";
        RedeSocial instance = new RedeSocial();
        instance.addCity(city);
        boolean expResult = false;
        boolean result = instance.TestCityByName(city1);
        assertEquals(expResult, result);
        boolean expResult2 = true;
        boolean result2 = instance.TestCityByName(city2);
        assertEquals(expResult2, result2);
    }

    @Test
    public void getCityByName() {
        System.out.println("getCityByCityName");
        Cidades city = new Cidades("Porto", 10, "4123", "4321");
        String city1 = "Porto";
        RedeSocial instance = new RedeSocial();
        instance.addCity(city);
        assertEquals(instance.getCityByCityName(city1), city);

    }

    @Test
    public void removeCity() {
        System.out.println("removeCity");
        Cidades city1 = new Cidades("Porto", 10, "2341", "4312");
        Cidades city2 = new Cidades("Lisboa", 9, "312", "51");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addCity(city2);
        ArrayList<Cidades> expResult = new ArrayList<>();
        expResult.add(city1);
        expResult.add(city2);
        instance.removeCity(city1);
        expResult.remove(city1);
        ArrayList<Cidades> result = instance.getCities();
        assertEquals(expResult, result);
    }

    @Test
    public void removeCidadeByName() {
        System.out.println("removeCityByName");
        Cidades city1 = new Cidades("Porto", 10, "31", "34235");
        Cidades city2 = new Cidades("Lisboa", 9, "54354", "523");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addCity(city2);
        ArrayList<Cidades> expResult = new ArrayList<>();
        expResult.add(city1);
        expResult.add(city2);
        instance.removeCityByName(city1.getName());
        expResult.remove(city1);
        ArrayList<Cidades> result = instance.getCities();
        assertEquals(expResult, result);
    }

    @Test
    public void CityPoints() {
        System.out.println("getCityPoints");
        Cidades city1 = new Cidades("Porto", 10, "5423", "45325");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        int expResult = 10;
        int result = instance.getCityPoints(city1.getName());
        assertEquals(expResult, result);
    }

    @Test
    public void getUserByName() {
        System.out.println("getUserByNickname");
        Cidades city = new Cidades("Porto", 10, "4234", "5432");
        String user2 = "user";
        RedeSocial instance = new RedeSocial();
        instance.addCity(city);
        Utilizadores user = instance.addUser("user", "user@email", city.getName());
        Utilizadores result = instance.getUserByNickname(user2);
        assertEquals(result, user);
    }

    @Test
    public void testMail() {
        System.out.println("testEmail");
        Cidades city = new Cidades("Porto", 10, "342", "321");
        Utilizadores user = new Utilizadores("user", "user@email.com", city);
        String email1 = "notemail";
        String email2 = "user@email.com";
        RedeSocial instance = new RedeSocial();
        instance.addCity(city);
        instance.addUser("user", "user@email.com", city.getName());
        boolean result = instance.testEmail(email1);
        assertFalse(result);
        result = instance.testEmail(email2);
        assertTrue(result);
    }

    @Test
    public void testNick() {
        System.out.println("testNickname");
        Cidades city = new Cidades("Porto", 10, "erwq", "rwe");
        Utilizadores user = new Utilizadores("Francisco", "user@email.com", city);
        String nickname1 = "notnickname";
        String nickname2 = "user";
        RedeSocial instance = new RedeSocial();
        instance.addCity(city);
        instance.addUser("user", "user@email.com", city.getName());
        boolean result = instance.testNickname(nickname1);
        assertFalse(result);
        result = instance.testNickname(nickname2);
        assertTrue(result);
    }

    @Test
    public void removeUserFromCityMayorList() {
        System.out.println("removeUserFromCitiesMayorList");
        String user = "";
        RedeSocial instance = new RedeSocial();
        boolean expResult = false;
        boolean result = instance.removeUserFromCitiesMayorList(user);
        // assert(expResult, result);
    }


    @Test
    public void removeCitiesFromUserCheckin() {
        System.out.println("removeCitiesfromUserCheckIn");
        Cidades city1 = new Cidades("Porto", 10, "rqw", "141");
        Cidades city2 = new Cidades("Lisboa", 5, "12344", "4321");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addCity(city2);
        Utilizadores user1 = instance.addUser("user", "user@email.com", city1.getName());
        Utilizadores user2 = instance.addUser("user1", "user1@email.com", city1.getName());
        instance.checkInUserToCity(user1.getNickname(), city2.getName());
        instance.checkInUserToCity(user2.getNickname(), city2.getName());
        instance.checkInUserToCity(user1.getNickname(), city1.getName());
        ArrayList<Cidades> expResult = new ArrayList<>();
        instance.removeCitiesfromUserCheckIn(city1);
        expResult.add(city2);
        int expResult2 = city2.getPoints();
        assertEquals(expResult, user1.getCityList());
        assertEquals(expResult, user2.getCityList());
        assertEquals(expResult2, user1.getPoints());
        assertEquals(expResult2, user2.getPoints());
    }

    @Test
    public void UserPointsInCity() {
        System.out.println("getUserPointsInACity");
        Cidades city1 = new Cidades("Porto", 10, "314", "412");
        Cidades city2 = new Cidades("Lisboa", 5, "3412", "412");
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addCity(city2);
        Utilizadores user1 = instance.addUser("user1", "user1", city1.getName());
        instance.checkInUserToCity(user1.getNickname(), city2.getName());
        instance.checkInUserToCity(user1.getNickname(), city1.getName());
        int expResult = 0;
        int result = instance.getUserPointsInACity(user1, city1);
        for (int i = 0; i < user1.getCityList().size(); i++) {
            if (user1.getCityList().get(i).equals(city1)) {
                expResult = expResult + city1.getPoints();

            }
        }
        assertEquals(expResult, result);
    }

    @Test
    public void testUser() {
        System.out.println("testUser");
        Cidades city1 = new Cidades("Porto", 10, "4123", "5152");
        Utilizadores user1 = new Utilizadores("user1", "user1", city1);
        Utilizadores user2 = new Utilizadores("user2", "user2", city1);
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        instance.addUser("user1", "user1", city1.getName());
        boolean expResult = false;
        boolean result = instance.testUser(user2);
        assertEquals(expResult, result);

    }

    @Test
    public void addUser() {
        System.out.println("addUser");
        Cidades city1 = new Cidades("Porto", 10, "4312", "6457");
        Utilizadores user1 = new Utilizadores("user1", "user1", city1);
        Utilizadores user2 = new Utilizadores("user2", "user2", city1);
        RedeSocial instance = new RedeSocial();
        instance.addCity(city1);
        ArrayList<Utilizadores> expResult = new ArrayList<>();
        expResult.add(user1);
        instance.addUser("user1", "user1", city1.getName());
        ArrayList<Utilizadores> result = instance.getUsers();
        assertEquals(expResult, result);
    }

    @Test
    public void testNonConsecutives() {
        System.out.println("nonConsecutiveCities");

        Cidades city1 = new Cidades("Porto", 10, "5432", "654");
        Cidades city2 = new Cidades("Lisboa", 5, "5432", "54325");
        ArrayList<Cidades> cityList = new ArrayList<Cidades>();
        RedeSocial instance = new RedeSocial();
        ArrayList<Cidades> expResult = new ArrayList<Cidades>();

        cityList.add(city1);
        cityList.add(city2);
        cityList.add(city2);
        cityList.add(city1);
        cityList.add(city1);
        cityList.add(city2);
        //lista de cidades nao consecutivas
        ArrayList<Cidades> result = instance.nonConsecutiveCities(cityList);
        //adiciona as cities ao expectedresult de modo a ser nao consecutivas
        expResult.add(city1);
        expResult.add(city2);
        expResult.add(city1);
        expResult.add(city2);
        //testa tamanhos
        assertEquals(expResult, result);

        boolean test = true;
        for (int i = 0; i < result.size(); i++) {
            //se as duas cidades nao forem iguais entao retorna falso
            if (!result.get(i).equals(expResult.get(i))) {
                test = false;
            }
        }
        //testa se o valor do teste e true
        assertTrue(test);

    }

    public void testUserPointsAndCities() {
        System.out.println("UserPointsAndCities");

        Cidades city1 = new Cidades("City1", 10, "41", "41");
        Cidades city2 = new Cidades("City2", 1, "12", "21");
        Cidades city3 = new Cidades("City3", 6, "32", "41");
        Cidades city4 = new Cidades("City4", 8, "10", "55");
        Cidades city5 = new Cidades("City5", 12, "90", "21");
        Cidades city6 = new Cidades("City6", 18, "11", "32");
        Cidades city7 = new Cidades("City7", 7, "244", "244");
        Cidades city8 = new Cidades("City8", 4, "443", "112");

        Utilizadores user = new Utilizadores("user1", "user1@email", city1);
        RedeSocial instance = new RedeSocial();

        instance.addCity(city1);
        instance.addCity(city2);
        instance.addCity(city3);
        instance.addCity(city4);
        instance.addCity(city5);
        instance.addCity(city6);
        instance.addCity(city7);
        instance.addCity(city8);
        instance.addUser("user1", "user1", city1.getName());

        instance.checkInUserToCity(user.getNickname(), city2.getName());
        instance.checkInUserToCity(user.getNickname(), city3.getName());
        instance.checkInUserToCity(user.getNickname(), city1.getName());
        instance.checkInUserToCity(user.getNickname(), city6.getName());
        instance.checkInUserToCity(user.getNickname(), city2.getName());
        instance.checkInUserToCity(user.getNickname(), city8.getName());
        instance.checkInUserToCity(user.getNickname(), city1.getName());
        instance.checkInUserToCity(user.getNickname(), city2.getName());

        Map<String, Integer> result = instance.UserPointsAndCities(user.getNickname());

        Map<String, Integer> expResult = new HashMap<String, Integer>();
        expResult.put(user.getNickname(), user.getPoints());
        expResult.put(city1.getName(), city1.getPoints() * 3);
        expResult.put(city2.getName(), city2.getPoints() * 3);
        expResult.put(city3.getName(), city3.getPoints() * 1);
        expResult.put(city4.getName(), 0);
        expResult.put(city5.getName(), 0);
        expResult.put(city6.getName(), city6.getPoints() * 1);
        expResult.put(city7.getName(), 0);
        expResult.put(city8.getName(), city8.getPoints() * 1);

        assertEquals(expResult, result);

    }