diff --git a/src/sparse_set.hpp b/src/sparse_set.hpp
index 3ef821f74..57f005790 100644
--- a/src/sparse_set.hpp
+++ b/src/sparse_set.hpp
@@ -165,8 +165,11 @@ class SparseSet<Index, Type> final: public SparseSet<Index> {
         std::sort(copy.begin(), copy.end(), compare);
 
         for(pos_type i = 0; i < copy.size(); ++i) {
-            SparseSet<Index>::swap(data + copy[i], data + i);
-            std::swap(instances[copy[i]], instances[i]);
+            if(copy[i] != i) {
+                SparseSet<Index>::swap(*(data + copy[i]), *(data + i));
+                std::swap(instances[copy[i]], instances[i]);
+                std::swap(copy[copy[i]], copy[i]);
+            }
         }
     }
 
@@ -215,7 +218,7 @@ public:
     }
 
     void swap(index_type lhs, index_type rhs) {
-        std::swap(SparseSet<Index>::get(lhs), SparseSet<Index>::get(rhs));
+        std::swap(instances[SparseSet<Index>::get(lhs)], instances[SparseSet<Index>::get(rhs)]);
         SparseSet<Index>::swap(lhs, rhs);
     }
 
diff --git a/test/sparse_set.cpp b/test/sparse_set.cpp
index 12eb4369a..324d15ba4 100644
--- a/test/sparse_set.cpp
+++ b/test/sparse_set.cpp
@@ -19,11 +19,6 @@ TEST(SparseSetNoType, Functionalities) {
     ASSERT_NE(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_TRUE(set.has(42));
-
-    auto begin = set.begin();
-
-    ASSERT_EQ(*begin, 42u);
-    ASSERT_EQ(++begin, set.end());
     ASSERT_EQ(set.get(42), 0u);
 
     ASSERT_EQ(set.destroy(42), 0u);
@@ -45,6 +40,49 @@ TEST(SparseSetNoType, Functionalities) {
     ASSERT_FALSE(set.has(42));
 }
 
+TEST(SparseSetNoType, DataBeginEnd) {
+    using SparseSet = entt::SparseSet<unsigned int>;
+
+    SparseSet set;
+
+    ASSERT_EQ(set.construct(3), 0u);
+    ASSERT_EQ(set.construct(12), 1u);
+    ASSERT_EQ(set.construct(42), 2u);
+
+    ASSERT_EQ(*(set.data() + 0u), 3u);
+    ASSERT_EQ(*(set.data() + 1u), 12u);
+    ASSERT_EQ(*(set.data() + 2u), 42u);
+
+    auto begin = set.begin();
+    auto end = set.end();
+
+    ASSERT_EQ(*(begin++), 42u);
+    ASSERT_EQ(*(begin++), 12u);
+    ASSERT_EQ(*(begin++), 3u);
+    ASSERT_EQ(begin, end);
+
+    set.reset();
+}
+
+TEST(SparseSetNoType, Swap) {
+    using SparseSet = entt::SparseSet<unsigned int>;
+
+    SparseSet set;
+
+    ASSERT_EQ(set.construct(3), 0u);
+    ASSERT_EQ(set.construct(12), 1u);
+
+    ASSERT_EQ(*(set.data() + 0u), 3u);
+    ASSERT_EQ(*(set.data() + 1u), 12u);
+
+    set.swap(3, 12);
+
+    ASSERT_EQ(*(set.data() + 0u), 12u);
+    ASSERT_EQ(*(set.data() + 1u), 3u);
+
+    set.reset();
+}
+
 TEST(SparseSetWithType, Functionalities) {
     using SparseSet = entt::SparseSet<unsigned int, int>;
 
@@ -63,12 +101,7 @@ TEST(SparseSetWithType, Functionalities) {
     ASSERT_NE(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_TRUE(set.has(42));
-
-    auto begin = set.begin();
-
-    ASSERT_EQ(*begin, 42u);
     ASSERT_EQ(set.get(42), 3);
-    ASSERT_EQ(++begin, set.end());
 
     set.destroy(42);
 
@@ -88,3 +121,78 @@ TEST(SparseSetWithType, Functionalities) {
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
 }
+
+TEST(SparseSetWithType, RawBeginEnd) {
+    using SparseSet = entt::SparseSet<unsigned int, int>;
+
+    SparseSet set;
+
+    ASSERT_EQ(set.construct(3, 3), 3);
+    ASSERT_EQ(set.construct(12, 6), 6);
+    ASSERT_EQ(set.construct(42, 9), 9);
+
+    ASSERT_EQ(*(set.raw() + 0u), 3);
+    ASSERT_EQ(*(set.raw() + 1u), 6);
+    ASSERT_EQ(*(set.raw() + 2u), 9);
+
+    auto begin = set.begin();
+    auto end = set.end();
+
+    ASSERT_EQ(set.get(*(begin++)), 9);
+    ASSERT_EQ(set.get(*(begin++)), 6);
+    ASSERT_EQ(set.get(*(begin++)), 3);
+    ASSERT_EQ(begin, end);
+
+    set.reset();
+}
+
+TEST(SparseSetWithType, Swap) {
+    using SparseSet = entt::SparseSet<unsigned int, int>;
+
+    SparseSet set;
+
+    ASSERT_EQ(set.construct(3, 3), 3);
+    ASSERT_EQ(set.construct(12, 6), 6);
+
+    ASSERT_EQ(*(set.raw() + 0u), 3);
+    ASSERT_EQ(*(set.raw() + 1u), 6);
+
+    set.swap(3, 12);
+
+    ASSERT_EQ(*(set.raw() + 0u), 6);
+    ASSERT_EQ(*(set.raw() + 1u), 3);
+
+    set.reset();
+}
+
+TEST(SparseSetWithType, SortBasic) {
+    using SparseSet = entt::SparseSet<unsigned int, int>;
+
+    SparseSet set;
+
+    ASSERT_EQ(set.construct(12, 6), 6);
+    ASSERT_EQ(set.construct(42, 9), 9);
+    ASSERT_EQ(set.construct(3, 3), 3);
+
+    set.sort([](auto lhs, auto rhs) {
+        return lhs < rhs;
+    });
+
+    ASSERT_EQ(*(set.raw() + 0u), 9);
+    ASSERT_EQ(*(set.raw() + 1u), 6);
+    ASSERT_EQ(*(set.raw() + 2u), 3);
+
+    auto begin = set.begin();
+    auto end = set.end();
+
+    ASSERT_EQ(set.get(*(begin++)), 3);
+    ASSERT_EQ(set.get(*(begin++)), 6);
+    ASSERT_EQ(set.get(*(begin++)), 9);
+    ASSERT_EQ(begin, end);
+
+    set.reset();
+}
+
+TEST(SparseSetWithType, SortAccordingTo) {
+    // TODO
+}