table,
          immutableTable);
    }

    final void check() {
      runTester()
          .assertNonNullValues(
              Gender.MALE,
              Integer.valueOf(0),
              0,
              "",
              "",
              ImmutableList.of(),
              ImmutableList.of(),
              ImmutableMap.of(),
              ImmutableMap.of(),

      implements Serializable {
    static final Converter<String, Float> INSTANCE = new FloatConverter();

    @Override
    protected Float doForward(String value) {
      return Float.valueOf(value);
    }

    @Override
    protected String doBackward(Float value) {
      return value.toString();
    }

    @Override
    public String toString() {

                            .map(e -> e.getKey() + " defined on lines "
                                    + e.getValue().stream()
                                            .map(l -> String.valueOf(l.getLineNumber()))
                                            .collect(Collectors.joining(", ")))
                            .collect(Collectors.joining("; ")));
        }

    try {
      UnsignedInts.checkedCast(value);
      fail("Cast to int should have failed: " + value);
    } catch (IllegalArgumentException ex) {
      assertThat(ex).hasMessageThat().contains(String.valueOf(value));
    }
  }

  public void testSaturatedCast() {
    for (long value : UNSIGNED_INTS) {
      assertThat(UnsignedInts.toLong(UnsignedInts.saturatedCast(value))).isEqualTo(value);
    }

			} else {
				db.AddError(err)
			}
		}
	}

	// assign stmt.ReflectValue
	if stmt.Dest != nil {
		stmt.ReflectValue = reflect.ValueOf(stmt.Dest)
		for stmt.ReflectValue.Kind() == reflect.Ptr {
			if stmt.ReflectValue.IsNil() && stmt.ReflectValue.CanAddr() {
				stmt.ReflectValue.Set(reflect.New(stmt.ReflectValue.Type().Elem()))
			}

        for (int i = 0; i < Math.max(firstSegments.length, secondSegments.length); i++) {
            int result = Long.valueOf(i < firstSegments.length ? firstSegments[i] : "0")
                    .compareTo(Long.valueOf(i < secondSegments.length ? secondSegments[i] : "0"));
            if (result != 0) {
                return result;
            }
        }
        return 0;

                    } else {
                        wantedNature = Metadata.Nature.RELEASE;
                    }
                } else {
                    wantedNature = Metadata.Nature.valueOf(natureString.toUpperCase(Locale.ROOT));
                }

                Map<String, ArtifactRepository> versionIndex = getVersions(session, result, request, wantedNature);

    Entry<Integer, String> entry = iterator.next();
    entry.setValue("two"); // changes the iterator's current entry value
    assertEquals("two", map.get(1));
    assertEquals(Integer.valueOf(1), map.inverse().get("two"));
    iterator.remove(); // removes the updated entry
    assertTrue(map.isEmpty());
  }

  public void testInsertionOrder() {
    BiMap<String, Integer> map = HashBiMap.create();

        if (level == null || level.isEmpty()) {
            return DEFAULT_VALIDATION_LEVEL;
        }
        try {
            return ValidationReportLevel.valueOf(level.toUpperCase(Locale.ENGLISH));
        } catch (IllegalArgumentException e) {
            logger.warn(
                    "Invalid value specified for property {}: '{}'. Supported values are (case insensitive): {}",

	switch s := src.(type) {
	case []byte:
		n, _ := strconv.Atoi(string(s))
		*i = Num(n)
	case int64:
		*i = Num(s)
	default:
		return errors.New("Cannot scan NamedInt from " + reflect.ValueOf(src).String())
	}
	return nil
}

type StringsSlice []string

func (l StringsSlice) Value() (driver.Value, error) {
	bytes, err := json.Marshal(l)
	return string(bytes), err
}