diff --git a/test/test_arraylist.c b/test/test_arraylist.c
index 1108a92..56b51dc 100644
--- a/test/test_arraylist.c
+++ b/test/test_arraylist.c
@@ -695,6 +695,194 @@ static void test_remove_at_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+// Get
+static void test_get_valid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
+    assert_uint_equal(m, 6);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_first_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, 0);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_last_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(m, 9);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_invalid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_OUT_OF_BOUNDS);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_get_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+
+    int m;
+    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG);
+}
+
+static void test_get_null_out(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    assert_uint_equal(arraylist_get(arr, 8, NULL), ARRLIST_NULL_ARG);
+
+    arraylist_destroy(&arr);
+}
+
+// Set
+static void test_set_valid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 6, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_first_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 0, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_last_element(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 9, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_invalid_index(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_set_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG);
+
+}
+
+static void test_set_null_data(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);
+
+    arraylist_destroy(&arr);
+}
+
 int main(void) {
     const struct CMUnitTest init[] = {
         cmocka_unit_test(test_init_valid_parameters),
@@ -768,6 +956,24 @@ int main(void) {
         cmocka_unit_test(test_remove_at_null_data),
     };
 
+    const struct CMUnitTest get[] = {
+        cmocka_unit_test(test_get_valid_index),
+        cmocka_unit_test(test_get_first_element),
+        cmocka_unit_test(test_get_last_element),
+        cmocka_unit_test(test_get_invalid_index),
+        cmocka_unit_test(test_get_null_array),
+        cmocka_unit_test(test_get_null_out),
+    };
+
+    const struct CMUnitTest set[] = {
+        cmocka_unit_test(test_set_valid_index),
+        cmocka_unit_test(test_set_first_element),
+        cmocka_unit_test(test_set_last_element),
+        cmocka_unit_test(test_set_invalid_index),
+        cmocka_unit_test(test_set_null_array),
+        cmocka_unit_test(test_set_null_data),
+    };
+
     int rc = 0;
 
     rc += cmocka_run_group_tests(init, NULL, NULL);
@@ -779,6 +985,8 @@ int main(void) {
     rc += cmocka_run_group_tests(pop_back, NULL, NULL);
     rc += cmocka_run_group_tests(pop_front, NULL, NULL);
     rc += cmocka_run_group_tests(remove_at, NULL, NULL);
+    rc += cmocka_run_group_tests(get, NULL, NULL);
+    rc += cmocka_run_group_tests(set, NULL, NULL);
 
     return rc;
 }