diff --git a/test/Audio/AlResource.cpp b/test/Audio/AlResource.cpp
new file mode 100644
index 00000000..819de7c3
--- /dev/null
+++ b/test/Audio/AlResource.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Audio/AlResource.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::AlResource>);
+static_assert(!std::is_copy_constructible_v<sf::AlResource>);
+static_assert(std::is_copy_assignable_v<sf::AlResource>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::AlResource>);
+static_assert(std::is_nothrow_move_assignable_v<sf::AlResource>);
diff --git a/test/Audio/Dummy.cpp b/test/Audio/Dummy.cpp
deleted file mode 100644
index e69de29b..00000000
diff --git a/test/Audio/InputSoundFile.cpp b/test/Audio/InputSoundFile.cpp
new file mode 100644
index 00000000..28a2758a
--- /dev/null
+++ b/test/Audio/InputSoundFile.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Audio/InputSoundFile.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::InputSoundFile>);
+static_assert(!std::is_copy_assignable_v<sf::InputSoundFile>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::InputSoundFile>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::InputSoundFile>);
diff --git a/test/Audio/Music.cpp b/test/Audio/Music.cpp
new file mode 100644
index 00000000..150771a1
--- /dev/null
+++ b/test/Audio/Music.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Audio/Music.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Music>);
+static_assert(!std::is_copy_assignable_v<sf::Music>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Music>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Music>);
diff --git a/test/Audio/OutputSoundFile.cpp b/test/Audio/OutputSoundFile.cpp
new file mode 100644
index 00000000..a2a259e1
--- /dev/null
+++ b/test/Audio/OutputSoundFile.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Audio/OutputSoundFile.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::OutputSoundFile>);
+static_assert(!std::is_copy_assignable_v<sf::OutputSoundFile>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::OutputSoundFile>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::OutputSoundFile>);
diff --git a/test/Audio/Sound.cpp b/test/Audio/Sound.cpp
new file mode 100644
index 00000000..727f3402
--- /dev/null
+++ b/test/Audio/Sound.cpp
@@ -0,0 +1,10 @@
+#include <SFML/Audio/Sound.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Sound>);
+static_assert(std::is_copy_assignable_v<sf::Sound>);
+static_assert(std::is_move_constructible_v<sf::Sound>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Sound>);
+static_assert(std::is_move_assignable_v<sf::Sound>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Sound>);
diff --git a/test/Audio/SoundBuffer.cpp b/test/Audio/SoundBuffer.cpp
new file mode 100644
index 00000000..c62ea06d
--- /dev/null
+++ b/test/Audio/SoundBuffer.cpp
@@ -0,0 +1,10 @@
+#include <SFML/Audio/SoundBuffer.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::SoundBuffer>);
+static_assert(std::is_copy_assignable_v<sf::SoundBuffer>);
+static_assert(std::is_move_constructible_v<sf::SoundBuffer>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::SoundBuffer>);
+static_assert(std::is_move_assignable_v<sf::SoundBuffer>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::SoundBuffer>);
diff --git a/test/Audio/SoundBufferRecorder.cpp b/test/Audio/SoundBufferRecorder.cpp
new file mode 100644
index 00000000..8f1c41db
--- /dev/null
+++ b/test/Audio/SoundBufferRecorder.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Audio/SoundBufferRecorder.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::SoundBufferRecorder>);
+static_assert(!std::is_copy_assignable_v<sf::SoundBufferRecorder>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::SoundBufferRecorder>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::SoundBufferRecorder>);
diff --git a/test/Audio/SoundRecorder.cpp b/test/Audio/SoundRecorder.cpp
new file mode 100644
index 00000000..571e0ab6
--- /dev/null
+++ b/test/Audio/SoundRecorder.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Audio/SoundRecorder.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::SoundRecorder>);
+static_assert(!std::is_copy_constructible_v<sf::SoundRecorder>);
+static_assert(!std::is_copy_assignable_v<sf::SoundRecorder>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::SoundRecorder>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::SoundRecorder>);
diff --git a/test/Audio/SoundSource.cpp b/test/Audio/SoundSource.cpp
new file mode 100644
index 00000000..4804e678
--- /dev/null
+++ b/test/Audio/SoundSource.cpp
@@ -0,0 +1,10 @@
+#include <SFML/Audio/SoundSource.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::SoundSource>);
+static_assert(!std::is_copy_constructible_v<sf::SoundSource>);
+static_assert(std::is_copy_assignable_v<sf::SoundSource>);
+static_assert(!std::is_move_constructible_v<sf::SoundSource>);
+static_assert(std::is_move_assignable_v<sf::SoundSource>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::SoundSource>);
diff --git a/test/Audio/SoundStream.cpp b/test/Audio/SoundStream.cpp
new file mode 100644
index 00000000..4438ccb0
--- /dev/null
+++ b/test/Audio/SoundStream.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Audio/SoundStream.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::SoundStream>);
+static_assert(!std::is_copy_constructible_v<sf::SoundStream>);
+static_assert(!std::is_copy_assignable_v<sf::SoundStream>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::SoundStream>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::SoundStream>);
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9b07ba72..03e4f98d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -30,6 +30,7 @@ set(SYSTEM_SRC
     System/Err.cpp
     System/FileInputStream.cpp
     System/MemoryInputStream.cpp
+    System/String.cpp
     System/Time.cpp
     System/Vector2.cpp
     System/Vector3.cpp
@@ -43,8 +44,13 @@ target_compile_definitions(test-sfml-system PRIVATE
 )
 
 set(WINDOW_SRC
+    Window/Context.cpp
     Window/ContextSettings.cpp
+    Window/Cursor.cpp
+    Window/GlResource.cpp
     Window/VideoMode.cpp
+    Window/Window.cpp
+    Window/WindowBase.cpp
 )
 sfml_add_test(test-sfml-window "${WINDOW_SRC}" SFML::Window)
 
@@ -53,28 +59,54 @@ set(GRAPHICS_SRC
     Graphics/CircleShape.cpp
     Graphics/Color.cpp
     Graphics/ConvexShape.cpp
+    Graphics/Drawable.cpp
+    Graphics/Font.cpp
     Graphics/Glyph.cpp
     Graphics/Image.cpp
     Graphics/Rect.cpp
     Graphics/RectangleShape.cpp
-    Graphics/Shape.cpp
     Graphics/RenderStates.cpp
+    Graphics/RenderTarget.cpp
+    Graphics/RenderTexture.cpp
+    Graphics/RenderWindow.cpp
+    Graphics/Shader.cpp
+    Graphics/Shape.cpp
+    Graphics/Sprite.cpp
+    Graphics/Text.cpp
+    Graphics/Texture.cpp
     Graphics/Transform.cpp
     Graphics/Transformable.cpp
     Graphics/Vertex.cpp
     Graphics/VertexArray.cpp
+    Graphics/VertexBuffer.cpp
     Graphics/View.cpp
 )
 sfml_add_test(test-sfml-graphics "${GRAPHICS_SRC}" SFML::Graphics)
 
 set(NETWORK_SRC
+    Network/Ftp.cpp
+    Network/Http.cpp
     Network/IpAddress.cpp
     Network/Packet.cpp
+    Network/Socket.cpp
+    Network/SocketSelector.cpp
+    Network/TcpListener.cpp
+    Network/TcpSocket.cpp
+    Network/UdpSocket.cpp
 )
 sfml_add_test(test-sfml-network "${NETWORK_SRC}" SFML::Network)
 
 set(AUDIO_SRC
-    Audio/Dummy.cpp # TODO: Remove when there are real tests
+    Audio/AlResource.cpp
+    Audio/InputSoundFile.cpp
+    Audio/Music.cpp
+    Audio/OutputSoundFile.cpp
+    Audio/Sound.cpp
+    Audio/SoundBuffer.cpp
+    Audio/SoundBufferRecorder.cpp
+    Audio/SoundRecorder.cpp
+    Audio/SoundSource.cpp
+    Audio/SoundStream.cpp
 )
 sfml_add_test(test-sfml-audio "${AUDIO_SRC}" SFML::Audio)
 
diff --git a/test/Graphics/BlendMode.cpp b/test/Graphics/BlendMode.cpp
index 378d4ab3..b187b005 100644
--- a/test/Graphics/BlendMode.cpp
+++ b/test/Graphics/BlendMode.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::BlendMode>);
+static_assert(std::is_copy_assignable_v<sf::BlendMode>);
+static_assert(std::is_nothrow_move_constructible_v<sf::BlendMode>);
+static_assert(std::is_nothrow_move_assignable_v<sf::BlendMode>);
 
 TEST_CASE("[Graphics] sf::BlendMode")
 {
diff --git a/test/Graphics/CircleShape.cpp b/test/Graphics/CircleShape.cpp
index c5dcf7a2..3f766126 100644
--- a/test/Graphics/CircleShape.cpp
+++ b/test/Graphics/CircleShape.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <SystemUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::CircleShape>);
+static_assert(std::is_copy_assignable_v<sf::CircleShape>);
+static_assert(std::is_move_constructible_v<sf::CircleShape>);
+static_assert(std::is_move_assignable_v<sf::CircleShape>);
 
 TEST_CASE("[Graphics] sf::CircleShape")
 {
diff --git a/test/Graphics/Color.cpp b/test/Graphics/Color.cpp
index f7b77a2c..0ed31eb3 100644
--- a/test/Graphics/Color.cpp
+++ b/test/Graphics/Color.cpp
@@ -3,8 +3,14 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
 #include <vector>
 
+static_assert(std::is_copy_constructible_v<sf::Color>);
+static_assert(std::is_copy_assignable_v<sf::Color>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Color>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Color>);
+
 TEST_CASE("[Graphics] sf::Color")
 {
     SUBCASE("Construction")
diff --git a/test/Graphics/ConvexShape.cpp b/test/Graphics/ConvexShape.cpp
index 449214a1..04e7cbb9 100644
--- a/test/Graphics/ConvexShape.cpp
+++ b/test/Graphics/ConvexShape.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <SystemUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::ConvexShape>);
+static_assert(std::is_copy_assignable_v<sf::ConvexShape>);
+static_assert(std::is_move_constructible_v<sf::ConvexShape>);
+static_assert(std::is_move_assignable_v<sf::ConvexShape>);
 
 TEST_CASE("[Graphics] sf::ConvexShape")
 {
diff --git a/test/Graphics/Drawable.cpp b/test/Graphics/Drawable.cpp
new file mode 100644
index 00000000..961acc8c
--- /dev/null
+++ b/test/Graphics/Drawable.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Graphics/Drawable.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::Drawable>);
+static_assert(!std::is_copy_constructible_v<sf::Drawable>);
+static_assert(std::is_copy_assignable_v<sf::Drawable>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Drawable>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Drawable>);
diff --git a/test/Graphics/Font.cpp b/test/Graphics/Font.cpp
new file mode 100644
index 00000000..6cbf1fcd
--- /dev/null
+++ b/test/Graphics/Font.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Graphics/Font.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Font>);
+static_assert(std::is_copy_assignable_v<sf::Font>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Font>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Font>);
diff --git a/test/Graphics/Glyph.cpp b/test/Graphics/Glyph.cpp
index 0885c750..cf59c575 100644
--- a/test/Graphics/Glyph.cpp
+++ b/test/Graphics/Glyph.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Glyph>);
+static_assert(std::is_copy_assignable_v<sf::Glyph>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Glyph>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Glyph>);
 
 TEST_CASE("[Graphics] sf::Glyph")
 {
diff --git a/test/Graphics/Image.cpp b/test/Graphics/Image.cpp
index 3f9b5aa2..107959eb 100644
--- a/test/Graphics/Image.cpp
+++ b/test/Graphics/Image.cpp
@@ -4,6 +4,12 @@
 
 #include <GraphicsUtil.hpp>
 #include <array>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Image>);
+static_assert(std::is_copy_assignable_v<sf::Image>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Image>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Image>);
 
 TEST_CASE("[Graphics] sf::Image")
 {
diff --git a/test/Graphics/Rect.cpp b/test/Graphics/Rect.cpp
index 78a0208d..5daeb529 100644
--- a/test/Graphics/Rect.cpp
+++ b/test/Graphics/Rect.cpp
@@ -4,6 +4,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::IntRect>);
+static_assert(std::is_copy_assignable_v<sf::IntRect>);
+static_assert(std::is_nothrow_move_constructible_v<sf::IntRect>);
+static_assert(std::is_nothrow_move_assignable_v<sf::IntRect>);
 
 TEST_CASE("[Graphics] sf::Rect")
 {
diff --git a/test/Graphics/RectangleShape.cpp b/test/Graphics/RectangleShape.cpp
index cb672c12..0a49d23a 100644
--- a/test/Graphics/RectangleShape.cpp
+++ b/test/Graphics/RectangleShape.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <SystemUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::RectangleShape>);
+static_assert(std::is_copy_assignable_v<sf::RectangleShape>);
+static_assert(std::is_move_constructible_v<sf::RectangleShape>);
+static_assert(std::is_move_assignable_v<sf::RectangleShape>);
 
 TEST_CASE("[Graphics] sf::RectangleShape")
 {
diff --git a/test/Graphics/RenderStates.cpp b/test/Graphics/RenderStates.cpp
index dc4c5be9..60d66425 100644
--- a/test/Graphics/RenderStates.cpp
+++ b/test/Graphics/RenderStates.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::RenderStates>);
+static_assert(std::is_copy_assignable_v<sf::RenderStates>);
+static_assert(std::is_nothrow_move_constructible_v<sf::RenderStates>);
+static_assert(std::is_nothrow_move_assignable_v<sf::RenderStates>);
 
 TEST_CASE("[Graphics] sf::RenderStates")
 {
diff --git a/test/Graphics/RenderTarget.cpp b/test/Graphics/RenderTarget.cpp
new file mode 100644
index 00000000..bb7f1302
--- /dev/null
+++ b/test/Graphics/RenderTarget.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Graphics/RenderTarget.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::RenderTarget>);
+static_assert(!std::is_copy_constructible_v<sf::RenderTarget>);
+static_assert(!std::is_copy_assignable_v<sf::RenderTarget>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::RenderTarget>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::RenderTarget>);
diff --git a/test/Graphics/RenderTexture.cpp b/test/Graphics/RenderTexture.cpp
new file mode 100644
index 00000000..4799e058
--- /dev/null
+++ b/test/Graphics/RenderTexture.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Graphics/RenderTexture.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::RenderTexture>);
+static_assert(!std::is_copy_assignable_v<sf::RenderTexture>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::RenderTexture>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::RenderTexture>);
diff --git a/test/Graphics/RenderWindow.cpp b/test/Graphics/RenderWindow.cpp
new file mode 100644
index 00000000..441c996c
--- /dev/null
+++ b/test/Graphics/RenderWindow.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Graphics/RenderWindow.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::RenderWindow>);
+static_assert(!std::is_copy_assignable_v<sf::RenderWindow>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::RenderWindow>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::RenderWindow>);
diff --git a/test/Graphics/Shader.cpp b/test/Graphics/Shader.cpp
new file mode 100644
index 00000000..4008895b
--- /dev/null
+++ b/test/Graphics/Shader.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Graphics/Shader.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Shader>);
+static_assert(!std::is_copy_assignable_v<sf::Shader>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Shader>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Shader>);
diff --git a/test/Graphics/Shape.cpp b/test/Graphics/Shape.cpp
index 49a06476..41142628 100644
--- a/test/Graphics/Shape.cpp
+++ b/test/Graphics/Shape.cpp
@@ -3,6 +3,13 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::Shape>);
+static_assert(!std::is_copy_constructible_v<sf::Shape>);
+static_assert(std::is_copy_assignable_v<sf::Shape>);
+static_assert(!std::is_move_constructible_v<sf::Shape>);
+static_assert(std::is_move_assignable_v<sf::Shape>);
 
 class TriangleShape : public sf::Shape
 {
diff --git a/test/Graphics/Sprite.cpp b/test/Graphics/Sprite.cpp
new file mode 100644
index 00000000..3f74ed00
--- /dev/null
+++ b/test/Graphics/Sprite.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Graphics/Sprite.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Sprite>);
+static_assert(std::is_copy_assignable_v<sf::Sprite>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Sprite>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Sprite>);
diff --git a/test/Graphics/Text.cpp b/test/Graphics/Text.cpp
new file mode 100644
index 00000000..9cf10197
--- /dev/null
+++ b/test/Graphics/Text.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Graphics/Text.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Text>);
+static_assert(std::is_copy_assignable_v<sf::Text>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Text>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Text>);
diff --git a/test/Graphics/Texture.cpp b/test/Graphics/Texture.cpp
new file mode 100644
index 00000000..c48fbcd4
--- /dev/null
+++ b/test/Graphics/Texture.cpp
@@ -0,0 +1,10 @@
+#include <SFML/Graphics/Texture.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Texture>);
+static_assert(std::is_copy_assignable_v<sf::Texture>);
+static_assert(std::is_move_constructible_v<sf::Texture>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Texture>);
+static_assert(std::is_move_assignable_v<sf::Texture>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Texture>);
diff --git a/test/Graphics/Transform.cpp b/test/Graphics/Transform.cpp
index 30d778a1..e38f1576 100644
--- a/test/Graphics/Transform.cpp
+++ b/test/Graphics/Transform.cpp
@@ -5,8 +5,14 @@
 
 #include <GraphicsUtil.hpp>
 #include <cassert>
+#include <type_traits>
 #include <vector>
 
+static_assert(std::is_copy_constructible_v<sf::Transform>);
+static_assert(std::is_copy_assignable_v<sf::Transform>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Transform>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Transform>);
+
 // Use StringMaker to avoid opening namespace std
 namespace doctest
 {
diff --git a/test/Graphics/Transformable.cpp b/test/Graphics/Transformable.cpp
index 5f7bb0d6..c2b727a0 100644
--- a/test/Graphics/Transformable.cpp
+++ b/test/Graphics/Transformable.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Transformable>);
+static_assert(std::is_copy_assignable_v<sf::Transformable>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Transformable>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Transformable>);
 
 TEST_CASE("[Graphics] sf::Transformable")
 {
diff --git a/test/Graphics/Vertex.cpp b/test/Graphics/Vertex.cpp
index 20207c7f..5b7695a4 100644
--- a/test/Graphics/Vertex.cpp
+++ b/test/Graphics/Vertex.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Vertex>);
+static_assert(std::is_copy_assignable_v<sf::Vertex>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Vertex>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Vertex>);
 
 TEST_CASE("[Graphics] sf::Vertex")
 {
diff --git a/test/Graphics/VertexArray.cpp b/test/Graphics/VertexArray.cpp
index 31014b10..320a164f 100644
--- a/test/Graphics/VertexArray.cpp
+++ b/test/Graphics/VertexArray.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::VertexArray>);
+static_assert(std::is_copy_assignable_v<sf::VertexArray>);
+static_assert(std::is_nothrow_move_constructible_v<sf::VertexArray>);
+static_assert(std::is_nothrow_move_assignable_v<sf::VertexArray>);
 
 TEST_CASE("[Graphics] sf::VertexArray")
 {
diff --git a/test/Graphics/VertexBuffer.cpp b/test/Graphics/VertexBuffer.cpp
new file mode 100644
index 00000000..145d15a8
--- /dev/null
+++ b/test/Graphics/VertexBuffer.cpp
@@ -0,0 +1,10 @@
+#include <SFML/Graphics/VertexBuffer.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::VertexBuffer>);
+static_assert(std::is_copy_assignable_v<sf::VertexBuffer>);
+static_assert(std::is_move_constructible_v<sf::VertexBuffer>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::VertexBuffer>);
+static_assert(std::is_move_assignable_v<sf::VertexBuffer>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::VertexBuffer>);
diff --git a/test/Graphics/View.cpp b/test/Graphics/View.cpp
index e996d2aa..e1411e6c 100644
--- a/test/Graphics/View.cpp
+++ b/test/Graphics/View.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <GraphicsUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::View>);
+static_assert(std::is_copy_assignable_v<sf::View>);
+static_assert(std::is_nothrow_move_constructible_v<sf::View>);
+static_assert(std::is_nothrow_move_assignable_v<sf::View>);
 
 TEST_CASE("[Graphics] sf::View")
 {
diff --git a/test/Network/Ftp.cpp b/test/Network/Ftp.cpp
new file mode 100644
index 00000000..a74396ce
--- /dev/null
+++ b/test/Network/Ftp.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Network/Ftp.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Ftp>);
+static_assert(!std::is_copy_assignable_v<sf::Ftp>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Ftp>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Ftp>);
diff --git a/test/Network/Http.cpp b/test/Network/Http.cpp
new file mode 100644
index 00000000..71e8cc65
--- /dev/null
+++ b/test/Network/Http.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Network/Http.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Http>);
+static_assert(!std::is_copy_assignable_v<sf::Http>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Http>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Http>);
diff --git a/test/Network/IpAddress.cpp b/test/Network/IpAddress.cpp
index 028190cd..6bff52d3 100644
--- a/test/Network/IpAddress.cpp
+++ b/test/Network/IpAddress.cpp
@@ -4,10 +4,16 @@
 
 #include <sstream>
 #include <string_view>
+#include <type_traits>
 
 using namespace std::string_literals;
 using namespace std::string_view_literals;
 
+static_assert(std::is_copy_constructible_v<sf::IpAddress>);
+static_assert(std::is_copy_assignable_v<sf::IpAddress>);
+static_assert(std::is_nothrow_move_constructible_v<sf::IpAddress>);
+static_assert(std::is_nothrow_move_assignable_v<sf::IpAddress>);
+
 TEST_CASE("[Network] sf::IpAddress")
 {
     SUBCASE("Construction")
diff --git a/test/Network/Packet.cpp b/test/Network/Packet.cpp
index a6a569ac..4f603cdd 100644
--- a/test/Network/Packet.cpp
+++ b/test/Network/Packet.cpp
@@ -4,6 +4,12 @@
 
 #include <array>
 #include <limits>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Packet>);
+static_assert(std::is_copy_assignable_v<sf::Packet>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Packet>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Packet>);
 
 #define CHECK_PACKET_STREAM_OPERATORS(expected)              \
     do                                                       \
diff --git a/test/Network/Socket.cpp b/test/Network/Socket.cpp
new file mode 100644
index 00000000..7493a55e
--- /dev/null
+++ b/test/Network/Socket.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Network/Socket.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::Socket>);
+static_assert(!std::is_copy_constructible_v<sf::Socket>);
+static_assert(!std::is_copy_assignable_v<sf::Socket>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Socket>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Socket>);
diff --git a/test/Network/SocketSelector.cpp b/test/Network/SocketSelector.cpp
new file mode 100644
index 00000000..0a7eee6c
--- /dev/null
+++ b/test/Network/SocketSelector.cpp
@@ -0,0 +1,10 @@
+#include <SFML/Network/SocketSelector.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::SocketSelector>);
+static_assert(std::is_copy_assignable_v<sf::SocketSelector>);
+static_assert(std::is_move_constructible_v<sf::SocketSelector>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::SocketSelector>);
+static_assert(std::is_move_assignable_v<sf::SocketSelector>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::SocketSelector>);
diff --git a/test/Network/TcpListener.cpp b/test/Network/TcpListener.cpp
new file mode 100644
index 00000000..bcb242d3
--- /dev/null
+++ b/test/Network/TcpListener.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Network/TcpListener.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::TcpListener>);
+static_assert(!std::is_copy_assignable_v<sf::TcpListener>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::TcpListener>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::TcpListener>);
diff --git a/test/Network/TcpSocket.cpp b/test/Network/TcpSocket.cpp
new file mode 100644
index 00000000..aeee20ba
--- /dev/null
+++ b/test/Network/TcpSocket.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Network/TcpSocket.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::TcpSocket>);
+static_assert(!std::is_copy_assignable_v<sf::TcpSocket>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::TcpSocket>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::TcpSocket>);
diff --git a/test/Network/UdpSocket.cpp b/test/Network/UdpSocket.cpp
new file mode 100644
index 00000000..f1016ec3
--- /dev/null
+++ b/test/Network/UdpSocket.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Network/UdpSocket.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::UdpSocket>);
+static_assert(!std::is_copy_assignable_v<sf::UdpSocket>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::UdpSocket>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::UdpSocket>);
diff --git a/test/System/Angle.cpp b/test/System/Angle.cpp
index 4db2f2e6..e838346c 100644
--- a/test/System/Angle.cpp
+++ b/test/System/Angle.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <SystemUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Angle>);
+static_assert(std::is_copy_assignable_v<sf::Angle>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Angle>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Angle>);
 
 TEST_CASE("[System] sf::Angle")
 {
diff --git a/test/System/Clock.cpp b/test/System/Clock.cpp
index 114253e7..72e2d764 100644
--- a/test/System/Clock.cpp
+++ b/test/System/Clock.cpp
@@ -5,6 +5,12 @@
 
 #include <SystemUtil.hpp>
 #include <thread>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Clock>);
+static_assert(std::is_copy_assignable_v<sf::Clock>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Clock>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Clock>);
 
 TEST_CASE("[System] sf::Clock")
 {
diff --git a/test/System/String.cpp b/test/System/String.cpp
new file mode 100644
index 00000000..a6d3c01f
--- /dev/null
+++ b/test/System/String.cpp
@@ -0,0 +1,8 @@
+#include <SFML/System/String.hpp>
+
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::String>);
+static_assert(std::is_copy_assignable_v<sf::String>);
+static_assert(std::is_nothrow_move_constructible_v<sf::String>);
+static_assert(std::is_nothrow_move_assignable_v<sf::String>);
diff --git a/test/System/Time.cpp b/test/System/Time.cpp
index 38eba463..ca9e99c1 100644
--- a/test/System/Time.cpp
+++ b/test/System/Time.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <SystemUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::Time>);
+static_assert(std::is_copy_assignable_v<sf::Time>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Time>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Time>);
 
 using namespace std::chrono_literals;
 
diff --git a/test/System/Vector2.cpp b/test/System/Vector2.cpp
index 0dc32cd4..489a02e7 100644
--- a/test/System/Vector2.cpp
+++ b/test/System/Vector2.cpp
@@ -11,6 +11,10 @@ using namespace sf::Literals;
 // Use sf::Vector2i for tests (except for float vector algebra).
 // Test coverage is given, as there are no template specializations.
 
+static_assert(std::is_copy_constructible_v<sf::Vector2i>);
+static_assert(std::is_copy_assignable_v<sf::Vector2i>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Vector2i>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Vector2i>);
 
 TEST_CASE("[System] sf::Vector2")
 {
diff --git a/test/System/Vector3.cpp b/test/System/Vector3.cpp
index 92cb977a..119db574 100644
--- a/test/System/Vector3.cpp
+++ b/test/System/Vector3.cpp
@@ -8,6 +8,11 @@
 // Use sf::Vector3i for tests (except for float vector algebra).
 // Test coverage is given, as there are no template specializations.
 
+static_assert(std::is_copy_constructible_v<sf::Vector3i>);
+static_assert(std::is_copy_assignable_v<sf::Vector3i>);
+static_assert(std::is_nothrow_move_constructible_v<sf::Vector3i>);
+static_assert(std::is_nothrow_move_assignable_v<sf::Vector3i>);
+
 TEST_CASE("[System] sf::Vector3")
 {
     SUBCASE("Construction")
diff --git a/test/Window/Context.cpp b/test/Window/Context.cpp
new file mode 100644
index 00000000..57f5bee5
--- /dev/null
+++ b/test/Window/Context.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Window/Context.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Context>);
+static_assert(!std::is_copy_assignable_v<sf::Context>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Context>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Context>);
diff --git a/test/Window/ContextSettings.cpp b/test/Window/ContextSettings.cpp
index 23cb06da..94227690 100644
--- a/test/Window/ContextSettings.cpp
+++ b/test/Window/ContextSettings.cpp
@@ -2,6 +2,13 @@
 
 #include <doctest/doctest.h>
 
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::ContextSettings>);
+static_assert(std::is_copy_assignable_v<sf::ContextSettings>);
+static_assert(std::is_nothrow_move_constructible_v<sf::ContextSettings>);
+static_assert(std::is_nothrow_move_assignable_v<sf::ContextSettings>);
+
 TEST_CASE("[Window] sf::ContextSettings")
 {
     SUBCASE("Construction")
diff --git a/test/Window/Cursor.cpp b/test/Window/Cursor.cpp
new file mode 100644
index 00000000..ca93af0b
--- /dev/null
+++ b/test/Window/Cursor.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Window/Cursor.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Cursor>);
+static_assert(!std::is_copy_assignable_v<sf::Cursor>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Cursor>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Cursor>);
diff --git a/test/Window/GlResource.cpp b/test/Window/GlResource.cpp
new file mode 100644
index 00000000..d0a0872d
--- /dev/null
+++ b/test/Window/GlResource.cpp
@@ -0,0 +1,9 @@
+#include <SFML/Window/GlResource.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_constructible_v<sf::GlResource>);
+static_assert(!std::is_copy_constructible_v<sf::GlResource>);
+static_assert(std::is_copy_assignable_v<sf::GlResource>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::GlResource>);
+static_assert(std::is_nothrow_move_assignable_v<sf::GlResource>);
diff --git a/test/Window/VideoMode.cpp b/test/Window/VideoMode.cpp
index afe8e119..866719d0 100644
--- a/test/Window/VideoMode.cpp
+++ b/test/Window/VideoMode.cpp
@@ -3,6 +3,12 @@
 #include <doctest/doctest.h>
 
 #include <WindowUtil.hpp>
+#include <type_traits>
+
+static_assert(std::is_copy_constructible_v<sf::VideoMode>);
+static_assert(std::is_copy_assignable_v<sf::VideoMode>);
+static_assert(std::is_nothrow_move_constructible_v<sf::VideoMode>);
+static_assert(std::is_nothrow_move_assignable_v<sf::VideoMode>);
 
 TEST_CASE("[Window] sf::VideoMode")
 {
diff --git a/test/Window/Window.cpp b/test/Window/Window.cpp
new file mode 100644
index 00000000..e778c569
--- /dev/null
+++ b/test/Window/Window.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Window/Window.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::Window>);
+static_assert(!std::is_copy_assignable_v<sf::Window>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::Window>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::Window>);
diff --git a/test/Window/WindowBase.cpp b/test/Window/WindowBase.cpp
new file mode 100644
index 00000000..63032aa4
--- /dev/null
+++ b/test/Window/WindowBase.cpp
@@ -0,0 +1,8 @@
+#include <SFML/Window/WindowBase.hpp>
+
+#include <type_traits>
+
+static_assert(!std::is_copy_constructible_v<sf::WindowBase>);
+static_assert(!std::is_copy_assignable_v<sf::WindowBase>);
+static_assert(!std::is_nothrow_move_constructible_v<sf::WindowBase>);
+static_assert(!std::is_nothrow_move_assignable_v<sf::WindowBase>);