}
        };

        String[] testStrings = { "simple", "with spaces", "special!@#$%^&*()", "unicode_test", "", "very long string " + "x".repeat(100) };

        for (String testStr : testStrings) {
            String encrypted = cipher.encrypt(testStr);
            String decrypted = cipher.decrypt(encrypted);

     * @throws IllegalAccessRuntimeException {@link IllegalAccessException} if an error occurs
     * @see #getString(Field, Object)
     */
    public static String getString(final Field field) throws IllegalAccessRuntimeException {
        assertArgumentNotNull("field", field);

        return getString(field, null);
    }

    /**
     * Returns the value of a {@link Field} as a {@link String}.
     *

     * @throws RuntimeException If failed (and not due source not exists).
     */
    @Nonnull
    default Optional<String> getString(@Nonnull URI relativeSource) {
        return getString(relativeSource, StandardCharsets.UTF_8);
    }

    /**
     * PUTs the source file (must exist as file) to target URI. The target MUST BE relative from the

        FieldUtil.set(field, this, testData);
        assertThat(FieldUtil.getString(field, this), is(testData));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetStringFieldObject() throws Exception {
        final Field field = getClass().getField("STRING_DATA");
        assertThat(FieldUtil.getString(field), is(STRING_DATA));
    }

    /**
     * @throws Exception
     */

        // This method is expected to do nothing and return 0
        int result = smbComQueryInformation.readBytesWireFormat(new byte[0], 0);
        assertEquals(0, result);
    }

    @Test
    public void testToString() {
        // Test the string representation of the object
        String result = smbComQueryInformation.toString();
        assertTrue(result.startsWith("SmbComQueryInformation["));

            final String pattern = ResourceBundleUtil.getString(resourceBundle, key);
            if (pattern != null) {
                return pattern;
            }
        }
        return resourceBundle.getString(messageCode);
    }

    /**
     * Returns the system name.
     *
     * @param messageCode

        assertEquals(e.getMessage(), NbtException.getErrorString(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED));
    }

    @Test
    @DisplayName("toString includes class, code and error string")
    void testToString() {
        NbtException e = new NbtException(NbtException.ERR_SSN_SRVC, NbtException.NO_RESOURCES);
        String str = e.toString();
        assertTrue(str.contains("errorClass=2"));

        // When
        int result = trans2SetFileInformation.readDataWireFormat(new byte[0], 0, 0);

        // Then
        assertEquals(0, result);
    }

    @Test
    void testToString() {
        // When
        String result = trans2SetFileInformation.toString();

        // Then
        assertTrue(result.startsWith("Trans2SetFileInformation["));

  private final TestByteSink byteSink;

  public TestCharSink(TestOption... options) {
    this.byteSink = new TestByteSink(options);
  }

  public String getString() {
    return new String(byteSink.getBytes(), UTF_8);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSink.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {

				if data != nil && *data != nil {
					field.ReflectValueOf(ctx, value).SetString(**data)
				}
			case string:
				field.ReflectValueOf(ctx, value).SetString(data)
			case []byte:
				field.ReflectValueOf(ctx, value).SetString(string(data))
			case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
				field.ReflectValueOf(ctx, value).SetString(utils.ToString(data))
			case float64, float32: