/**
     * Creates a new CreateForm instance.
     */
    public CreateForm() {
    }

    /**
     * The CRUD operation mode (create, update, etc.).
     */
    @ValidateTypeFailure
    public Integer crudMode;

    /**
     * The regular expression pattern to match request paths.
     */
    @Required
    @Size(max = 1000)
    public String regex;

    /**

                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

obtendrás una versión en texto, con:

```
1 validation error
path -> item_id
  value is not a valid integer (type=type_error.integer)
```

#### `RequestValidationError` vs `ValidationError`

/// warning | Advertencia

                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

você receberá a versão em texto:

```
1 validation error
path -> item_id
  value is not a valid integer (type=type_error.integer)
```

### `RequestValidationError` vs `ValidationError`

/// warning | Aviso

        registerModifiedProperty("regularName");
        this.regularName = value;
    }

    public Integer getSortOrder() {
        checkSpecifiedProperty("sortOrder");
        return sortOrder;
    }

    public void setSortOrder(Integer value) {
        registerModifiedProperty("sortOrder");
        this.sortOrder = value;
    }

    public String getUpdatedBy() {

  }

  public void testOrdering() throws Exception {
    AtomicInteger integer = new AtomicInteger();
    for (int i = 0; i < 10; i++) {
      int expectedCount = i;
      list.add(
          new Runnable() {
            @Override
            public void run() {
              integer.compareAndSet(expectedCount, expectedCount + 1);
            }
          },
          directExecutor());

  /** Tests the initial state of the future. */
  public void testCreate() throws Exception {
    SettableFuture<Integer> future = SettableFuture.create();
    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void testSetValue_simpleThreaded() throws Exception {
    SettableFuture<Integer> future = SettableFuture.create();
    assertTrue(future.set(42));

public class SingletonImmutableMapMapInterfaceTest
    extends AbstractImmutableMapMapInterfaceTest<String, Integer> {
  @Override
  protected Map<String, Integer> makePopulatedMap() {
    return ImmutableMap.of("one", 1);
  }

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

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }

    taskDone = false;
    Callable<Integer> task =
        new Callable<Integer>() {
          @Override
          public Integer call() {
            taskDone = true;
            return 6;
          }
        };
    Future<Integer> future =
        TestingExecutors.sameThreadScheduledExecutor().schedule(task, 10000, MILLISECONDS);

      };

  @Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    Table<String, Integer, String> table = HashBasedTable.create();
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      String value = (data[i + 2] == null) ? null : (data[i + 2] + "transformed");
      table.put((String) data[i], (Integer) data[i + 1], value);
    }

    extends MapInterfaceTest<String, Collection<Integer>> {

  public AbstractMultimapAsMapImplementsMapTest(
      boolean modifiable, boolean allowsNulls, boolean supportsIteratorRemove) {
    super(allowsNulls, allowsNulls, false, modifiable, modifiable, supportsIteratorRemove);
  }

  protected void populate(Multimap<String, Integer> multimap) {
    multimap.put("one", 1);
    multimap.put("two", 2);