}

    @DisplayName("Should parse different share types correctly")
    @ParameterizedTest
    @CsvSource({ "1, 1", // DISK
            "2, 2", // PIPE
            "3, 3", // PRINT
            "0, 0", // Unknown
            "255, -1" // Byte overflow to signed
    })
    void testDifferentShareTypes(int shareTypeValue, int expectedValue) throws SMBProtocolDecodingException {
        // Given

    public static final int SID_NAME_DELETED = 6;
    /** SID name type: invalid. */
    /** SID name type: invalid. */
    public static final int SID_NAME_INVALID = 7;
    /** SID name type: unknown. */
    /** SID name type: unknown. */
    public static final int SID_NAME_UNKNOWN = 8;

    /**
     * LSA translated SID.
     */
    public static class LsarTranslatedSid extends NdrObject {

        /**

            // Given
            when(transportPool.getSmbTransport(context, "unknown.host", DEFAULT_PORT, false, false))
                    .thenThrow(new UnknownHostException("Unknown host"));

            // When & Then
            assertThrows(UnknownHostException.class,
                    () -> transportPool.getSmbTransport(context, "unknown.host", DEFAULT_PORT, false, false));
        }

        @Test

     */
    public static String getHashAlgorithmName(int algorithm) {
        switch (algorithm) {
        case HASH_ALGO_SHA512:
            return "SHA-512";
        default:
            return "Unknown(0x" + Integer.toHexString(algorithm) + ")";
        }
    }

    /**
     * Clears all session contexts (for cleanup).
     */
    public void cleanup() {

        assertTrue(queryCommand.isSearchField("filetype"));

        // Test invalid search fields
        assertFalse(queryCommand.isSearchField("invalid"));
        assertFalse(queryCommand.isSearchField("unknown"));
        assertFalse(queryCommand.isSearchField(""));
    }

    /**
     * Test isSearchField() with null field.
     */
    @Test
    public void test_isSearchField_withNull() {

        Encdec.enc_uint32le(0x00000000, blob, 4); // Reserved
        Encdec.enc_uint64le(nanos1601, blob, 8);
        System.arraycopy(clientChallenge, 0, blob, 16, 8);
        Encdec.enc_uint32le(0x00000000, blob, 24); // Unknown
        System.arraycopy(avPairs, 0, blob, 28, avPairsLength);
        Encdec.enc_uint32le(0x00000000, blob, 28 + avPairsLength);

        // Act

                String projectName = getParameters().getProjectBuildDirs().get().get(dependencyFile);
                if (projectName == null) {
                    throw new IllegalStateException("Build directory unknown to gradle: " + dependencyFile);
                }
                return "project " + projectName;
            }
            return dependencyFile.getName(); // just the jar filename
        }
    }

    assertThat(closed.get()).isTrue()
  }

  @Test
  fun unicodeTextWithUnsupportedEncoding() {
    val text = "eile oli oliiviõli"
    val body = text.toResponseBody("text/plain; charset=unknown".toMediaType())
    assertThat(body.string()).isEqualTo(text)
  }

  companion object {
    @JvmOverloads
    fun body(
      hex: String,
      charset: String? = null,
    ): ResponseBody {

                    } else if ("file".equalsIgnoreCase(protocolType)) {
                        addFileProtocol(protocol);
                    } else {
                        logger.warn("Unknown protocol: protocol={}", protocol);
                    }
                }
            } catch (final ClassNotFoundRuntimeException e) {
                logger.debug("{}.{}.Handler does not exist.", basePackage, protocol, e);

						invalid_response: '<la:message key="labels.chat_error_invalid_response" />',
						connection_error: '<la:message key="labels.chat_error_connection" />',
						unknown: '<la:message key="labels.chat_error" />'
					}
				}
			});
		});
	</script>
</body>