diff --git a/packtools/sps/validation/funding_group.py b/packtools/sps/validation/funding_group.py
index e2c0d6d36..8cfbbe0d1 100644
--- a/packtools/sps/validation/funding_group.py
+++ b/packtools/sps/validation/funding_group.py
@@ -154,3 +154,295 @@ def validate_funding_statement(self):
                     data=statements,
                     error_level=self.params["funding_statement_error_level"],
                 )
+
+    def validate_funding_group_uniqueness(self, error_level="ERROR"):
+        """
+        Rule 1: Validates that <funding-group> appears at most once in <article-meta>.
+        
+        According to SPS 1.10, only one <funding-group> is allowed per <article-meta>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "ERROR".
+        
+        Yields
+        ------
+        dict
+            Validation result for funding-group uniqueness.
+        """
+        funding_groups = self.xml_tree.xpath(".//article-meta/funding-group")
+        count = len(funding_groups)
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        is_valid = count <= 1
+        advice = None
+        if not is_valid:
+            advice = f"Found {count} <funding-group> elements in <article-meta>. Only one is allowed. Merge them into a single <funding-group>."
+        
+        yield build_response(
+            title="funding-group uniqueness",
+            parent=parent,
+            item="funding-group",
+            sub_item=None,
+            validation_type="unique",
+            is_valid=is_valid,
+            expected="At most one <funding-group> in <article-meta>",
+            obtained=f"{count} <funding-group> element(s) found",
+            advice=advice,
+            data={"count": count},
+            error_level=error_level,
+        )
+
+    def validate_funding_statement_presence(self, error_level="CRITICAL"):
+        """
+        Rule 2: Validates that <funding-statement> is present in <funding-group>.
+        
+        According to SPS 1.10, <funding-statement> is mandatory in all cases.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "CRITICAL".
+        
+        Yields
+        ------
+        dict
+            Validation result for funding-statement presence.
+        """
+        funding_groups = self.xml_tree.xpath(".//article-meta/funding-group")
+        
+        if not funding_groups:
+            # No funding-group means no validation needed
+            return
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        funding_statement = self.funding.funding_statement
+        is_valid = funding_statement is not None
+        
+        advice = None
+        if not is_valid:
+            advice = "Add <funding-statement> element inside <funding-group>. It is mandatory according to SPS 1.10."
+        
+        yield build_response(
+            title="funding-statement presence",
+            parent=parent,
+            item="funding-statement",
+            sub_item=None,
+            validation_type="exist",
+            is_valid=is_valid,
+            expected="<funding-statement> present in <funding-group>",
+            obtained=funding_statement if funding_statement else "None",
+            advice=advice,
+            data={"funding_statement": funding_statement},
+            error_level=error_level,
+        )
+
+    def validate_funding_source_in_award_group(self, error_level="CRITICAL"):
+        """
+        Rule 3: Validates that <funding-source> is present when <award-group> exists.
+        
+        According to SPS 1.10, when there are institutions declared via <award-group>,
+        <funding-source> is mandatory.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "CRITICAL".
+        
+        Yields
+        ------
+        dict
+            Validation results for each award-group.
+        """
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        for item in self.funding.award_groups:
+            funding_sources = item["funding-source"]
+            
+            is_valid = len(funding_sources) > 0
+            advice = None
+            if not is_valid:
+                advice = "Add at least one <funding-source> element inside this <award-group>. It is mandatory when <award-group> exists."
+            
+            yield build_response(
+                title="funding-source in award-group",
+                parent=parent,
+                item="award-group",
+                sub_item="funding-source",
+                validation_type="exist",
+                is_valid=is_valid,
+                expected="At least one <funding-source> in <award-group>",
+                obtained=f"{len(funding_sources)} <funding-source> element(s) found",
+                advice=advice,
+                data=item,
+                error_level=error_level,
+            )
+
+    def validate_label_absence(self, error_level="ERROR"):
+        """
+        Rule 5: Validates that <label> is not present in <funding-group> or its descendants.
+        
+        According to SPS 1.10, <label> is not allowed inside <funding-group>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "ERROR".
+        
+        Yields
+        ------
+        dict
+            Validation result for label absence.
+        """
+        labels = self.xml_tree.xpath(".//funding-group//label")
+        count = len(labels)
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        is_valid = count == 0
+        advice = None
+        if not is_valid:
+            advice = f"Remove {count} <label> element(s) from <funding-group>. <label> is not allowed according to SPS 1.10."
+        
+        yield build_response(
+            title="label absence in funding-group",
+            parent=parent,
+            item="funding-group",
+            sub_item="label",
+            validation_type="forbidden",
+            is_valid=is_valid,
+            expected="No <label> elements in <funding-group>",
+            obtained=f"{count} <label> element(s) found",
+            advice=advice,
+            data={"count": count, "labels": [label.text for label in labels]},
+            error_level=error_level,
+        )
+
+    def validate_title_absence(self, error_level="ERROR"):
+        """
+        Rule 6: Validates that <title> is not present in <funding-group> or its descendants.
+        
+        According to SPS 1.10, <title> is not allowed inside <funding-group>.
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "ERROR".
+        
+        Yields
+        ------
+        dict
+            Validation result for title absence.
+        """
+        titles = self.xml_tree.xpath(".//funding-group//title")
+        count = len(titles)
+        
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        is_valid = count == 0
+        advice = None
+        if not is_valid:
+            advice = f"Remove {count} <title> element(s) from <funding-group>. <title> is not allowed according to SPS 1.10."
+        
+        yield build_response(
+            title="title absence in funding-group",
+            parent=parent,
+            item="funding-group",
+            sub_item="title",
+            validation_type="forbidden",
+            is_valid=is_valid,
+            expected="No <title> elements in <funding-group>",
+            obtained=f"{count} <title> element(s) found",
+            advice=advice,
+            data={"count": count, "titles": [title.text for title in titles]},
+            error_level=error_level,
+        )
+
+    def validate_award_id_funding_source_consistency(self, error_level="WARNING"):
+        """
+        Rule 7: Validates consistency of <funding-source> and <award-id> quantities.
+        
+        According to SPS 1.10, in each <award-group>, the quantity of <award-id> should be:
+        - 0: Support without contract
+        - 1: One contract for one or more funding sources
+        - N: Multiple contracts (should match number of funding sources in most cases)
+        
+        Params
+        ------
+        error_level : str, optional
+            The severity level of the validation error, by default "WARNING".
+        
+        Yields
+        ------
+        dict
+            Validation results for each award-group.
+        """
+        funding_data = self.funding.data
+        parent = {
+            "parent": "article",
+            "parent_id": None,
+            "parent_article_type": funding_data.get("article_type"),
+            "parent_lang": funding_data.get("article_lang"),
+        }
+        
+        for item in self.funding.award_groups:
+            funding_sources = item["funding-source"]
+            award_ids = item["award-id"]
+            
+            num_sources = len(funding_sources)
+            num_awards = len(award_ids)
+            
+            # Valid cases: 0 awards (support), 1 award (single contract), or N awards matching N sources
+            is_valid = num_awards == 0 or num_awards == 1 or num_awards == num_sources
+            
+            advice = None
+            if not is_valid:
+                if num_awards > 1 and num_awards != num_sources:
+                    advice = f"Inconsistent quantities: {num_sources} <funding-source>(s) but {num_awards} <award-id>(s). When multiple <award-id> elements exist, they should typically match the number of <funding-source> elements, or use separate <award-group> elements."
+            
+            yield build_response(
+                title="award-id and funding-source consistency",
+                parent=parent,
+                item="award-group",
+                sub_item="award-id",
+                validation_type="consistency",
+                is_valid=is_valid,
+                expected="Consistent quantities: 0 awards (support), 1 award (contract), or N awards matching N sources",
+                obtained=f"{num_sources} funding-source(s), {num_awards} award-id(s)",
+                advice=advice,
+                data=item,
+                error_level=error_level,
+            )
diff --git a/tests/sps/validation/test_funding_group.py b/tests/sps/validation/test_funding_group.py
index dd63c784f..26a68e543 100644
--- a/tests/sps/validation/test_funding_group.py
+++ b/tests/sps/validation/test_funding_group.py
@@ -248,5 +248,495 @@ def test_info_level(self):
         self.assertEqual(results[0]["response"], "INFO")
 
 
+# ========================================
+# New Tests for SPS 1.10 Validations
+# ========================================
+
+
+class TestFundingGroupUniqueness(TestFundingValidationBase):
+    """Rule 1: Test <funding-group> uniqueness validation"""
+
+    def test_single_funding_group_valid(self):
+        """Single <funding-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>No funding</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_multiple_funding_groups_invalid(self):
+        """Multiple <funding-group> elements should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Funding 1</funding-statement>
+                        </funding-group>
+                        <funding-group>
+                            <funding-statement>Funding 2</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "ERROR")
+        self.assertIn("2 <funding-group>", results[0]["advice"])
+
+    def test_no_funding_group_valid(self):
+        """No <funding-group> should be valid (0 <= 1)"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_group_uniqueness())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+
+class TestFundingStatementPresence(TestFundingValidationBase):
+    """Rule 2: Test <funding-statement> presence validation"""
+
+    def test_funding_statement_present_valid(self):
+        """<funding-statement> present should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>This study was supported by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_funding_statement_missing_invalid(self):
+        """Missing <funding-statement> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "CRITICAL")
+        self.assertIn("Add <funding-statement>", results[0]["advice"])
+
+    def test_no_funding_group_no_validation(self):
+        """No <funding-group> means no validation needed"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_statement_presence())
+        
+        self.assertEqual(len(results), 0)
+
+
+class TestFundingSourceInAwardGroup(TestFundingValidationBase):
+    """Rule 3: Test <funding-source> presence in <award-group> validation"""
+
+    def test_funding_source_present_valid(self):
+        """<funding-source> present in <award-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_source_in_award_group())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_funding_source_missing_invalid(self):
+        """Missing <funding-source> in <award-group> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_source_in_award_group())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "CRITICAL")
+        self.assertIn("Add at least one <funding-source>", results[0]["advice"])
+
+    def test_multiple_funding_sources_valid(self):
+        """Multiple <funding-source> elements should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <funding-source>CAPES</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP and CAPES</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_funding_source_in_award_group())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+
+class TestLabelAbsence(TestFundingValidationBase):
+    """Rule 5: Test <label> absence validation"""
+
+    def test_no_label_valid(self):
+        """No <label> in <funding-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_label_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_label_present_invalid(self):
+        """<label> in <funding-group> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <label>Funding</label>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_label_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "ERROR")
+        self.assertIn("Remove", results[0]["advice"])
+        self.assertIn("<label>", results[0]["advice"])
+
+
+class TestTitleAbsence(TestFundingValidationBase):
+    """Rule 6: Test <title> absence validation"""
+
+    def test_no_title_valid(self):
+        """No <title> in <funding-group> should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_title_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_title_present_invalid(self):
+        """<title> in <funding-group> should be invalid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <title>Funding Information</title>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_title_absence())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "ERROR")
+        self.assertIn("Remove", results[0]["advice"])
+        self.assertIn("<title>", results[0]["advice"])
+
+
+class TestAwardIdFundingSourceConsistency(TestFundingValidationBase):
+    """Rule 7: Test <award-id> and <funding-source> consistency validation"""
+
+    def test_support_without_contract_valid(self):
+        """Support without contract (0 award-ids) should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_single_contract_valid(self):
+        """Single contract (1 award-id) for multiple sources should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <funding-source>CAPES</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP and CAPES</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_matching_quantities_valid(self):
+        """Matching quantities (N sources, N awards) should be valid"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <funding-source>CAPES</funding-source>
+                                <award-id>04/08142-0</award-id>
+                                <award-id>05/09876-5</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP and CAPES</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "OK")
+
+    def test_inconsistent_quantities_warning(self):
+        """Inconsistent quantities should trigger warning"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>FAPESP</funding-source>
+                                <award-id>04/08142-0</award-id>
+                                <award-id>05/09876-5</award-id>
+                                <award-id>06/12345-6</award-id>
+                            </award-group>
+                            <funding-statement>Funded by FAPESP</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        results = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["response"], "WARNING")
+        self.assertIn("Inconsistent quantities", results[0]["advice"])
+
+
+class TestCompleteValidExamples(TestFundingValidationBase):
+    """Test complete valid XML examples from the issue"""
+
+    def test_example_1_funding_with_contract(self):
+        """Example 1: Funding with contract number"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <award-group>
+                                <funding-source>Fundação de Amparo à Pesquisa do Estado de São Paulo (FAPESP)</funding-source>
+                                <award-id>04/08142-0</award-id>
+                            </award-group>
+                            <funding-statement>This study was supported by Fundação de Amparo à Pesquisa do Estado de São Paulo (FAPESP - Grant no. 04/08142-0; São Paulo, Brazil)</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        
+        # All validations should pass
+        uniqueness = list(validator.validate_funding_group_uniqueness())
+        statement = list(validator.validate_funding_statement_presence())
+        source = list(validator.validate_funding_source_in_award_group())
+        label = list(validator.validate_label_absence())
+        title = list(validator.validate_title_absence())
+        consistency = list(validator.validate_award_id_funding_source_consistency())
+        
+        self.assertEqual(uniqueness[0]["response"], "OK")
+        self.assertEqual(statement[0]["response"], "OK")
+        self.assertEqual(source[0]["response"], "OK")
+        self.assertEqual(label[0]["response"], "OK")
+        self.assertEqual(title[0]["response"], "OK")
+        self.assertEqual(consistency[0]["response"], "OK")
+
+    def test_example_6_negative_funding_declaration(self):
+        """Example 6: Negative funding declaration"""
+        xml = """
+            <article article-type="research-article" xml:lang="en">
+                <front>
+                    <article-meta>
+                        <funding-group>
+                            <funding-statement>Não houve financiamento para esta publicação</funding-statement>
+                        </funding-group>
+                    </article-meta>
+                </front>
+            </article>
+        """
+        xml_tree = etree.fromstring(xml)
+        validator = FundingGroupValidation(xml_tree, self.params)
+        
+        # Should pass all checks (no award-group means no source validation)
+        uniqueness = list(validator.validate_funding_group_uniqueness())
+        statement = list(validator.validate_funding_statement_presence())
+        source = list(validator.validate_funding_source_in_award_group())
+        label = list(validator.validate_label_absence())
+        title = list(validator.validate_title_absence())
+        
+        self.assertEqual(uniqueness[0]["response"], "OK")
+        self.assertEqual(statement[0]["response"], "OK")
+        self.assertEqual(len(source), 0)  # No award-group, so no validation
+        self.assertEqual(label[0]["response"], "OK")
+        self.assertEqual(title[0]["response"], "OK")
+
+
 if __name__ == "__main__":
     unittest.main()