Implement utf-8 module and improve testing.

src/back_end/src/core/macro.rs

@@ -0,0 +1,8 @@
+#[macro_export]
+macro_rules! ensure {
+    ($cond:expr, $err:expr) => {
+        if !$cond {
+            return $err;
+        }
+    };
+}

src/back_end/src/core/result_enum.rs

@@ -0,0 +1,8 @@
+#[derive(PartialEq, Eq, Debug)]
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub enum AllocResult {
+    OK,
+    NULL_DEFERENCE_ERR,
+    C_STRING_CONVERT_ERR,
+}

src/back_end/src/core/sha.rs

@@ -1,23 +1,21 @@
 use std::ffi::{CStr, CString, c_char};
 
+use crate::core::result_enum::AllocResult;
+use crate::ensure;
 use sha2::{Digest, Sha256};
 
-#[repr(C)]
-#[allow(non_camel_case_types)]
-pub enum GetShaResult {
-    OK,
-    C_STRING_CONVERT_ERR,
-}
-
 /// # Safety
 /// Careful with raw pointers.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn text_sha256(
     text: *const c_char,
     out: *mut *mut c_char,
-) -> GetShaResult {
+) -> AllocResult {
     unsafe {
-        use GetShaResult as R;
+        use AllocResult as R;
+
+        ensure!(!text.is_null(), R::NULL_DEFERENCE_ERR);
+        ensure!(!out.is_null(), R::NULL_DEFERENCE_ERR);
 
         let mut hasher = Sha256::new();
 

src/back_end/src/core/utf8.rs

@@ -0,0 +1,28 @@
+use std::ffi::{CStr, CString, c_char};
+
+use crate::{core::result_enum::AllocResult, ensure};
+
+#[unsafe(no_mangle)]
+/// # Safety
+/// Careful with raw pointers & memory leaks
+pub unsafe extern "C" fn to_utf8(
+    content: *const c_char,
+    out: *mut *mut c_char,
+) -> AllocResult {
+    use AllocResult as R;
+
+    unsafe {
+        ensure!(!content.is_null(), R::NULL_DEFERENCE_ERR);
+        ensure!(!content.is_null(), R::NULL_DEFERENCE_ERR);
+
+        let result_str = CStr::from_ptr(content).to_string_lossy();
+
+        let Ok(c_str) = CString::new(result_str.as_ref()) else {
+            return R::C_STRING_CONVERT_ERR;
+        };
+
+        *out = c_str.into_raw();
+
+        R::OK
+    }
+}

src/back_end/src/lib.rs

@@ -7,8 +7,11 @@ pub mod utils {
 }
 
 pub mod core {
+    pub mod r#macro;
+    pub mod result_enum;
     pub mod sha;
     pub mod sqlite;
+    pub mod utf8;
 }
 
 pub mod internal {

src/back_end/tests/utf8.rs

@@ -0,0 +1,61 @@
+#[test]
+/* Null deference beavior test. */
+fn test_utf8_null_dererence() {
+    use back_end::core::result_enum::AllocResult;
+    use back_end::core::utf8::to_utf8;
+    use std::ffi::c_char;
+    use std::ptr;
+
+    use AllocResult as R;
+
+    unsafe {
+        let mut output_null: *mut c_char = ptr::null_mut();
+        let result_null: *const c_char = ptr::null();
+
+        let result = to_utf8(result_null, &raw mut output_null);
+
+        assert_ne!(result, R::OK);
+        assert_ne!(result, R::C_STRING_CONVERT_ERR);
+        assert_eq!(result, R::NULL_DEFERENCE_ERR);
+    }
+}
+
+#[test]
+fn test_utf8() {
+    unsafe {
+        use back_end::core::result_enum::AllocResult;
+        use back_end::core::utf8::to_utf8;
+        use std::ffi::{CStr, CString, c_char};
+        use std::ptr::null_mut;
+
+        use AllocResult as R;
+
+        let mut out: *mut c_char = null_mut();
+        let content = CString::new(
+            "café 世界 🌍\n春の海　ひねもすのたり　のたりかな\nشكرا لك.\n
+            Cá trèo lên cây cao, khỉ bơi tung tăng mặt hồ!\n
+            Thấy em thật là vui khi không buồn và thật buồn khi mà không vui...\n
+            Anh nói với họ rằng, có kì lân thực sự và con gà nhà anh đã đấm chết một
+            con voi nặng 69 tấn nhưng họ lại bắt anh, anh tự hỏi vì sao nhỉ em?",
+        )
+        .unwrap();
+
+        let result = to_utf8(content.as_ptr(), &raw mut out);
+        let content_str = CStr::from_ptr(out).to_str().unwrap();
+
+        assert_ne!(result, R::C_STRING_CONVERT_ERR);
+        assert_ne!(result, R::NULL_DEFERENCE_ERR);
+        assert_eq!(result, R::OK);
+        assert!(!content_str.is_empty());
+        assert_eq!(
+            content_str,
+            "café 世界 🌍\n春の海　ひねもすのたり　のたりかな\nشكرا لك.\n
+            Cá trèo lên cây cao, khỉ bơi tung tăng mặt hồ!\n
+            Thấy em thật là vui khi không buồn và thật buồn khi mà không vui...\n
+            Anh nói với họ rằng, có kì lân thực sự và con gà nhà anh đã đấm chết một
+            con voi nặng 69 tấn nhưng họ lại bắt anh, anh tự hỏi vì sao nhỉ em?"
+        );
+
+        let _ = CString::from_raw(out);
+    }
+}

src/clipboard/include/content_types.hxx

@@ -0,0 +1,16 @@
+#ifndef CONTENT_TYPES_HXX
+#define CONTENT_TYPES_HXX
+
+#include <cstdint>
+using std::uint8_t;
+namespace Lazyboard::clipboard {
+enum class ContentTypes : uint8_t {
+	TEXT,
+	HTML,
+	URL,
+	PATH,
+	IMAGE,
+};
+}
+
+#endif

src/clipboard/include/text.hxx

@@ -0,0 +1,30 @@
+#ifndef TEXT_CLIPBOARD_HXX
+#define TEXT_CLIPBOARD_HXX
+#include <qclipboard.h>
+
+#include <memory>
+#include <string>
+
+#include "../../front_end_db/include/sqlite_manager.hxx"
+
+using Lazyboard::front_end_db::SQLiteManager;
+using std::string;
+using std::unique_ptr;
+
+namespace Lazyboard::clipboard {
+class TextClipboard {
+   private:
+	QClipboard *clipboard = nullptr;
+	unique_ptr<SQLiteManager> sqlite_manager;
+
+   private:
+	void save_to_cache();
+
+   public:
+	TextClipboard();
+	void on_changed();
+	string get();
+};
+}  // namespace Lazyboard::clipboard
+
+#endif	// TEXT_CLIPBOARD_HXX

src/clipboard/text.cxx

@@ -0,0 +1,35 @@
+#include "include/text.hxx"
+
+#include <qapplication.h>
+#include <qclipboard.h>
+#include <qobject.h>
+
+#include <memory>
+
+using Lazyboard::clipboard::TextClipboard;
+using Self = TextClipboard;
+using std::make_unique;
+
+Self::TextClipboard() {
+	if (!this->clipboard) {
+		this->clipboard = QApplication::clipboard();
+	}
+
+	sqlite_manager = make_unique<SQLiteManager>();
+}
+
+void Self::save_to_cache() {}
+
+void Self::on_changed() {
+	using O = QObject;
+
+	O::connect(this->clipboard, &QClipboard::dataChanged, [] {
+
+	});
+}
+
+string Self::get() {
+	auto clipboard_text = this->clipboard->text();
+
+	return clipboard_text.toStdString();
+}

tests-ffi/sha.cxx

@@ -5,17 +5,18 @@
 #include <string>
 
 // clang-format off
-enum class GetShaResult : uint8_t {
+enum class AllocResult : uint8_t {
 	OK,
+	NULL_DEFERENCE_ERR,
 	C_STRING_CONVERT_ERR
-};	 // clang-format on
-extern "C" GetShaResult text_sha256(const char* text, char** out);
+};	// clang-format on
+extern "C" AllocResult text_sha256(const char* text, char** out);
 extern "C" void raw_free_c_str(char* str);
 
 using std::string;
 
-int main() {
-	using R = GetShaResult;
+void test_success() {
+	using R = AllocResult;
 
 	const char* my_text = "Hello";
 	const char* real_result =
@@ -27,9 +28,49 @@ int main() {
 	raw_free_c_str(out);
 
 	assert(!hash_result.empty());
-	assert(result != R::C_STRING_CONVERT_ERR);
 	assert(hash_result == real_result);
+
+	assert(result != R::C_STRING_CONVERT_ERR);
+	assert(result != R::NULL_DEFERENCE_ERR);
+	assert(result == R::OK);
+}
+
+void test_deference_err() {
+	using R = AllocResult;
+
+	const char* my_text = nullptr;
+	char* out = nullptr;
+
+	auto result = text_sha256(my_text, nullptr);
+	raw_free_c_str(out);
+
+	assert(result != R::OK);
+	assert(result != R::C_STRING_CONVERT_ERR);
+	assert(result == R::NULL_DEFERENCE_ERR);
+}
+
+void test_sha_mismatch_err() {
+	using R = AllocResult;
+
+	const char* my_text = "Hello but my SHA will mismatch, to sad...";
+	const char* real_result = "185f8db32271fe25f561a6...";
+	char* out = nullptr;
+
+	auto result = text_sha256(my_text, &out);
+	string hash_result = string(out);
+	raw_free_c_str(out);
+
+	assert(result != R::C_STRING_CONVERT_ERR);
+	assert(result != R::NULL_DEFERENCE_ERR);
 	assert(result == R::OK);
 
+	assert(!hash_result.empty());
+	assert(hash_result != real_result);
+}
+
+int main() {
+	test_success();
+	test_deference_err();
+	test_sha_mismatch_err();
 	return 0;
 }