@NullUnmarked
public class ImmutableSortedMapHeadMapMapInterfaceTest
    extends AbstractImmutableSortedMapMapInterfaceTest<String, Integer> {
  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).headMap("d");
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "d";
  }

  @Override

@NullUnmarked
public class ImmutableSortedMapSubMapMapInterfaceTest
    extends AbstractImmutableSortedMapMapInterfaceTest<String, Integer> {
  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).subMap("b", "d");
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "a";
  }

  @Override

        // Test with various path formats
        String[] testPaths = { "simple.txt", "path/to/file.doc", "//server/share/file.txt", "folder\\windows\\style.txt", "" // empty path
        };

        for (String path : testPaths) {
            trans2QueryPathInfo = new Trans2QueryPathInformation(config, path, TEST_INFO_LEVEL);
            String result = trans2QueryPathInfo.toString();

            assertNotNull(result);

    @DisplayName("toString should handle various pipe names")
    void testToStringWithVariousPipeNames(String pipeName) {
        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, pipeName, TEST_FID);

        // Act
        String result = transPeekNamedPipe.toString();

        // Assert
        assertNotNull(result);

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // Calculate offsets (must be 4-byte aligned)
        String fileName1 = "file1.txt";
        String fileName2 = "file2.txt";
        String fileName3 = "file3.txt";

        byte[] fileNameBytes1 = fileName1.getBytes("UTF-16LE");
        byte[] fileNameBytes2 = fileName2.getBytes("UTF-16LE");

        };
    }

    /**
     * Encodes a String as UTF-8 bytes.
     *
     * @param str the String to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @param dlim the maximum index in the destination array
     * @return the number of bytes written
     */
    public static int enc_utf8(final String str, final byte[] dst, int di, final int dlim) {

		t.Fatalf("failed to upsert, got name %v", result.Name)
	}

	if name := DB.Dialector.Name(); name != "sqlserver" {
		type RestrictedLanguage struct {
			Code string `gorm:"primarykey"`
			Name string
			Lang string `gorm:"<-:create"`
		}

                String initialNamespace,
                String initialModelVersion,
                String targetModelVersion,
                String expectedNamespace,
                String expectedModelVersion,
                int expectedModifiedCount,
                String description) {

            String pomXml = PomBuilder.create()

        try {
          base.evaluate()
        } finally {
          afterEach(null)
        }
      }
    }

  fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String =
    logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")

     */
    public MojoFailureException(Object source, String shortMessage, String longMessage) {
        super(shortMessage);
        this.source = source;
        this.longMessage = longMessage;
    }

    /**
     * Construct a new <code>MojoFailureException</code> exception providing a message.
     *
     * @param message
     */
    public MojoFailureException(String message) {
        super(message);
    }

    /**