11 files changed, 1196 insertions, 0 deletions
diff --git a/src/python/test/test_alpha_complex.py b/src/python/test/test_alpha_complex.py
new file mode 100755
index 00000000..24f8bf53
--- /dev/null
+++ b/src/python/test/test_alpha_complex.py
@@ -0,0 +1,90 @@
+from gudhi import AlphaComplex, SimplexTree
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_empty_alpha():
+    alpha_complex = AlphaComplex(points=[[0, 0]])
+    assert alpha_complex.__is_defined() == True
+
+
+def test_infinite_alpha():
+    point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+    alpha_complex = AlphaComplex(points=point_list)
+    assert alpha_complex.__is_defined() == True
+
+    simplex_tree = alpha_complex.create_simplex_tree()
+    assert simplex_tree.__is_persistence_defined() == False
+
+    assert simplex_tree.num_simplices() == 11
+    assert simplex_tree.num_vertices() == 4
+
+    assert simplex_tree.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([2], 0.0),
+        ([3], 0.0),
+        ([0, 1], 0.25),
+        ([0, 2], 0.25),
+        ([1, 3], 0.25),
+        ([2, 3], 0.25),
+        ([1, 2], 0.5),
+        ([0, 1, 2], 0.5),
+        ([1, 2, 3], 0.5),
+    ]
+    assert simplex_tree.get_star([0]) == [
+        ([0], 0.0),
+        ([0, 1], 0.25),
+        ([0, 1, 2], 0.5),
+        ([0, 2], 0.25),
+    ]
+    assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
+
+    assert point_list[0] == alpha_complex.get_point(0)
+    assert point_list[1] == alpha_complex.get_point(1)
+    assert point_list[2] == alpha_complex.get_point(2)
+    assert point_list[3] == alpha_complex.get_point(3)
+    assert alpha_complex.get_point(4) == []
+    assert alpha_complex.get_point(125) == []
+
+
+def test_filtered_alpha():
+    point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+    filtered_alpha = AlphaComplex(points=point_list)
+
+    simplex_tree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
+
+    assert simplex_tree.num_simplices() == 8
+    assert simplex_tree.num_vertices() == 4
+
+    assert point_list[0] == filtered_alpha.get_point(0)
+    assert point_list[1] == filtered_alpha.get_point(1)
+    assert point_list[2] == filtered_alpha.get_point(2)
+    assert point_list[3] == filtered_alpha.get_point(3)
+    assert filtered_alpha.get_point(4) == []
+    assert filtered_alpha.get_point(125) == []
+
+    assert simplex_tree.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([2], 0.0),
+        ([3], 0.0),
+        ([0, 1], 0.25),
+        ([0, 2], 0.25),
+        ([1, 3], 0.25),
+        ([2, 3], 0.25),
+    ]
+    assert simplex_tree.get_star([0]) == [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)]
+    assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
diff --git a/src/python/test/test_bottleneck_distance.py b/src/python/test/test_bottleneck_distance.py
new file mode 100755
index 00000000..f5f019b9
--- /dev/null
+++ b/src/python/test/test_bottleneck_distance.py
@@ -0,0 +1,23 @@
+import gudhi
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_basic_bottleneck():
+    diag1 = [[2.7, 3.7], [9.6, 14.0], [34.2, 34.974], [3.0, float("Inf")]]
+    diag2 = [[2.8, 4.45], [9.5, 14.1], [3.2, float("Inf")]]
+
+    assert gudhi.bottleneck_distance(diag1, diag2, 0.1) == 0.8081763781405569
+    assert gudhi.bottleneck_distance(diag1, diag2) == 0.75
diff --git a/src/python/test/test_cover_complex.py b/src/python/test/test_cover_complex.py
new file mode 100755
index 00000000..8cd12272
--- /dev/null
+++ b/src/python/test/test_cover_complex.py
@@ -0,0 +1,85 @@
+from gudhi import CoverComplex
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2018 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2018 Inria"
+__license__ = "MIT"
+
+
+def test_empty_constructor():
+    # Try to create an empty CoverComplex
+    cover = CoverComplex()
+    assert cover.__is_defined() == True
+
+
+def test_non_existing_file_read():
+    # Try to open a non existing file
+    cover = CoverComplex()
+    assert cover.read_point_cloud("pouetpouettralala.toubiloubabdou") == False
+
+
+def test_files_creation():
+    # Create test file
+    cloud_file = open("cloud", "w")
+    cloud_file.write("nOFF\n3\n3 0 0\n0 0 0\n2 1 0\n4 0 0")
+    cloud_file.close()
+    cover_file = open("cover", "w")
+    cover_file.write("1\n2\n3")
+    cover_file.close()
+    graph_file = open("graph", "w")
+    graph_file.write("0 1\n0 2\n1 2")
+    graph_file.close()
+
+
+def test_nerve():
+    nerve = CoverComplex()
+    nerve.set_type("Nerve")
+    assert nerve.read_point_cloud("cloud") == True
+    nerve.set_color_from_coordinate()
+    nerve.set_graph_from_file("graph")
+    nerve.set_cover_from_file("cover")
+    nerve.find_simplices()
+    stree = nerve.create_simplex_tree()
+
+    assert stree.num_vertices() == 3
+    assert (stree.num_simplices() - stree.num_vertices()) == 0
+    assert stree.dimension() == 0
+
+
+def test_graph_induced_complex():
+    gic = CoverComplex()
+    gic.set_type("GIC")
+    assert gic.read_point_cloud("cloud") == True
+    gic.set_color_from_coordinate()
+    gic.set_graph_from_file("graph")
+    gic.set_cover_from_file("cover")
+    gic.find_simplices()
+    stree = gic.create_simplex_tree()
+
+    assert stree.num_vertices() == 3
+    assert (stree.num_simplices() - stree.num_vertices()) == 4
+    assert stree.dimension() == 2
+
+
+def test_voronoi_graph_induced_complex():
+    gic = CoverComplex()
+    gic.set_type("GIC")
+    assert gic.read_point_cloud("cloud") == True
+    gic.set_color_from_coordinate()
+    gic.set_graph_from_file("graph")
+    gic.set_cover_from_Voronoi(2)
+    gic.find_simplices()
+    stree = gic.create_simplex_tree()
+
+    assert stree.num_vertices() == 2
+    assert (stree.num_simplices() - stree.num_vertices()) == 1
+    assert stree.dimension() == 1
diff --git a/src/python/test/test_cubical_complex.py b/src/python/test/test_cubical_complex.py
new file mode 100755
index 00000000..68f54fbe
--- /dev/null
+++ b/src/python/test/test_cubical_complex.py
@@ -0,0 +1,98 @@
+from gudhi import CubicalComplex
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_empty_constructor():
+    # Try to create an empty CubicalComplex
+    cub = CubicalComplex()
+    assert cub.__is_defined() == False
+    assert cub.__is_persistence_defined() == False
+
+
+def test_non_existing_perseus_file_constructor():
+    # Try to open a non existing file
+    cub = CubicalComplex(perseus_file="pouetpouettralala.toubiloubabdou")
+    assert cub.__is_defined() == False
+    assert cub.__is_persistence_defined() == False
+
+
+def test_dimension_or_perseus_file_constructor():
+    # Create test file
+    test_file = open("CubicalOneSphere.txt", "w")
+    test_file.write("2\n3\n3\n0\n0\n0\n0\n100\n0\n0\n0\n0\n")
+    test_file.close()
+    # CubicalComplex can be constructed from dimensions and
+    # top_dimensional_cells OR from a Perseus-style file name.
+    cub = CubicalComplex(
+        dimensions=[3, 3],
+        top_dimensional_cells=[1, 2, 3, 4, 5, 6, 7, 8, 9],
+        perseus_file="CubicalOneSphere.txt",
+    )
+    assert cub.__is_defined() == False
+    assert cub.__is_persistence_defined() == False
+
+    cub = CubicalComplex(
+        top_dimensional_cells=[1, 2, 3, 4, 5, 6, 7, 8, 9],
+        perseus_file="CubicalOneSphere.txt",
+    )
+    assert cub.__is_defined() == False
+    assert cub.__is_persistence_defined() == False
+
+    cub = CubicalComplex(dimensions=[3, 3], perseus_file="CubicalOneSphere.txt")
+    assert cub.__is_defined() == False
+    assert cub.__is_persistence_defined() == False
+
+
+def test_dimension_simple_constructor():
+    cub = CubicalComplex(
+        dimensions=[3, 3], top_dimensional_cells=[1, 2, 3, 4, 5, 6, 7, 8, 9]
+    )
+    assert cub.__is_defined() == True
+    assert cub.__is_persistence_defined() == False
+    assert cub.persistence() == [(0, (1.0, float("inf")))]
+    assert cub.__is_persistence_defined() == True
+    assert cub.betti_numbers() == [1, 0, 0]
+    assert cub.persistent_betti_numbers(0, 1000) == [0, 0, 0]
+
+
+def test_user_case_simple_constructor():
+    cub = CubicalComplex(
+        dimensions=[3, 3],
+        top_dimensional_cells=[float("inf"), 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+    )
+    assert cub.__is_defined() == True
+    assert cub.__is_persistence_defined() == False
+    assert cub.persistence() == [(1, (0.0, 1.0)), (0, (0.0, float("inf")))]
+    assert cub.__is_persistence_defined() == True
+    other_cub = CubicalComplex(
+        dimensions=[3, 3],
+        top_dimensional_cells=[1000.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+    )
+    assert other_cub.persistence() == [(1, (0.0, 1.0)), (0, (0.0, float("inf")))]
+
+
+def test_dimension_file_constructor():
+    # Create test file
+    test_file = open("CubicalOneSphere.txt", "w")
+    test_file.write("2\n3\n3\n0\n0\n0\n0\n100\n0\n0\n0\n0\n")
+    test_file.close()
+    cub = CubicalComplex(perseus_file="CubicalOneSphere.txt")
+    assert cub.__is_defined() == True
+    assert cub.__is_persistence_defined() == False
+    assert cub.persistence() == [(1, (0.0, 100.0)), (0, (0.0, float("inf")))]
+    assert cub.__is_persistence_defined() == True
+    assert cub.betti_numbers() == [1, 0, 0]
+    assert cub.persistent_betti_numbers(0, 1000) == [1, 0, 0]
diff --git a/src/python/test/test_euclidean_witness_complex.py b/src/python/test/test_euclidean_witness_complex.py
new file mode 100755
index 00000000..f5eae5fa
--- /dev/null
+++ b/src/python/test/test_euclidean_witness_complex.py
@@ -0,0 +1,95 @@
+import gudhi
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_empty_euclidean_witness_complex():
+    euclidean_witness = gudhi.EuclideanWitnessComplex()
+    assert euclidean_witness.__is_defined() == False
+
+
+def test_witness_complex():
+    point_cloud = [
+        [1.0, 1.0],
+        [7.0, 0.0],
+        [4.0, 6.0],
+        [9.0, 6.0],
+        [0.0, 14.0],
+        [2.0, 19.0],
+        [9.0, 17.0],
+    ]
+    landmarks = [[1.0, 1.0], [7.0, 0.0], [4.0, 6.0]]
+    euclidean_witness_complex = gudhi.EuclideanWitnessComplex(
+        landmarks=landmarks, witnesses=point_cloud
+    )
+    simplex_tree = euclidean_witness_complex.create_simplex_tree(max_alpha_square=4.1)
+
+    assert landmarks[0] == euclidean_witness_complex.get_point(0)
+    assert landmarks[1] == euclidean_witness_complex.get_point(1)
+    assert landmarks[2] == euclidean_witness_complex.get_point(2)
+
+    assert simplex_tree.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([0, 1], 0.0),
+        ([2], 0.0),
+        ([0, 2], 0.0),
+        ([1, 2], 0.0),
+        ([0, 1, 2], 0.0),
+    ]
+
+
+def test_empty_euclidean_strong_witness_complex():
+    euclidean_strong_witness = gudhi.EuclideanStrongWitnessComplex()
+    assert euclidean_strong_witness.__is_defined() == False
+
+
+def test_strong_witness_complex():
+    point_cloud = [
+        [1.0, 1.0],
+        [7.0, 0.0],
+        [4.0, 6.0],
+        [9.0, 6.0],
+        [0.0, 14.0],
+        [2.0, 19.0],
+        [9.0, 17.0],
+    ]
+    landmarks = [[1.0, 1.0], [7.0, 0.0], [4.0, 6.0]]
+    euclidean_strong_witness_complex = gudhi.EuclideanStrongWitnessComplex(
+        landmarks=landmarks, witnesses=point_cloud
+    )
+    simplex_tree = euclidean_strong_witness_complex.create_simplex_tree(
+        max_alpha_square=14.9
+    )
+
+    assert landmarks[0] == euclidean_strong_witness_complex.get_point(0)
+    assert landmarks[1] == euclidean_strong_witness_complex.get_point(1)
+    assert landmarks[2] == euclidean_strong_witness_complex.get_point(2)
+
+    assert simplex_tree.get_filtration() == [([0], 0.0), ([1], 0.0), ([2], 0.0)]
+
+    simplex_tree = euclidean_strong_witness_complex.create_simplex_tree(
+        max_alpha_square=100.0
+    )
+
+    assert simplex_tree.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([2], 0.0),
+        ([1, 2], 15.0),
+        ([0, 2], 34.0),
+        ([0, 1], 37.0),
+        ([0, 1, 2], 37.0),
+    ]
diff --git a/src/python/test/test_reader_utils.py b/src/python/test/test_reader_utils.py
new file mode 100755
index 00000000..4c7b32c2
--- /dev/null
+++ b/src/python/test/test_reader_utils.py
@@ -0,0 +1,126 @@
+import gudhi
+import numpy as np
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2017 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2017 Inria"
+__license__ = "MIT"
+
+
+def test_non_existing_csv_file():
+    # Try to open a non existing file
+    matrix = gudhi.read_lower_triangular_matrix_from_csv_file(
+        csv_file="pouetpouettralala.toubiloubabdou"
+    )
+    assert matrix == []
+
+
+def test_full_square_distance_matrix_csv_file():
+    # Create test file
+    test_file = open("full_square_distance_matrix.csv", "w")
+    test_file.write("0;1;2;3;\n1;0;4;5;\n2;4;0;6;\n3;5;6;0;")
+    test_file.close()
+    matrix = gudhi.read_lower_triangular_matrix_from_csv_file(
+        csv_file="full_square_distance_matrix.csv"
+    )
+    assert matrix == [[], [1.0], [2.0, 4.0], [3.0, 5.0, 6.0]]
+
+
+def test_lower_triangular_distance_matrix_csv_file():
+    # Create test file
+    test_file = open("lower_triangular_distance_matrix.csv", "w")
+    test_file.write("\n1,\n2,3,\n4,5,6,\n7,8,9,10,")
+    test_file.close()
+    matrix = gudhi.read_lower_triangular_matrix_from_csv_file(
+        csv_file="lower_triangular_distance_matrix.csv", separator=","
+    )
+    assert matrix == [[], [1.0], [2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0]]
+
+
+def test_non_existing_persistence_file():
+    # Try to open a non existing file
+    persistence = gudhi.read_persistence_intervals_grouped_by_dimension(
+        persistence_file="pouetpouettralala.toubiloubabdou"
+    )
+    assert persistence == []
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="pouetpouettralala.toubiloubabdou", only_this_dim=1
+    )
+    np.testing.assert_array_equal(persistence, [])
+
+
+def test_read_persistence_intervals_without_dimension():
+    # Create test file
+    test_file = open("persistence_intervals_without_dimension.pers", "w")
+    test_file.write(
+        "# Simple persistence diagram without dimension\n2.7 3.7\n9.6 14.\n34.2 34.974\n3. inf"
+    )
+    test_file.close()
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_without_dimension.pers"
+    )
+    np.testing.assert_array_equal(
+        persistence, [(2.7, 3.7), (9.6, 14.0), (34.2, 34.974), (3.0, float("Inf"))]
+    )
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_without_dimension.pers", only_this_dim=0
+    )
+    np.testing.assert_array_equal(persistence, [])
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_without_dimension.pers", only_this_dim=1
+    )
+    np.testing.assert_array_equal(persistence, [])
+    persistence = gudhi.read_persistence_intervals_grouped_by_dimension(
+        persistence_file="persistence_intervals_without_dimension.pers"
+    )
+    assert persistence == {
+        -1: [(2.7, 3.7), (9.6, 14.0), (34.2, 34.974), (3.0, float("Inf"))]
+    }
+
+
+def test_read_persistence_intervals_with_dimension():
+    # Create test file
+    test_file = open("persistence_intervals_with_dimension.pers", "w")
+    test_file.write(
+        "# Simple persistence diagram with dimension\n0 2.7 3.7\n1 9.6 14.\n3 34.2 34.974\n1 3. inf"
+    )
+    test_file.close()
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_with_dimension.pers"
+    )
+    np.testing.assert_array_equal(
+        persistence, [(2.7, 3.7), (9.6, 14.0), (34.2, 34.974), (3.0, float("Inf"))]
+    )
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=0
+    )
+    np.testing.assert_array_equal(persistence, [(2.7, 3.7)])
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=1
+    )
+    np.testing.assert_array_equal(persistence, [(9.6, 14.0), (3.0, float("Inf"))])
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=2
+    )
+    np.testing.assert_array_equal(persistence, [])
+    persistence = gudhi.read_persistence_intervals_in_dimension(
+        persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=3
+    )
+    np.testing.assert_array_equal(persistence, [(34.2, 34.974)])
+    persistence = gudhi.read_persistence_intervals_grouped_by_dimension(
+        persistence_file="persistence_intervals_with_dimension.pers"
+    )
+    assert persistence == {
+        0: [(2.7, 3.7)],
+        1: [(9.6, 14.0), (3.0, float("Inf"))],
+        3: [(34.2, 34.974)],
+    }
diff --git a/src/python/test/test_rips_complex.py b/src/python/test/test_rips_complex.py
new file mode 100755
index 00000000..d55ae22f
--- /dev/null
+++ b/src/python/test/test_rips_complex.py
@@ -0,0 +1,133 @@
+from gudhi import RipsComplex
+from math import sqrt
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_empty_rips():
+    rips_complex = RipsComplex()
+
+
+def test_rips_from_points():
+    point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+    rips_complex = RipsComplex(points=point_list, max_edge_length=42)
+
+    simplex_tree = rips_complex.create_simplex_tree(max_dimension=1)
+
+    assert simplex_tree.__is_defined() == True
+    assert simplex_tree.__is_persistence_defined() == False
+
+    assert simplex_tree.num_simplices() == 10
+    assert simplex_tree.num_vertices() == 4
+
+    assert simplex_tree.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([2], 0.0),
+        ([3], 0.0),
+        ([0, 1], 1.0),
+        ([0, 2], 1.0),
+        ([1, 3], 1.0),
+        ([2, 3], 1.0),
+        ([1, 2], 1.4142135623730951),
+        ([0, 3], 1.4142135623730951),
+    ]
+    assert simplex_tree.get_star([0]) == [
+        ([0], 0.0),
+        ([0, 1], 1.0),
+        ([0, 2], 1.0),
+        ([0, 3], 1.4142135623730951),
+    ]
+    assert simplex_tree.get_cofaces([0], 1) == [
+        ([0, 1], 1.0),
+        ([0, 2], 1.0),
+        ([0, 3], 1.4142135623730951),
+    ]
+
+
+def test_filtered_rips_from_points():
+    point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+    filtered_rips = RipsComplex(points=point_list, max_edge_length=1.0)
+
+    simplex_tree = filtered_rips.create_simplex_tree(max_dimension=1)
+
+    assert simplex_tree.__is_defined() == True
+    assert simplex_tree.__is_persistence_defined() == False
+
+    assert simplex_tree.num_simplices() == 8
+    assert simplex_tree.num_vertices() == 4
+
+
+def test_sparse_filtered_rips_from_points():
+    point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+    filtered_rips = RipsComplex(points=point_list, max_edge_length=1.0, sparse=0.001)
+
+    simplex_tree = filtered_rips.create_simplex_tree(max_dimension=1)
+
+    assert simplex_tree.__is_defined() == True
+    assert simplex_tree.__is_persistence_defined() == False
+
+    assert simplex_tree.num_simplices() == 8
+    assert simplex_tree.num_vertices() == 4
+
+
+def test_rips_from_distance_matrix():
+    distance_matrix = [[0], [1, 0], [1, sqrt(2), 0], [sqrt(2), 1, 1, 0]]
+    rips_complex = RipsComplex(distance_matrix=distance_matrix, max_edge_length=42)
+
+    simplex_tree = rips_complex.create_simplex_tree(max_dimension=1)
+
+    assert simplex_tree.__is_defined() == True
+    assert simplex_tree.__is_persistence_defined() == False
+
+    assert simplex_tree.num_simplices() == 10
+    assert simplex_tree.num_vertices() == 4
+
+    assert simplex_tree.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([2], 0.0),
+        ([3], 0.0),
+        ([0, 1], 1.0),
+        ([0, 2], 1.0),
+        ([1, 3], 1.0),
+        ([2, 3], 1.0),
+        ([1, 2], 1.4142135623730951),
+        ([0, 3], 1.4142135623730951),
+    ]
+    assert simplex_tree.get_star([0]) == [
+        ([0], 0.0),
+        ([0, 1], 1.0),
+        ([0, 2], 1.0),
+        ([0, 3], 1.4142135623730951),
+    ]
+    assert simplex_tree.get_cofaces([0], 1) == [
+        ([0, 1], 1.0),
+        ([0, 2], 1.0),
+        ([0, 3], 1.4142135623730951),
+    ]
+
+
+def test_filtered_rips_from_distance_matrix():
+    distance_matrix = [[0], [1, 0], [1, sqrt(2), 0], [sqrt(2), 1, 1, 0]]
+    filtered_rips = RipsComplex(distance_matrix=distance_matrix, max_edge_length=1.0)
+
+    simplex_tree = filtered_rips.create_simplex_tree(max_dimension=1)
+
+    assert simplex_tree.__is_defined() == True
+    assert simplex_tree.__is_persistence_defined() == False
+
+    assert simplex_tree.num_simplices() == 8
+    assert simplex_tree.num_vertices() == 4
diff --git a/src/python/test/test_simplex_tree.py b/src/python/test/test_simplex_tree.py
new file mode 100755
index 00000000..8d8971c1
--- /dev/null
+++ b/src/python/test/test_simplex_tree.py
@@ -0,0 +1,250 @@
+from gudhi import SimplexTree
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_insertion():
+    st = SimplexTree()
+    assert st.__is_defined() == True
+    assert st.__is_persistence_defined() == False
+
+    # insert test
+    assert st.insert([0, 1]) == True
+
+    assert st.dimension() == 1
+
+    assert st.insert([0, 1, 2], filtration=4.0) == True
+
+    assert st.dimension() == 2
+
+    assert st.num_simplices() == 7
+    assert st.num_vertices() == 3
+
+    # find test
+    assert st.find([0, 1, 2]) == True
+    assert st.find([0, 1]) == True
+    assert st.find([0, 2]) == True
+    assert st.find([0]) == True
+    assert st.find([1]) == True
+    assert st.find([2]) == True
+    assert st.find([3]) == False
+    assert st.find([0, 3]) == False
+    assert st.find([1, 3]) == False
+    assert st.find([2, 3]) == False
+
+    # filtration test
+    st.initialize_filtration()
+    assert st.filtration([0, 1, 2]) == 4.0
+    assert st.filtration([0, 2]) == 4.0
+    assert st.filtration([1, 2]) == 4.0
+    assert st.filtration([2]) == 4.0
+    assert st.filtration([0, 1]) == 0.0
+    assert st.filtration([0]) == 0.0
+    assert st.filtration([1]) == 0.0
+
+    # skeleton test
+    assert st.get_skeleton(2) == [
+        ([0, 1, 2], 4.0),
+        ([0, 1], 0.0),
+        ([0, 2], 4.0),
+        ([0], 0.0),
+        ([1, 2], 4.0),
+        ([1], 0.0),
+        ([2], 4.0),
+    ]
+    assert st.get_skeleton(1) == [
+        ([0, 1], 0.0),
+        ([0, 2], 4.0),
+        ([0], 0.0),
+        ([1, 2], 4.0),
+        ([1], 0.0),
+        ([2], 4.0),
+    ]
+    assert st.get_skeleton(0) == [([0], 0.0), ([1], 0.0), ([2], 4.0)]
+
+    # remove_maximal_simplex test
+    assert st.get_cofaces([0, 1, 2], 1) == []
+    st.remove_maximal_simplex([0, 1, 2])
+    assert st.get_skeleton(2) == [
+        ([0, 1], 0.0),
+        ([0, 2], 4.0),
+        ([0], 0.0),
+        ([1, 2], 4.0),
+        ([1], 0.0),
+        ([2], 4.0),
+    ]
+    assert st.find([0, 1, 2]) == False
+    assert st.find([0, 1]) == True
+    assert st.find([0, 2]) == True
+    assert st.find([0]) == True
+    assert st.find([1]) == True
+    assert st.find([2]) == True
+
+    st.initialize_filtration()
+    assert st.persistence(persistence_dim_max=True) == [
+        (1, (4.0, float("inf"))),
+        (0, (0.0, float("inf"))),
+    ]
+    assert st.__is_persistence_defined() == True
+
+    assert st.betti_numbers() == [1, 1]
+    assert st.persistent_betti_numbers(-0.1, 10000.0) == [0, 0]
+    assert st.persistent_betti_numbers(0.0, 10000.0) == [1, 0]
+    assert st.persistent_betti_numbers(3.9, 10000.0) == [1, 0]
+    assert st.persistent_betti_numbers(4.0, 10000.0) == [1, 1]
+    assert st.persistent_betti_numbers(9999.0, 10000.0) == [1, 1]
+
+
+def test_expansion():
+    st = SimplexTree()
+    assert st.__is_defined() == True
+    assert st.__is_persistence_defined() == False
+
+    # insert test
+    assert st.insert([3, 2], 0.1) == True
+    assert st.insert([2, 0], 0.2) == True
+    assert st.insert([1, 0], 0.3) == True
+    assert st.insert([3, 1], 0.4) == True
+    assert st.insert([2, 1], 0.5) == True
+    assert st.insert([6, 5], 0.6) == True
+    assert st.insert([4, 2], 0.7) == True
+    assert st.insert([3, 0], 0.8) == True
+    assert st.insert([6, 4], 0.9) == True
+    assert st.insert([6, 3], 1.0) == True
+
+    assert st.num_vertices() == 7
+    assert st.num_simplices() == 17
+    assert st.get_filtration() == [
+        ([2], 0.1),
+        ([3], 0.1),
+        ([2, 3], 0.1),
+        ([0], 0.2),
+        ([0, 2], 0.2),
+        ([1], 0.3),
+        ([0, 1], 0.3),
+        ([1, 3], 0.4),
+        ([1, 2], 0.5),
+        ([5], 0.6),
+        ([6], 0.6),
+        ([5, 6], 0.6),
+        ([4], 0.7),
+        ([2, 4], 0.7),
+        ([0, 3], 0.8),
+        ([4, 6], 0.9),
+        ([3, 6], 1.0),
+    ]
+
+    st.expansion(3)
+    assert st.num_vertices() == 7
+    assert st.num_simplices() == 22
+    st.initialize_filtration()
+
+    assert st.get_filtration() == [
+        ([2], 0.1),
+        ([3], 0.1),
+        ([2, 3], 0.1),
+        ([0], 0.2),
+        ([0, 2], 0.2),
+        ([1], 0.3),
+        ([0, 1], 0.3),
+        ([1, 3], 0.4),
+        ([1, 2], 0.5),
+        ([0, 1, 2], 0.5),
+        ([1, 2, 3], 0.5),
+        ([5], 0.6),
+        ([6], 0.6),
+        ([5, 6], 0.6),
+        ([4], 0.7),
+        ([2, 4], 0.7),
+        ([0, 3], 0.8),
+        ([0, 1, 3], 0.8),
+        ([0, 2, 3], 0.8),
+        ([0, 1, 2, 3], 0.8),
+        ([4, 6], 0.9),
+        ([3, 6], 1.0),
+    ]
+
+
+def test_automatic_dimension():
+    st = SimplexTree()
+    assert st.__is_defined() == True
+    assert st.__is_persistence_defined() == False
+
+    # insert test
+    assert st.insert([0, 1, 3], filtration=0.5) == True
+    assert st.insert([0, 1, 2], filtration=1.0) == True
+
+    assert st.num_vertices() == 4
+    assert st.num_simplices() == 11
+
+    assert st.dimension() == 2
+    assert st.upper_bound_dimension() == 2
+
+    assert st.prune_above_filtration(0.6) == True
+    assert st.dimension() == 2
+    assert st.upper_bound_dimension() == 2
+
+    st.assign_filtration([0, 1, 3], 0.7)
+    assert st.filtration([0, 1, 3]) == 0.7
+
+    st.remove_maximal_simplex([0, 1, 3])
+    assert st.upper_bound_dimension() == 2
+    assert st.dimension() == 1
+    assert st.upper_bound_dimension() == 1
+
+
+def test_make_filtration_non_decreasing():
+    st = SimplexTree()
+    assert st.__is_defined() == True
+    assert st.__is_persistence_defined() == False
+
+    # Inserted simplex:
+    #    1
+    #    o
+    #   /X\
+    #  o---o---o---o
+    #  2   0   3\X/4
+    #            o
+    #            5
+    assert st.insert([2, 1, 0], filtration=2.0) == True
+    assert st.insert([3, 0], filtration=2.0) == True
+    assert st.insert([3, 4, 5], filtration=2.0) == True
+
+    assert st.make_filtration_non_decreasing() == False
+
+    # Because of non decreasing property of simplex tree, { 0 } , { 1 } and
+    # { 0, 1 } are going to be set from value 2.0 to 1.0
+    st.insert([0, 1, 6, 7], filtration=1.0)
+
+    assert st.make_filtration_non_decreasing() == False
+
+    # Modify specific values to test make_filtration_non_decreasing
+    st.assign_filtration([0, 1, 6, 7], 0.8)
+    st.assign_filtration([0, 1, 6], 0.9)
+    st.assign_filtration([0, 6], 0.6)
+    st.assign_filtration([3, 4, 5], 1.2)
+    st.assign_filtration([3, 4], 1.1)
+    st.assign_filtration([4, 5], 1.99)
+
+    assert st.make_filtration_non_decreasing() == True
+
+    assert st.filtration([0, 1, 6, 7]) == 1.0
+    assert st.filtration([0, 1, 6]) == 1.0
+    assert st.filtration([0, 1]) == 1.0
+    assert st.filtration([0]) == 1.0
+    assert st.filtration([1]) == 1.0
+    assert st.filtration([3, 4, 5]) == 2.0
+    assert st.filtration([3, 4]) == 2.0
+    assert st.filtration([4, 5]) == 2.0
diff --git a/src/python/test/test_subsampling.py b/src/python/test/test_subsampling.py
new file mode 100755
index 00000000..c816e203
--- /dev/null
+++ b/src/python/test/test_subsampling.py
@@ -0,0 +1,179 @@
+import gudhi
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_write_off_file_for_tests():
+    file = open("subsample.off", "w")
+    file.write("nOFF\n")
+    file.write("2 7 0 0\n")
+    file.write("1.0 1.0\n")
+    file.write("7.0 0.0\n")
+    file.write("4.0 6.0\n")
+    file.write("9.0 6.0\n")
+    file.write("0.0 14.0\n")
+    file.write("2.0 19.0\n")
+    file.write("9.0 17.0\n")
+    file.close()
+
+
+def test_simple_choose_n_farthest_points_with_a_starting_point():
+    point_set = [[0, 1], [0, 0], [1, 0], [1, 1]]
+    i = 0
+    for point in point_set:
+        # The iteration starts with the given starting point
+        sub_set = gudhi.choose_n_farthest_points(
+            points=point_set, nb_points=1, starting_point=i
+        )
+        assert sub_set[0] == point_set[i]
+        i = i + 1
+
+    # The iteration finds then the farthest
+    sub_set = gudhi.choose_n_farthest_points(
+        points=point_set, nb_points=2, starting_point=1
+    )
+    assert sub_set[1] == point_set[3]
+    sub_set = gudhi.choose_n_farthest_points(
+        points=point_set, nb_points=2, starting_point=3
+    )
+    assert sub_set[1] == point_set[1]
+    sub_set = gudhi.choose_n_farthest_points(
+        points=point_set, nb_points=2, starting_point=0
+    )
+    assert sub_set[1] == point_set[2]
+    sub_set = gudhi.choose_n_farthest_points(
+        points=point_set, nb_points=2, starting_point=2
+    )
+    assert sub_set[1] == point_set[0]
+
+    # Test the limits
+    assert (
+        gudhi.choose_n_farthest_points(points=[], nb_points=0, starting_point=0) == []
+    )
+    assert (
+        gudhi.choose_n_farthest_points(points=[], nb_points=1, starting_point=0) == []
+    )
+    assert (
+        gudhi.choose_n_farthest_points(points=[], nb_points=0, starting_point=1) == []
+    )
+    assert (
+        gudhi.choose_n_farthest_points(points=[], nb_points=1, starting_point=1) == []
+    )
+
+    # From off file test
+    for i in range(0, 7):
+        assert (
+            len(
+                gudhi.choose_n_farthest_points(
+                    off_file="subsample.off", nb_points=i, starting_point=i
+                )
+            )
+            == i
+        )
+
+
+def test_simple_choose_n_farthest_points_randomed():
+    point_set = [[0, 1], [0, 0], [1, 0], [1, 1]]
+    # Test the limits
+    assert gudhi.choose_n_farthest_points(points=[], nb_points=0) == []
+    assert gudhi.choose_n_farthest_points(points=[], nb_points=1) == []
+    assert gudhi.choose_n_farthest_points(points=point_set, nb_points=0) == []
+
+    # Go furter than point set on purpose
+    for iter in range(1, 10):
+        sub_set = gudhi.choose_n_farthest_points(points=point_set, nb_points=iter)
+        for sub in sub_set:
+            found = False
+            for point in point_set:
+                if point == sub:
+                    found = True
+            # Check each sub set point is existing in the point set
+            assert found == True
+
+    # From off file test
+    for i in range(0, 7):
+        assert (
+            len(gudhi.choose_n_farthest_points(off_file="subsample.off", nb_points=i))
+            == i
+        )
+
+
+def test_simple_pick_n_random_points():
+    point_set = [[0, 1], [0, 0], [1, 0], [1, 1]]
+    # Test the limits
+    assert gudhi.pick_n_random_points(points=[], nb_points=0) == []
+    assert gudhi.pick_n_random_points(points=[], nb_points=1) == []
+    assert gudhi.pick_n_random_points(points=point_set, nb_points=0) == []
+
+    # Go furter than point set on purpose
+    for iter in range(1, 10):
+        sub_set = gudhi.pick_n_random_points(points=point_set, nb_points=iter)
+        print(5)
+        for sub in sub_set:
+            found = False
+            for point in point_set:
+                if point == sub:
+                    found = True
+            # Check each sub set point is existing in the point set
+            assert found == True
+
+    # From off file test
+    for i in range(0, 7):
+        assert (
+            len(gudhi.pick_n_random_points(off_file="subsample.off", nb_points=i)) == i
+        )
+
+
+def test_simple_sparsify_points():
+    point_set = [[0, 1], [0, 0], [1, 0], [1, 1]]
+    # Test the limits
+    # assert gudhi.sparsify_point_set(points = [], min_squared_dist = 0.0) == []
+    # assert gudhi.sparsify_point_set(points = [], min_squared_dist = 10.0) == []
+    assert gudhi.sparsify_point_set(points=point_set, min_squared_dist=0.0) == point_set
+    assert gudhi.sparsify_point_set(points=point_set, min_squared_dist=1.0) == point_set
+    assert gudhi.sparsify_point_set(points=point_set, min_squared_dist=2.0) == [
+        [0, 1],
+        [1, 0],
+    ]
+    assert gudhi.sparsify_point_set(points=point_set, min_squared_dist=2.01) == [[0, 1]]
+
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=0.0))
+        == 7
+    )
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=30.0))
+        == 5
+    )
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=40.0))
+        == 4
+    )
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=90.0))
+        == 3
+    )
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=100.0))
+        == 2
+    )
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=325.0))
+        == 2
+    )
+    assert (
+        len(gudhi.sparsify_point_set(off_file="subsample.off", min_squared_dist=325.01))
+        == 1
+    )
diff --git a/src/python/test/test_tangential_complex.py b/src/python/test/test_tangential_complex.py
new file mode 100755
index 00000000..0f828d8e
--- /dev/null
+++ b/src/python/test/test_tangential_complex.py
@@ -0,0 +1,55 @@
+from gudhi import TangentialComplex, SimplexTree
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_tangential():
+    point_list = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]
+    tc = TangentialComplex(intrisic_dim=1, points=point_list)
+    assert tc.__is_defined() == True
+    assert tc.num_vertices() == 4
+    assert tc.num_simplices() == 0
+    assert tc.num_inconsistent_simplices() == 0
+    assert tc.num_inconsistent_stars() == 0
+
+    tc.compute_tangential_complex()
+    assert tc.num_vertices() == 4
+    assert tc.num_simplices() == 4
+    assert tc.num_inconsistent_simplices() == 0
+    assert tc.num_inconsistent_stars() == 0
+
+    st = tc.create_simplex_tree()
+    assert st.__is_defined() == True
+    assert st.__is_persistence_defined() == False
+
+    assert st.num_simplices() == 6
+    assert st.num_vertices() == 4
+
+    assert st.get_filtration() == [
+        ([0], 0.0),
+        ([1], 0.0),
+        ([2], 0.0),
+        ([0, 2], 0.0),
+        ([3], 0.0),
+        ([1, 3], 0.0),
+    ]
+    assert st.get_cofaces([0], 1) == [([0, 2], 0.0)]
+
+    assert point_list[0] == tc.get_point(0)
+    assert point_list[1] == tc.get_point(1)
+    assert point_list[2] == tc.get_point(2)
+    assert point_list[3] == tc.get_point(3)
+    assert tc.get_point(4) == []
+    assert tc.get_point(125) == []
diff --git a/src/python/test/test_witness_complex.py b/src/python/test/test_witness_complex.py
new file mode 100755
index 00000000..36ced635
--- /dev/null
+++ b/src/python/test/test_witness_complex.py
@@ -0,0 +1,62 @@
+from gudhi import WitnessComplex, StrongWitnessComplex, SimplexTree
+
+""" This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+    Author(s):       Vincent Rouvreau
+
+    Copyright (C) 2016 Inria
+
+    Modification(s):
+      - YYYY/MM Author: Description of the modification
+"""
+
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016 Inria"
+__license__ = "MIT"
+
+
+def test_empty_witness_complex():
+    witness = WitnessComplex()
+    assert witness.__is_defined() == False
+
+
+def test_witness_complex():
+    nearest_landmark_table = [
+        [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]],
+        [[1, 0], [2, 1], [3, 2], [4, 3], [0, 4]],
+        [[2, 0], [3, 1], [4, 2], [0, 3], [1, 4]],
+        [[3, 0], [4, 1], [0, 2], [1, 3], [2, 4]],
+        [[4, 0], [0, 1], [1, 2], [2, 3], [3, 4]],
+    ]
+
+    witness_complex = WitnessComplex(nearest_landmark_table=nearest_landmark_table)
+    simplex_tree = witness_complex.create_simplex_tree(max_alpha_square=4.1)
+    assert simplex_tree.num_vertices() == 5
+    assert simplex_tree.num_simplices() == 31
+    simplex_tree = witness_complex.create_simplex_tree(
+        max_alpha_square=4.1, limit_dimension=2
+    )
+    assert simplex_tree.num_vertices() == 5
+    assert simplex_tree.num_simplices() == 25
+
+
+def test_strong_witness_complex():
+    nearest_landmark_table = [
+        [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]],
+        [[1, 0], [2, 1], [3, 2], [4, 3], [0, 4]],
+        [[2, 0], [3, 1], [4, 2], [0, 3], [1, 4]],
+        [[3, 0], [4, 1], [0, 2], [1, 3], [2, 4]],
+        [[4, 0], [0, 1], [1, 2], [2, 3], [3, 4]],
+    ]
+
+    strong_witness_complex = StrongWitnessComplex(
+        nearest_landmark_table=nearest_landmark_table
+    )
+    simplex_tree = strong_witness_complex.create_simplex_tree(max_alpha_square=4.1)
+    assert simplex_tree.num_vertices() == 5
+    assert simplex_tree.num_simplices() == 31
+    simplex_tree = strong_witness_complex.create_simplex_tree(
+        max_alpha_square=4.1, limit_dimension=2
+    )
+    assert simplex_tree.num_vertices() == 5
+    assert simplex_tree.num_simplices() == 25