diff --git a/libc/string/main.c b/libc/string/main.c
index fa2843fa3..8623226e2 100644
--- a/libc/string/main.c
+++ b/libc/string/main.c
@@ -34,6 +34,7 @@ void runner(void)
 	RUN_TEST_GROUP(signal_psignal);
 	RUN_TEST_GROUP(string_cat);
 	RUN_TEST_GROUP(string_dup);
+	RUN_TEST_GROUP(string_spn);
 }
 
 
diff --git a/libc/string/string_lenchr.c b/libc/string/string_lenchr.c
index 5afc45d5a..bdf2cebd2 100644
--- a/libc/string/string_lenchr.c
+++ b/libc/string/string_lenchr.c
@@ -7,8 +7,8 @@
  * TESTED:
  *    - strlen()
  *    - strnlen()
- * 	- strchr()
- * 	- strrchr()
+ *    - strcspn()
+ *    - strspn()
  *    - strchr()
  *    - strrchr()
  *    - memchr()
@@ -34,6 +34,7 @@
 
 TEST_GROUP(string_len);
 TEST_GROUP(string_chr);
+TEST_GROUP(string_spn);
 
 
 TEST_SETUP(string_len)
@@ -148,6 +149,161 @@ TEST(string_len, big)
 */
 
 
+TEST_SETUP(string_spn)
+{
+}
+
+
+TEST_TEAR_DOWN(string_spn)
+{
+}
+
+TEST(string_spn, basic)
+{
+	const char pangram[] = " The quick brown fox jumps over the lazy dog";
+	char holder[45] = { 0 };
+	int sz;
+
+	/* Checking if both functions recognize the holder as a different set of elements */
+	sz = sizeof(pangram) - 1;
+
+	memcpy(holder, pangram, sz + 1);
+
+	/* Checking if both functions recognize holder as same set of elements */
+	TEST_ASSERT_EQUAL_INT(0, strcspn(pangram, holder));
+	TEST_ASSERT_EQUAL_INT(sz, strspn(pangram, holder));
+
+	TEST_ASSERT_EQUAL_INT(0, strcspn(pangram, &holder[sz / 2]));
+	/* One becouse strspn found space as*/
+	TEST_ASSERT_EQUAL_INT(1, strspn(pangram, &holder[sz / 2]));
+
+	TEST_ASSERT_EQUAL_INT(sz, strcspn(pangram, &holder[sz]));
+}
+
+
+TEST(string_spn, ascii)
+{
+	char supportCharSet[BUFF_SIZE] = { 0 },
+		 reversCharSet[BUFF_SIZE] = { 0 },
+		 *asciiStr;
+	int i;
+
+	asciiStr = testdata_createCharStr(BUFF_SIZE + 1);
+
+
+	for (i = 1; i < BUFF_SIZE; i++) {
+		supportCharSet[i - 1] = i;
+		reversCharSet[i - 1] = BUFF_SIZE - i;
+
+		/*
+		 * In this case we need to use fully filled set for strcspn
+		 * because it counts size based on elements that are not
+		 * present in himself
+		 */
+		TEST_ASSERT_EQUAL_INT(i - 1, strcspn(&asciiStr[1], &asciiStr[i]));
+		TEST_ASSERT_EQUAL_INT(i, strspn(&asciiStr[1], supportCharSet));
+
+		/* Checking if we reverse order strcspn and strspn will find elements that are correct */
+		TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 1, strcspn(&asciiStr[1], &reversCharSet[i]));
+
+		if (i == 127) {
+			TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 1, strspn(&asciiStr[1], reversCharSet));
+		}
+		else {
+			TEST_ASSERT_EQUAL_INT(0, strspn(&asciiStr[1], reversCharSet));
+		}
+	}
+
+	free((void *)asciiStr);
+}
+
+
+TEST(string_spn, not_ascii)
+{
+	unsigned char charSet[BUFF_SIZE] = { 0 };
+	int sz, i;
+
+	/* Checking  out of ASCII bytes */
+	for (i = sizeof(charSet); i < sizeof(charSet) * 2 - 1; i++) {
+		charSet[i - sizeof(charSet)] = i;
+	}
+
+	sz = sizeof(charSet) - 1;
+	TEST_ASSERT_EQUAL_INT(sz, strcspn((const char *)charSet, ""));
+	TEST_ASSERT_EQUAL_INT(sz, strspn((const char *)charSet, (const char *)charSet));
+}
+
+
+TEST(string_spn, big)
+{
+	char bigstr[PATH_MAX] = { 0 },
+		 support[PATH_MAX] = { 0 };
+	int sz;
+
+	/*
+	 * The length of the string is not restricted,
+	 * so we test one of the bigger values, which may be used
+	 * with remembering the last element must be a null term
+	 * zero to collect the data as the string from
+	 * declared space, that's why we memset one place less than its size
+	 */
+
+	sz = sizeof(bigstr) - 1;
+	memset(bigstr, 'a', sz);
+
+	TEST_ASSERT_EQUAL_INT(sz, strcspn(bigstr, ""));
+	TEST_ASSERT_EQUAL_INT(sz, strspn(bigstr, bigstr));
+
+	memcpy(support, bigstr, sz);
+	support[sz - 1] = 'b';
+	TEST_ASSERT_EQUAL_INT(sz, strspn(bigstr, support));
+
+	memset(support, 'b', sz);
+	support[sz - 1] = 'a';
+	TEST_ASSERT_EQUAL_INT(0, strcspn(bigstr, support));
+	support[sz - 1] = 'b';
+	TEST_ASSERT_EQUAL_INT(sz, strcspn(bigstr, support));
+}
+
+
+TEST(string_spn, empty_output)
+{
+	TEST_ASSERT_EQUAL_INT(0, strcspn("", "abc"));
+	TEST_ASSERT_EQUAL_INT(0, strspn("", "abc"));
+
+	TEST_ASSERT_EQUAL_INT(0, strcspn("", ""));
+	TEST_ASSERT_EQUAL_INT(0, strspn("", ""));
+}
+
+
+TEST(string_spn, mixed_order)
+{
+
+	char strHolder[BUFF_SIZE] = { 0 },
+		 supportSet[BUFF_SIZE] = { 0 };
+
+
+	TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "cba"));
+	TEST_ASSERT_EQUAL_INT(3, strspn("abc", "cba"));
+
+	memset(strHolder, 'a', BUFF_SIZE - 3);
+	strHolder[BUFF_SIZE - 2] = 'b';
+	memset(supportSet, 'b', BUFF_SIZE - 3);
+	supportSet[BUFF_SIZE - 2] = 'a';
+
+	TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 3, strcspn(strHolder, supportSet));
+	TEST_ASSERT_EQUAL_INT(0, strspn(strHolder, supportSet));
+
+	TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 3, strcspn(supportSet, strHolder));
+	TEST_ASSERT_EQUAL_INT(0, strspn(supportSet, strHolder));
+}
+
+
+/*
+////////////////////////////////////////////////////////////////////////////////////
+*/
+
+
 TEST_SETUP(string_chr)
 {
 }
@@ -400,6 +556,17 @@ TEST_GROUP_RUNNER(string_len)
 }
 
 
+TEST_GROUP_RUNNER(string_spn)
+{
+	RUN_TEST_CASE(string_spn, ascii);
+	RUN_TEST_CASE(string_spn, not_ascii);
+	RUN_TEST_CASE(string_spn, empty_output);
+	RUN_TEST_CASE(string_spn, mixed_order);
+	RUN_TEST_CASE(string_spn, basic);
+	RUN_TEST_CASE(string_spn, big);
+}
+
+
 TEST_GROUP_RUNNER(string_chr)
 {
 	RUN_TEST_CASE(string_chr, basic);