final String content = new String(is.readAllBytes(), StandardCharsets.UTF_8);
            assertTrue("Mapping content should not be empty", content.length() > 0);
            assertTrue("Mapping should contain properties", content.contains("properties"));
        }
    }

    /**
     * Test that getDefaultIndexSettings correctly loads and returns settings resource.
     */
    @Test

            fail("Expected exception for invalid Word document");
        } catch (final ExtractException e) {
            // ExtractException with improved message
            assertTrue("Error message should contain context about Word document or extraction",
                    e.getMessage().contains("Word") || e.getMessage().contains("extract"));
        } catch (final RuntimeException e) {

        assertTrue(labels.contains("a"), "Expected " + labels + " to contain " + "a");
        assertTrue(labels.contains("b"), "Expected " + labels + " to contain " + "b");
        assertTrue(labels.contains("c"), "Expected " + labels + " to contain " + "c");
        assertTrue(labels.contains("d"), "Expected " + labels + " to contain " + "d");

        addEdge(graph, "a", "d");
        assertEquals(2, a.getChildren().size());

     * and that the expecption message contains the expected and actual <abbr>GAV</abbr>.
     *
     * @param expectedGAV the actual <abbr>GAV</abbr> that the exception message should contain
     * @param actualGAV the actual <abbr>GAV</abbr> that the exception message should contain
     */
    private void assertExceptionMessageContains(String expectedGAV, String actualGAV) {
        String cause = assertThrows(

  }

  protected void expectMissingKeys(K... elements) {
    for (K element : elements) {
      assertFalse("Should not contain key " + element, getMap().containsKey(element));
    }
  }

  protected void expectMissingValues(V... elements) {
    for (V element : elements) {
      assertFalse("Should not contain value " + element, getMap().containsValue(element));
    }
  }

  /**

        assertEquals(2, downstreamProjects.size());
        assertTrue(downstreamProjects.contains(dProject), "Expected " + downstreamProjects + " to contain " + dProject);
        assertTrue(downstreamProjects.contains(eProject), "Expected " + downstreamProjects + " to contain " + eProject);
    }

    @Test
    void testGetSortedProjects() throws DuplicateProjectException, CycleDetectedException {

        assertTrue(projects.contains(pluginProject), "Expected " + projects + " to contain " + pluginProject);
        assertTrue(
                projects.contains(pluginLevelDepProject),
                "Expected " + projects + " to contain " + pluginLevelDepProject);

        // the declaring project MUST be listed after the plugin and its plugin-level dep, though.

        // toString uses Hexdump.toHexString(informationLevel, 3)
        assertTrue(str.contains(Hexdump.toHexString(level, 3)), "toString should contain hex level");
        assertTrue(str.contains("Trans2QueryFSInformation["), "should start with class name");
        assertTrue(str.contains(",informationLevel=0x"), "should contain level field marker");
    }

        if (!table) {
            throw new RuntimeException("Section '$title' does not contain a <table> element.")
        }
        if (!table.thead[0]) {
            throw new RuntimeException("Table '$title' does not contain a <thead> element.")
        }
        if (!table.thead[0].tr[0]) {
            throw new RuntimeException("Table '$title' does not contain a <thead>/<tr> element.")
        }
        return table
    }

        String result = pipe.toString();
        assertNotNull(result);
        assertTrue(result.contains("TransWaitNamedPipe"), "toString should contain class name");
        assertTrue(result.contains(pipeName), "toString should contain pipe name");
    }

    @Test
    public void testMultiplePipeNames() {
        // Test with various pipe names