assertEquals(8, encrypted.length);
        assertNotEquals(new String(plaintext), new String(encrypted));
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "a", "short", "medium length text", "very long text that exceeds typical block sizes" })
    @DisplayName("Should handle various input sizes for hashing")
    void testHashVariousInputSizes(String input) {
        // Given
        byte[] data = input.getBytes();

		gorm.Model
		Name                    string
		FieldAllowCreate        string `gorm:"<-:create"`
		FieldAllowUpdate        string `gorm:"<-:update"`
		FieldAllowSave          string `gorm:"<-"`
		FieldAllowSave2         string `gorm:"<-:create,update"`
		FieldAllowSave3         string `gorm:"->:false;<-:create"`
		FieldReadonly           string `gorm:"->"`
		FieldIgnore             string `gorm:"-"`

        String result = (String) readStringMethod.invoke(response, buffer, 10, 128, false);

        assertEquals(testString, result);
    }

    @Test
    @DisplayName("Test readString with null terminator in middle")
    void testReadStringWithNullTerminator() throws Exception {
        byte[] buffer = new byte[128];
        String testString = "Test";

package org.gradle.test

class GroovyClassWithConstants {
    static final int INT_CONST = 9
    public static final String STRING_CONST = 'some-string'
    static final Object OBJECT_CONST = new GroovyClassWithConstants()
    static final def BIG_DECIMAL_CONST = 1.02

    String ignored = 'ignore'
    final int ignored2 = 1001
    static def ignored3

type Input struct {
	Stack
	includes        []string
	beginningOfLine bool
	ifdefStack      []bool
	macros          map[string]*Macro
	text            string // Text of last token returned by Next.
	peek            bool
	peekToken       ScanToken
	peekText        string
}

// NewInput returns an Input from the given path.
func NewInput(name string) *Input {
	return &Input{

     * @param domain the domain for authentication
     * @param username the username for authentication
     * @param password the password for authentication
     */
    public JAASAuthenticator(String serviceName, String domain, String username, String password) {
        super(null, domain, username, password);
        this.serviceName = serviceName;
    }

    /**
     * Create an authenticator using the given credentials
     *

                        "email": {
                            "title": "Email",
                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },
                        "full_name": {
                            "title": "Full Name",
                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },

  @Test
  fun stringEmpty() {
    val body = body("")
    assertThat(body.string()).isEqualTo("")
  }

  @Test
  fun stringLooksLikeBomButTooShort() {
    val body = body("000048")
    assertThat(body.string()).isEqualTo("\u0000\u0000H")
  }

  @Test
  fun stringDefaultsToUtf8() {
    val body = body("68656c6c6f")
    assertThat(body.string()).isEqualTo("hello")
  }

  @Test
  fun stringExplicitCharset() {

 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook.model

class ExtensionMetaData {
    final String pluginId
    final String extensionId
    final String extensionClass

    ExtensionMetaData(String pluginId, String extensionId, String extensionClass) {
        this.pluginId = pluginId
        this.extensionId = extensionId
        this.extensionClass = extensionClass
    }

        final Method m = ClassUtil.getMethod(getClass(), "testGetProperties");
        final Annotation anno = m.getAnnotation(Hoge.class);
        final Map<String, Object> props = AnnotationUtil.getProperties(anno);
        assertThat((String) props.get("aaa"), is("123"));
        assertThat((String) props.get("bbb"), is("3"));
        assertThat(props.get("ccc"), is(nullValue()));
    }