diff --git a/nirjas/languages/tests/__init__.py b/nirjas/languages/tests/__init__.py
index e69de29..f2c451b 100644
--- a/nirjas/languages/tests/__init__.py
+++ b/nirjas/languages/tests/__init__.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Test scripts for Nirjas
+'''
diff --git a/nirjas/languages/tests/test_c.py b/nirjas/languages/tests/test_c.py
index cf00afc..4c15363 100644
--- a/nirjas/languages/tests/test_c.py
+++ b/nirjas/languages/tests/test_c.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import c
@@ -5,28 +25,38 @@
 
 
 class CTest(unittest.TestCase):
+    '''
+    Test cases for C language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.c")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        sign = '//'
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        comment_single = c.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = c.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSinglelines = c.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                                syntax_end)
+        comment_contSinglelines = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSinglelines)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = "*/"
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = "*/"
         expected = c.cExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSinglelines = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,20 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSinglelines:
-            for idx, i in enumerate(comment_contSinglelines[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSinglelines[1][idx], "end_line": comment_contSinglelines[2][idx], "comment": comment_contSinglelines[3][idx]})
+            for idx, _ in enumerate(comment_contSinglelines[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSinglelines[1][idx],
+                  "end_line": comment_contSinglelines[2][idx],
+                  "comment": comment_contSinglelines[3][idx]})
 
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = c.cSource(self.testfile, name)
 
         self.assertTrue(newfile)
-
diff --git a/nirjas/languages/tests/test_c_sharp.py b/nirjas/languages/tests/test_c_sharp.py
index 45d712e..e8f6bbf 100644
--- a/nirjas/languages/tests/test_c_sharp.py
+++ b/nirjas/languages/tests/test_c_sharp.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import c_sharp
@@ -5,29 +25,39 @@
 
 
 class CSharpTest(unittest.TestCase):
+    '''
+    Test cases for C Sharp language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cs")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = c_sharp.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = c_sharp.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = c_sharp.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
 
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = c_sharp.c_sharpExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -52,16 +82,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = c_sharp.c_sharpSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_cpp.py b/nirjas/languages/tests/test_cpp.py
index 3a87363..d67cbd8 100644
--- a/nirjas/languages/tests/test_cpp.py
+++ b/nirjas/languages/tests/test_cpp.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import cpp
@@ -5,28 +25,38 @@
 
 
 class CPPTest(unittest.TestCase):
+    '''
+    Test cases for C++ language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cpp")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = cpp.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = cpp.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = cpp.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                                  syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = cpp.cppExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,19 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = cpp.cppSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_css.py b/nirjas/languages/tests/test_css.py
index fab34c6..0ead41d 100644
--- a/nirjas/languages/tests/test_css.py
+++ b/nirjas/languages/tests/test_css.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import css
@@ -5,20 +25,32 @@
 
 
 class CssTest(unittest.TestCase):
+    '''
+    Test cases for CSS language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.css")
 
     def test_output(self):
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        comment_multiline = css.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        '''
+        Check for the scan correctness.
+        '''
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
 
         self.assertTrue(comment_multiline)
 
     def test_outputFormat(self):
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
+        '''
+        Check for the output format correctness.
+        '''
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = css.cssExtractor(self.testfile).get_dict()
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         file = self.testfile.split("/")
         output = {
         "metadata": {
@@ -34,15 +66,19 @@ def test_outputFormat(self):
         "multi_line_comment": []
         }
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = css.cssSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_dart.py b/nirjas/languages/tests/test_dart.py
index 616a02b..477c575 100644
--- a/nirjas/languages/tests/test_dart.py
+++ b/nirjas/languages/tests/test_dart.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 '''
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
@@ -25,18 +27,25 @@
 
 
 class DartTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.dart")
+    '''
+    Test cases for Dart language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.dart")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
         regex2 = r'''\/\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign1 = '//'
-        sign2 = '///'
-        comment_single_doubleSlash = dart.readSingleLine(self.testfile, regex1, sign1)
-        comment_single_tripleSlash = dart.readSingleLine(self.testfile, regex2, sign2)
-        comment_multiline = dart.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
+        comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                                   syntax_end)
         comment_contSingleline1 = dart.contSingleLines(comment_single_doubleSlash)
         comment_contSingleline2 = dart.contSingleLines(comment_single_tripleSlash)
         self.assertTrue(comment_single_doubleSlash)
@@ -46,16 +55,18 @@ def test_output(self):
         self.assertTrue(comment_contSingleline2)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
         regex2 = r'''\/\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign1 = '//'
-        sign2 = '///'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = dart.dartExtractor(self.testfile).get_dict()
-        comment_single_doubleSlash = dart.readSingleLine(self.testfile, regex1, sign1)
-        comment_single_tripleSlash = dart.readSingleLine(self.testfile, regex2, sign2)
-        comment_multiline = dart.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
+        comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline1 = dart.contSingleLines(comment_single_doubleSlash)
         comment_contSingleline2 = dart.contSingleLines(comment_single_tripleSlash)
         file = self.testfile.split("/")
@@ -64,9 +75,13 @@ def test_outputFormat(self):
         "filename": file[-1],
         "lang": "Dart",
         "total_lines": comment_single_doubleSlash[1],
-        "total_lines_of_comments": comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3],
+        "total_lines_of_comments": comment_single_doubleSlash[3] + \
+                                   comment_single_tripleSlash[3] + \
+                                   comment_multiline[3],
         "blank_lines": comment_single_doubleSlash[2],
-        "sloc": comment_single_doubleSlash[1] - (comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3] + comment_single_doubleSlash[2])
+        "sloc": comment_single_doubleSlash[1] - (
+          comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + \
+          comment_multiline[3] + comment_single_doubleSlash[2])
         },
         "single_line_comment": [],
         "cont_single_line_comment": [],
@@ -88,23 +103,33 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline1:
-            for idx, i in enumerate(comment_contSingleline1[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline1[1][idx], "end_line": comment_contSingleline1[2][idx], "comment": comment_contSingleline1[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline1[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline1[1][idx],
+                  "end_line": comment_contSingleline1[2][idx],
+                  "comment": comment_contSingleline1[3][idx]})
 
         if comment_contSingleline2:
-            for idx, i in enumerate(comment_contSingleline2[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline2[1][idx], "end_line": comment_contSingleline2[2][idx], "comment": comment_contSingleline2[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline2[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline2[1][idx],
+                  "end_line": comment_contSingleline2[2][idx],
+                  "comment": comment_contSingleline2[3][idx]})
 
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = dart.dartSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_go.py b/nirjas/languages/tests/test_go.py
index bf6f412..05533c2 100644
--- a/nirjas/languages/tests/test_go.py
+++ b/nirjas/languages/tests/test_go.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import go
@@ -5,28 +25,38 @@
 
 
 class GoTest(unittest.TestCase):
+    '''
+    Test cases for Go language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cs")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = go.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = go.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = go.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = go.goExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = go.goSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_haskell.py b/nirjas/languages/tests/test_haskell.py
index abc1eb7..142500e 100644
--- a/nirjas/languages/tests/test_haskell.py
+++ b/nirjas/languages/tests/test_haskell.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import haskell
@@ -5,28 +25,38 @@
 
 
 class HaskellTest(unittest.TestCase):
+    '''
+    Test cases for Haskell language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.hs")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''\-\-\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '--'
-        comment_single = haskell.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = haskell.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = haskell.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''\-\-\s*(.*)'''
-        self.syntax_start = "{-"
-        self.syntax_end = "-}"
-        sign = '--'
+        syntax_start = "{-"
+        syntax_end = "-}"
         expected = haskell.haskellExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = haskell.haskellSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_html.py b/nirjas/languages/tests/test_html.py
index ecaa9b7..e5e024c 100644
--- a/nirjas/languages/tests/test_html.py
+++ b/nirjas/languages/tests/test_html.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import html
@@ -5,27 +25,42 @@
 
 
 class HTMLTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.html")
+    '''
+    Test cases for HTML language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.html")
 
     def test_output(self):
-        self.start_exclamation = "<!--"
-        self.end_exclamation = "-->"
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        comment_single = html.readMultiLineDiff(self.testfile, self.start_exclamation, self.end_exclamation)
-        comment_multiline = html.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        '''
+        Check for the scan correctness.
+        '''
+        start_exclamation = "<!--"
+        end_exclamation = "-->"
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readMultiLineDiff(self.testfile, start_exclamation,
+                                           end_exclamation)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
 
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
 
     def test_outputFormat(self):
-        self.start_exclamation = "<!--"
-        self.end_exclamation = "-->"
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
+        '''
+        Check for the output format correctness.
+        '''
+        start_exclamation = "<!--"
+        end_exclamation = "-->"
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = html.htmlExtractor(self.testfile).get_dict()
-        comment_single = readMultiLineDiff(self.testfile, self.start_exclamation, self.end_exclamation)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readMultiLineDiff(self.testfile, start_exclamation,
+                                           end_exclamation)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         file = self.testfile.split("/")
         output = {
         "metadata": {
@@ -42,22 +77,26 @@ def test_outputFormat(self):
         }
 
         if comment_single:
-            try:
-                for idx, i in enumerate(comment_single[0]):
-                    output['multi_line_comment'].append({"start_line": comment_single[0][idx], "end_line": comment_single[1][idx], "comment": comment_single[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_single[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_single[0][idx],
+                  "end_line": comment_single[1][idx],
+                  "comment": comment_single[2][idx]})
 
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = html.htmlSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_java.py b/nirjas/languages/tests/test_java.py
index 0555f9c..d863456 100644
--- a/nirjas/languages/tests/test_java.py
+++ b/nirjas/languages/tests/test_java.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import java
@@ -5,28 +25,39 @@
 
 
 class JavaTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.java")
+    '''
+    Test cases for Java language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.java")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = java.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = java.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = java.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = java.javaExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -48,19 +79,29 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output['single_line_comment'].append({"line_number": i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = java.javaSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_javascript.py b/nirjas/languages/tests/test_javascript.py
index 656264a..20ede78 100644
--- a/nirjas/languages/tests/test_javascript.py
+++ b/nirjas/languages/tests/test_javascript.py
@@ -1,33 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import javascript
-from nirjas.binder import readSingleLine, readMultiLineDiff
+from nirjas.binder import readSingleLine, readMultiLineDiff, contSingleLines
 
 
 class JSTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.js")
+    '''
+    Test cases for JavaScript language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.js")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = javascript.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = javascript.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = javascript.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = javascript.javascriptExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = javascript.contSingleLines(comment_single)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
         "metadata": {
@@ -51,19 +82,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = javascript.javascriptSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_kotlin.py b/nirjas/languages/tests/test_kotlin.py
index f9969e5..9503c98 100644
--- a/nirjas/languages/tests/test_kotlin.py
+++ b/nirjas/languages/tests/test_kotlin.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import kotlin
@@ -5,28 +25,38 @@
 
 
 class KotlinTest(unittest.TestCase):
+    '''
+    Test cases for Kotlin language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.kts")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = kotlin.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = kotlin.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = kotlin.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = kotlin.kotlinExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = kotlin.kotlinSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_matlab.py b/nirjas/languages/tests/test_matlab.py
index 0ee4103..9806d3d 100644
--- a/nirjas/languages/tests/test_matlab.py
+++ b/nirjas/languages/tests/test_matlab.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import matlab
@@ -5,28 +25,38 @@
 
 
 class matlabTest(unittest.TestCase):
+    '''
+    Test cases for Matlab language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.m")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''\%\s*(.*)'''
-        self.syntax_start = "%{"
-        self.syntax_end = "%}"
-        sign = '%'
-        comment_single = matlab.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = matlab.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = matlab.contSingleLines(comment_single)
+        syntax_start = "%{"
+        syntax_end = "%}"
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''\%\s*(.*)'''
-        self.syntax_start = "%{"
-        self.syntax_end = "%}"
-        sign = '%'
+        syntax_start = "%{"
+        syntax_end = "%}"
         expected = matlab.matlabExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = matlab.matlabSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_perl.py b/nirjas/languages/tests/test_perl.py
index 79b12e3..3f56f50 100644
--- a/nirjas/languages/tests/test_perl.py
+++ b/nirjas/languages/tests/test_perl.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import perl
@@ -5,28 +25,38 @@
 
 
 class perlTest(unittest.TestCase):
+    '''
+    Test cases for Perl language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.pl")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        self.syntax_start = "=begin"
-        self.syntax_end = "=cut"
-        sign = '#'
-        comment_single = perl.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = perl.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = perl.contSingleLines(comment_single)
+        syntax_start = "=begin"
+        syntax_end = "=cut"
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        self.syntax_start = "=begin"
-        self.syntax_end = "=cut"
-        sign = '#'
+        syntax_start = "=begin"
+        syntax_end = "=cut"
         expected = perl.perlExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = perl.perlSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_php.py b/nirjas/languages/tests/test_php.py
index a9bd1e6..11c2ff1 100644
--- a/nirjas/languages/tests/test_php.py
+++ b/nirjas/languages/tests/test_php.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import php
@@ -5,28 +25,38 @@
 
 
 class PHPTest(unittest.TestCase):
+    '''
+    Test cases for PHP language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.php")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = php.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = php.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = php.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = php.phpExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -48,19 +78,29 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output['single_line_comment'].append({"line_number": i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = php.phpSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_python.py b/nirjas/languages/tests/test_python.py
index 11ac13e..3059e26 100644
--- a/nirjas/languages/tests/test_python.py
+++ b/nirjas/languages/tests/test_python.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import python
@@ -5,31 +25,39 @@
 
 
 class PythonTest(unittest.TestCase):
+    '''
+    Test cases for Python language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.py")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        self.syntax_single = "'''"
-        self.syntax_double = '"""'
-        sign = '#'
-        comment_multi_single = python.readMultiLineSame(self.testfile, self.syntax_single)
-        comment_single = python.readSingleLine(self.testfile, regex, sign)
-        comment_multi_double = python.readMultiLineSame(self.testfile, self.syntax_double)
-        comment_contSingleline = python.contSingleLines(comment_single)
+        syntax_single = "'''"
+        syntax_double = '"""'
+        comment_multi_single = readMultiLineSame(self.testfile, syntax_single)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multi_double = readMultiLineSame(self.testfile, syntax_double)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multi_single)
         self.assertTrue(comment_multi_double)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        self.syntax_single = "'''"
-        self.syntax_double = '"""'
-        sign = '#'
+        syntax_single = "'''"
+        syntax_double = '"""'
         expected = python.pythonExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multi_single = readMultiLineSame(self.testfile, self.syntax_single)
-        comment_multi_double = readMultiLineSame(self.testfile, self.syntax_double)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multi_single = readMultiLineSame(self.testfile, syntax_single)
+        comment_multi_double = readMultiLineSame(self.testfile, syntax_double)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -37,9 +65,14 @@ def test_outputFormat(self):
         "filename": file[-1],
         "lang": "Python",
         "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multi_single[3] + comment_multi_double[3],
+        "total_lines_of_comments": comment_single[3] + \
+                                   comment_multi_single[3] + \
+                                   comment_multi_double[3],
         "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multi_single[3] + comment_multi_double[3] + comment_single[2])
+        "sloc": comment_single[1] - (comment_single[3] + \
+                                     comment_multi_single[3] + \
+                                     comment_multi_double[3] + \
+                                     comment_single[2])
         },
         "single_line_comment": [],
         "cont_single_line_comment": [],
@@ -54,26 +87,33 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multi_single:
-            try:
-                for idx, i in enumerate(comment_multi_single[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multi_single[0][idx], "end_line": comment_multi_single[1][idx], "comment": comment_multi_single[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multi_single[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multi_single[0][idx],
+                  "end_line": comment_multi_single[1][idx],
+                  "comment": comment_multi_single[2][idx]})
 
         if comment_multi_double:
-            try:
-                for idx, i in enumerate(comment_multi_double[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multi_double[0][idx], "end_line": comment_multi_double[1][idx], "comment": comment_multi_double[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multi_double[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multi_double[0][idx],
+                  "end_line": comment_multi_double[1][idx],
+                  "comment": comment_multi_double[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = python.pythonSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_r.py b/nirjas/languages/tests/test_r.py
index 43915ef..5b297de 100644
--- a/nirjas/languages/tests/test_r.py
+++ b/nirjas/languages/tests/test_r.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import r
@@ -5,19 +25,27 @@
 
 
 class rTest(unittest.TestCase):
+    '''
+    Test cases for R language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.R")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        sign = '#'
-        comment_single = r.readSingleLine(self.testfile, regex, sign)
+        comment_single = readSingleLine(self.testfile, regex)
         self.assertTrue(comment_single)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        sign = '#'
         expected = r.rExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
+        comment_single = readSingleLine(self.testfile, regex)
         file = self.testfile.split("/")
         output = {
         "metadata": {
@@ -38,6 +66,10 @@ def test_outputFormat(self):
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = r.rSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_ruby.py b/nirjas/languages/tests/test_ruby.py
index e22c0af..9b7b25e 100644
--- a/nirjas/languages/tests/test_ruby.py
+++ b/nirjas/languages/tests/test_ruby.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import ruby
@@ -5,28 +25,38 @@
 
 
 class RubyTest(unittest.TestCase):
+    '''
+    Test cases for Ruby language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.rb")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        self.syntax_start = "=begin"
-        self.syntax_end = "=end"
-        sign = '#'
-        comment_single = ruby.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = ruby.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = ruby.contSingleLines(comment_single)
+        syntax_start = "=begin"
+        syntax_end = "=end"
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        self.syntax_start = "=begin"
-        self.syntax_end = "=cut"
-        sign = '#'
+        syntax_start = "=begin"
+        syntax_end = "=cut"
         expected = ruby.rubyExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = ruby.rubySource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_rust.py b/nirjas/languages/tests/test_rust.py
index cff99e8..1221144 100644
--- a/nirjas/languages/tests/test_rust.py
+++ b/nirjas/languages/tests/test_rust.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import rust
@@ -5,28 +25,38 @@
 
 
 class RustTest(unittest.TestCase):
+    '''
+    Test cases for Rust language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.rs")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = rust.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = rust.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = rust.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = rust.rustExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +81,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = rust.rustSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_scala.py b/nirjas/languages/tests/test_scala.py
index 9cc0588..f03bd67 100644
--- a/nirjas/languages/tests/test_scala.py
+++ b/nirjas/languages/tests/test_scala.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import scala
@@ -5,28 +25,39 @@
 
 
 class ScalaTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.scala")
+    '''
+    Test cases for Scala language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.scala")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = scala.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = scala.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = scala.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = scala.scalaExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +82,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = scala.scalaSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_scss.py b/nirjas/languages/tests/test_scss.py
index bfdeb85..142416b 100644
--- a/nirjas/languages/tests/test_scss.py
+++ b/nirjas/languages/tests/test_scss.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 '''
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
@@ -21,24 +23,31 @@
 import unittest
 import os
 from nirjas.languages import scss
-from nirjas.binder import readSingleLine, readMultiLineDiff
+from nirjas.binder import readSingleLine, readMultiLineDiff, contSingleLines
 
 
 class ScssTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.scss")
+    '''
+    Test cases for SCSS language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.scss")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
         regex2 = r'''\/\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign1 = '//'
-        sign2 = '///'
-        comment_single_doubleSlash = scss.readSingleLine(self.testfile, regex1, sign1)
-        comment_single_tripleSlash = scss.readSingleLine(self.testfile, regex2, sign2)
-        comment_multiline = scss.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline1 = scss.contSingleLines(comment_single_doubleSlash)
-        comment_contSingleline2 = scss.contSingleLines(comment_single_tripleSlash)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
+        comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline1 = contSingleLines(comment_single_doubleSlash)
+        comment_contSingleline2 = contSingleLines(comment_single_tripleSlash)
         self.assertTrue(comment_single_doubleSlash)
         self.assertTrue(comment_single_tripleSlash)
         self.assertTrue(comment_multiline)
@@ -46,27 +55,33 @@ def test_output(self):
         self.assertTrue(comment_contSingleline2)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
         regex2 = r'''\/\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign1 = '//'
-        sign2 = '///'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = scss.scssExtractor(self.testfile).get_dict()
-        comment_single_doubleSlash = scss.readSingleLine(self.testfile, regex1, sign1)
-        comment_single_tripleSlash = scss.readSingleLine(self.testfile, regex2, sign2)
-        comment_multiline = scss.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline1 = scss.contSingleLines(comment_single_doubleSlash)
-        comment_contSingleline2 = scss.contSingleLines(comment_single_tripleSlash)
+        comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
+        comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline1 = contSingleLines(comment_single_doubleSlash)
+        comment_contSingleline2 = contSingleLines(comment_single_tripleSlash)
         file = self.testfile.split("/")
         output = {
         "metadata": {
         "filename": file[-1],
         "lang": "Scss",
         "total_lines": comment_single_doubleSlash[1],
-        "total_lines_of_comments": comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3],
+        "total_lines_of_comments": comment_single_doubleSlash[3] + \
+                                   comment_single_tripleSlash[3] + \
+                                   comment_multiline[3],
         "blank_lines": comment_single_doubleSlash[2],
-        "sloc": comment_single_doubleSlash[1] - (comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3] + comment_single_doubleSlash[2])
+        "sloc": comment_single_doubleSlash[1] - (
+          comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + \
+          comment_multiline[3] + comment_single_doubleSlash[2])
         },
         "single_line_comment": [],
         "cont_single_line_comment": [],
@@ -88,23 +103,33 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline1:
-            for idx, i in enumerate(comment_contSingleline1[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline1[1][idx], "end_line": comment_contSingleline1[2][idx], "comment": comment_contSingleline1[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline1[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline1[1][idx],
+                  "end_line": comment_contSingleline1[2][idx],
+                  "comment": comment_contSingleline1[3][idx]})
 
         if comment_contSingleline2:
-            for idx, i in enumerate(comment_contSingleline2[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline2[1][idx], "end_line": comment_contSingleline2[2][idx], "comment": comment_contSingleline2[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline2[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline2[1][idx],
+                  "end_line": comment_contSingleline2[2][idx],
+                  "comment": comment_contSingleline2[3][idx]})
 
         if comment_multiline:
-            try:
-                for idx, i in enumerate(comment_multiline[0]):
-                    output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-            except:
-                pass
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = scss.scssSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_shell.py b/nirjas/languages/tests/test_shell.py
index 8f51e7b..55aec6e 100644
--- a/nirjas/languages/tests/test_shell.py
+++ b/nirjas/languages/tests/test_shell.py
@@ -1,24 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import shell
-from nirjas.binder import readSingleLine
+from nirjas.binder import readSingleLine, contSingleLines
 
 
 class ShellTest(unittest.TestCase):
+    '''
+    Test cases for Shell language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.sh")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''#+\s*(.*)'''
-        sign = '#'
-        comment_single = shell.readSingleLine(self.testfile, regex, sign)
+        comment_single = readSingleLine(self.testfile, regex)
         self.assertTrue(comment_single)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''#+\s*(.*)'''
         expected = shell.shellExtractor(self.testfile).get_dict()
-        sign = '#'
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_contSingleline = shell.contSingleLines(comment_single)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
         "metadata": {
@@ -41,12 +69,19 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = shell.shellSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_swift.py b/nirjas/languages/tests/test_swift.py
index 11fe999..4c6c942 100644
--- a/nirjas/languages/tests/test_swift.py
+++ b/nirjas/languages/tests/test_swift.py
@@ -1,3 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+'''
+SPDX-License-Identifier: LGPL-2.1
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+'''
+
 import unittest
 import os
 from nirjas.languages import swift
@@ -5,28 +25,39 @@
 
 
 class SwiftTest(unittest.TestCase):
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.swift")
+    '''
+    Test cases for Swift language.
+    :ivar testfile: Location of test file
+    '''
+    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                            "TestFiles/textcomment.swift")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        sign = '//'
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        comment_single = swift.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = swift.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = swift.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = "*/"
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = "*/"
         expected = swift.swiftExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -51,16 +82,26 @@ def test_outputFormat(self):
                 output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
         if comment_contSingleline:
-            for idx, i in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+            for idx, _ in enumerate(comment_contSingleline[1]):
+                output['cont_single_line_comment'].append({
+                  "start_line": comment_contSingleline[1][idx],
+                  "end_line": comment_contSingleline[2][idx],
+                  "comment": comment_contSingleline[3][idx]})
 
         if comment_multiline:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
+            for idx, _ in enumerate(comment_multiline[0]):
+                output['multi_line_comment'].append({
+                  "start_line": comment_multiline[0][idx],
+                  "end_line": comment_multiline[1][idx],
+                  "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = swift.swiftSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_typescript.py b/nirjas/languages/tests/test_typescript.py
index ca7a780..0bb01f7 100644
--- a/nirjas/languages/tests/test_typescript.py
+++ b/nirjas/languages/tests/test_typescript.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 '''
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
@@ -21,32 +23,42 @@
 import unittest
 import os
 from nirjas.languages import typescript
-from nirjas.binder import readSingleLine, readMultiLineDiff
+from nirjas.binder import readSingleLine, readMultiLineDiff, contSingleLines
 
 
 class TSTest(unittest.TestCase):
+    '''
+    Test cases for TypeScript language.
+    :ivar testfile: Location of test file
+    '''
     testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.ts")
 
     def test_output(self):
+        '''
+        Check for the scan correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
-        comment_single = typescript.readSingleLine(self.testfile, regex, sign)
-        comment_multiline = typescript.readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
-        comment_contSingleline = typescript.contSingleLines(comment_single)
+        syntax_start = "/*"
+        syntax_end = '*/'
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
+        comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
+        '''
+        Check for the output format correctness.
+        '''
         regex = r'''(?<![pst]:)\/\/\s*(.*)'''
-        self.syntax_start = "/*"
-        self.syntax_end = '*/'
-        sign = '//'
+        syntax_start = "/*"
+        syntax_end = '*/'
         expected = typescript.typescriptExtractor(self.testfile).get_dict()
-        comment_single = readSingleLine(self.testfile, regex, sign)
-        comment_multiline = readMultiLineDiff(self.testfile, self.syntax_start, self.syntax_end)
+        comment_single = readSingleLine(self.testfile, regex)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
+                                              syntax_end)
         comment_contSingleline = typescript.contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
@@ -69,18 +81,25 @@ def test_outputFormat(self):
         for i in comment_single[0]:
             output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
 
-        for idx, i in enumerate(comment_contSingleline[1]):
-            output['cont_single_line_comment'].append({"start_line": comment_contSingleline[1][idx], "end_line": comment_contSingleline[2][idx], "comment": comment_contSingleline[3][idx]})
+        for idx, _ in enumerate(comment_contSingleline[1]):
+            output['cont_single_line_comment'].append({
+              "start_line": comment_contSingleline[1][idx],
+              "end_line": comment_contSingleline[2][idx],
+              "comment": comment_contSingleline[3][idx]})
 
-        try:
-            for idx, i in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({"start_line": comment_multiline[0][idx], "end_line": comment_multiline[1][idx], "comment": comment_multiline[2][idx]})
-        except:
-            pass
+        for idx, _ in enumerate(comment_multiline[0]):
+            output['multi_line_comment'].append({
+              "start_line": comment_multiline[0][idx],
+              "end_line": comment_multiline[1][idx],
+              "comment": comment_multiline[2][idx]})
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
+        '''
+        Test the source code extraction.
+        Call the source function and check if new file exists.
+        '''
         name = "source.txt"
         newfile = typescript.typescriptSource(self.testfile, name)