feat: moving the tests to its corresponding place

shacl_validation/tests/core/complex/mod.rs

@@ -1,17 +1,24 @@
 use shacl_validation::shacl_processor::ShaclValidationMode;
 
 use crate::test;
+use crate::TestSuite;
 
-const PATH: &str = "/tests/data-shapes/data-shapes-test-suite/tests/core/complex/";
+const PATH: &str = "tests/data-shapes/data-shapes-test-suite/tests/core/complex/";
 
 #[test]
-fn personexample() {
+fn personexample() -> Result<(), TestSuite> {
     let path = format!("{}/{}.ttl", PATH, "personexample");
-    test(path, ShaclValidationMode::Native, false);
+    test(path, ShaclValidationMode::Native, false)
 }
 
 #[test]
-fn shacl_shacl_data_shapes() {}
+fn shacl_shacl_data_shapes() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "shacl-shacl-data-shapes");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn shacl_shacl() {}
+fn shacl_shacl() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "shacl-shacl");
+    test(path, ShaclValidationMode::Native, false)
+}

shacl_validation/tests/core/misc/mod.rs

@@ -1,14 +1,36 @@
+use shacl_validation::shacl_processor::ShaclValidationMode;
+
+use crate::test;
+use crate::TestSuite;
+
+const PATH: &str = "tests/data-shapes/data-shapes-test-suite/tests/core/misc/";
+
 #[test]
-fn deactivated_001() {}
+fn deactivated_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "deactivated-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn deactivated_002() {}
+fn deactivated_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "deactivated-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn message_001() {}
+fn message_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "message-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn severity_001() {}
+fn severity_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "severity-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn severity_002() {}
+fn severity_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "severity-002");
+    test(path, ShaclValidationMode::Native, false)
+}

shacl_validation/tests/core/node/mod.rs

@@ -1,116 +1,222 @@
 use shacl_validation::shacl_processor::ShaclValidationMode;
 
 use crate::test;
+use crate::TestSuite;
 
-const PATH: &str = "/tests/data-shapes/data-shapes-test-suite/tests/core/node/";
+const PATH: &str = "tests/data-shapes/data-shapes-test-suite/tests/core/node/";
 
 #[test]
-fn and_001() {
+fn and_001() -> Result<(), TestSuite> {
     let path = format!("{}/{}.ttl", PATH, "and-001");
-    test(path, ShaclValidationMode::Native, false);
+    test(path, ShaclValidationMode::Native, false)
 }
 
 #[test]
-fn and_002() {}
+fn and_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "and-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn class_001() {}
+fn class_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "class-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn class_002() {}
+fn class_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "class-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn class_003() {}
+fn class_003() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "class-003");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn closed_001() {}
+fn closed_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "closed-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn closed_002() {}
+fn closed_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "closed-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn datatype_001() {}
+fn datatype_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "datatype-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn datatype_002() {}
+fn datatype_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "datatype-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn disjoint_001() {}
+fn disjoint_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "disjoint-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn equals_001() {}
+fn equals_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "equals-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn hasValue_001() {}
+fn has_value_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "hasValue-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn in_001() {}
+fn in_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "in-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn languageIn_001() {}
+fn language_in_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "languageIn-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn maxExclusive_001() {}
+fn max_exclusive_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "maxExclusive-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn maxInclusive_001() {}
+fn max_inclusive_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "maxInclusive-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn maxLength_001() {}
+fn max_length_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "maxLength-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn minExclusive_001() {}
+fn min_exclusive_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "minExclusive-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn minInclusive_001() {}
+fn min_inclusive_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "minInclusive-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn minInclusive_002() {}
+fn min_inclusive_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "minInclusive-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn minInclusive_003() {}
+fn min_inclusive_003() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "minInclusive-003");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn minLength_001() {}
+fn min_length_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "minLength-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn node_001() {}
+fn node_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "node-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn nodeKind_001() {}
+fn node_kind_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "nodeKind-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn not_001() {}
+fn not_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "not-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn not_002() {}
+fn not_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "not-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn or_001() {}
+fn or_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "or-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn pattern_001() {}
+fn pattern_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "pattern-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn pattern_002() {}
+fn pattern_002() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "pattern-002");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn qualified_001_data() {}
+fn qualified_001_data() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "qualified-001-data");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn qualified_001_shapes() {}
+fn qualified_001_shapes() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "qualified-001-shapes");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn qualified_001() {}
+fn qualified_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "qualified-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn xone_001() {}
+fn xone_001() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "xone-001");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn xone_duplicate_data() {}
+fn xone_duplicate_data() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "xone-duplicate-data");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn xone_duplicate_shapes() {}
+fn xone_duplicate_shapes() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "xone-duplicate-shapes");
+    test(path, ShaclValidationMode::Native, false)
+}
 
 #[test]
-fn xone_duplicate() {}
+fn xone_duplicate() -> Result<(), TestSuite> {
+    let path = format!("{}/{}.ttl", PATH, "xone-duplicate");
+    test(path, ShaclValidationMode::Native, false)
+}