}
        return indexName;
    }

    @Override
    protected <RESULT extends Role> RESULT createEntity(final Map<String, Object> source, final Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setName(DfTypeUtil.toString(source.get("name")));
            result.setAttributes(source.entrySet()
                    .stream()

    }

    private static class SimpleModelProblemCollector implements ModelProblemCollector {

        ModelValidationResult result;

        SimpleModelProblemCollector(ModelValidationResult result) {
            this.result = result;
        }

        @Override
        public void add(ModelProblemCollectorRequest req) {
            if (!ModelProblem.Severity.WARNING.equals(req.getSeverity())) {

        // Arrange: stub to return true regardless of input
        when(handle.hasCapability(anyInt())).thenReturn(true);

        // Act
        boolean result = handle.hasCapability(cap);

        // Assert: verify return and the captured argument equals input
        assertTrue(result);
        ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(Integer.class);
        verify(handle, times(1)).hasCapability(captor.capture());

	}

	var result2 User
	if err := DB.Where("name = ?", "create_from_map_2").First(&result2).Error; err != nil || result2.Age != 19 {
		t.Fatalf("failed to query data after create from slice of map, got error %v", err)
	}

	var result3 User
	if err := DB.Where("name = ?", "create_from_map_3").First(&result3).Error; err != nil || result3.Age != 20 {

        SmbFilenameFilter filter = (dir, n) -> n == null;

        boolean result = filter.accept(mockDir, name);

        if (name == null) {
            assertTrue(result, "Null name should be accepted by this filter");
        } else {
            assertFalse(result, "Non-null names should be rejected by this filter");
        }
        verifyNoInteractions(mockDir);
    }

    /**

            int result = response.readParametersWireFormat(buffer, 0, 2);
            assertEquals(2, result);
        }

        @Test
        @DisplayName("Should write setup wire format")
        void testWriteSetupWireFormat() {
            byte[] buffer = new byte[100];
            int result = response.writeSetupWireFormat(buffer, 0);
            assertEquals(0, result);
        }

        @Test

        try {
            Object result = null;
            if (null != value && !value.isEmpty()) {
                if (evaluator instanceof TypeAwareExpressionEvaluator typeAwareExpressionEvaluator) {
                    result = typeAwareExpressionEvaluator.evaluate(value, type);
                } else {
                    result = evaluator.evaluate(value);
                }
            }

          return false;
        }
        byte result = 0;
        for (int i = 0; i < a.length; i++) {
          result = (byte) (result | a[i] ^ b[i]);
        }
        return result == 0;
      }
    },
    XORING_TO_INT {
      @Override
      boolean doEquals(byte[] a, byte[] b) {
        if (a.length != b.length) {
          return false;
        }
        int result = 0;
        for (int i = 0; i < a.length; i++) {

        SmbFileFilter filter = f -> f.isDirectory();
        when(smbFile.isDirectory()).thenReturn(true);

        // Act
        boolean result = filter.accept(smbFile);

        // Assert
        assertTrue(result, "Directory should be accepted");
        verify(smbFile, times(1)).isDirectory();
        verify(smbFile, never()).getName();
        verifyNoMoreInteractions(smbFile);
    }

            logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

    /**
     * Moves the result set to the next position.
     *
     * @param resultSet
     *            The result set. Must not be {@literal null}.
     * @return Whether the result set successfully moved to the next position.
     */
    public static boolean next(final ResultSet resultSet) {