public void testValueOfFunction_equals() {
   new EqualsTester()
       .addEqualityGroup(
           Enums.valueOfFunction(TestEnum.class), Enums.valueOfFunction(TestEnum.class))
       .addEqualityGroup(Enums.valueOfFunction(OtherEnum.class))
       .testEquals();
 }
  @GwtIncompatible("reflection")
  public void testGetField() {
    Field foo = Enums.getField(AnEnum.FOO);
    assertEquals("FOO", foo.getName());
    assertTrue(foo.isAnnotationPresent(ExampleAnnotation.class));

    Field bar = Enums.getField(AnEnum.BAR);
    assertEquals("BAR", bar.getName());
    assertFalse(bar.isAnnotationPresent(ExampleAnnotation.class));
  }
Exemple #3
0
  public IndicatorStyle seenIndicatorStyle() {
    String value =
        preferences.getString("pref_seen_indicator_style", IndicatorStyle.NONE.toString());

    assert value != null;
    return Enums.getIfPresent(IndicatorStyle.class, value).or(IndicatorStyle.NONE);
  }
 public NetworkGroupFilterSupport() {
   super(
       builderFor(NetworkGroup.class)
           .withTagFiltering(NetworkGroupTag.class, "networkGroup")
           .withStringProperty("description", FilterFunctions.DESCRIPTION)
           .withStringProperty("group-id", FilterFunctions.GROUP_ID)
           .withStringProperty("group-name", CloudMetadatas.toDisplayName())
           .withStringSetProperty("ip-permission.cidr", FilterSetFunctions.PERMISSION_CIDR)
           .withStringSetProperty(
               "ip-permission.from-port", FilterSetFunctions.PERMISSION_FROM_PORT)
           .withStringSetProperty(
               "ip-permission.group-name", FilterSetFunctions.PERMISSION_GROUP)
           .withStringSetProperty(
               "ip-permission.protocol", FilterSetFunctions.PERMISSION_PROTOCOL)
           .withStringSetProperty("ip-permission.to-port", FilterSetFunctions.PERMISSION_TO_PORT)
           .withStringSetProperty(
               "ip-permission.user-id", FilterSetFunctions.PERMISSION_ACCOUNT_ID)
           .withStringProperty("owner-id", FilterFunctions.ACCOUNT_ID)
           .withPersistenceAlias("networkRules", "networkRules")
           .withPersistenceFilter("description")
           .withPersistenceFilter("group-id", "groupId")
           .withPersistenceFilter("group-name", "displayName")
           .withPersistenceFilter(
               "ip-permission.from-port", "networkRules.lowPort", PersistenceFilter.Type.Integer)
           .withPersistenceFilter(
               "ip-permission.protocol",
               "networkRules.protocol",
               Enums.valueOfFunction(NetworkRule.Protocol.class))
           .withPersistenceFilter(
               "ip-permission.to-port", "networkRules.highPort", PersistenceFilter.Type.Integer)
           .withPersistenceFilter("owner-id", "ownerAccountNumber"));
 }
  public void testGetIfPresent() {
    assertEquals(Optional.of(TestEnum.CHEETO), Enums.getIfPresent(TestEnum.class, "CHEETO"));
    assertEquals(Optional.of(TestEnum.HONDA), Enums.getIfPresent(TestEnum.class, "HONDA"));
    assertEquals(Optional.of(TestEnum.POODLE), Enums.getIfPresent(TestEnum.class, "POODLE"));

    assertTrue(Enums.getIfPresent(TestEnum.class, "CHEETO").isPresent());
    assertTrue(Enums.getIfPresent(TestEnum.class, "HONDA").isPresent());
    assertTrue(Enums.getIfPresent(TestEnum.class, "POODLE").isPresent());

    assertEquals(TestEnum.CHEETO, Enums.getIfPresent(TestEnum.class, "CHEETO").get());
    assertEquals(TestEnum.HONDA, Enums.getIfPresent(TestEnum.class, "HONDA").get());
    assertEquals(TestEnum.POODLE, Enums.getIfPresent(TestEnum.class, "POODLE").get());
  }
 public void testStringConverter_convertError() {
   Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class);
   try {
     converter.convert("xxx");
     fail();
   } catch (IllegalArgumentException expected) {
   }
 }
 public void testStringConverter_convert() {
   Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class);
   assertEquals(TestEnum.CHEETO, converter.convert("CHEETO"));
   assertEquals(TestEnum.HONDA, converter.convert("HONDA"));
   assertEquals(TestEnum.POODLE, converter.convert("POODLE"));
   assertNull(converter.convert(null));
   assertNull(converter.reverse().convert(null));
 }
 @GwtIncompatible("NullPointerTester")
 public void testStringConverter_nullPointerTester() throws Exception {
   Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class);
   NullPointerTester tester = new NullPointerTester();
   tester.testAllPublicInstanceMethods(converter);
 }
 public void testValueOfFunction_nullWhenNoMatchingConstant() {
   Function<String, TestEnum> function = Enums.valueOfFunction(TestEnum.class);
   assertNull(function.apply("WOMBAT"));
 }
 public void testValueOfFunction_caseSensitive() {
   Function<String, TestEnum> function = Enums.valueOfFunction(TestEnum.class);
   assertNull(function.apply("cHEETO"));
   assertNull(function.apply("Honda"));
   assertNull(function.apply("poodlE"));
 }
 public void testValueOfFunction() {
   Function<String, TestEnum> function = Enums.valueOfFunction(TestEnum.class);
   assertEquals(TestEnum.CHEETO, function.apply("CHEETO"));
   assertEquals(TestEnum.HONDA, function.apply("HONDA"));
   assertEquals(TestEnum.POODLE, function.apply("POODLE"));
 }
 public <A extends Enum<A>> A getEnumValue(final String name, final Class<A> type) {
   return Enums.stringConverter(type).convert(getString(name));
 }
 public void testStringConverter_serialization() {
   SerializableTester.reserializeAndAssert(Enums.stringConverter(TestEnum.class));
 }
Exemple #14
0
 public static CpuFamily fromValue(String v) {
   return Enums.getIfPresent(CpuFamily.class, v).or(UNRECOGNIZED);
 }
 public void testGetIfPresent_caseSensitive() {
   assertFalse(Enums.getIfPresent(TestEnum.class, "cHEETO").isPresent());
   assertFalse(Enums.getIfPresent(TestEnum.class, "Honda").isPresent());
   assertFalse(Enums.getIfPresent(TestEnum.class, "poodlE").isPresent());
 }
 @GwtIncompatible("SerializableTester")
 public void testValueOfFunction_serialization() {
   Function<String, TestEnum> function = Enums.valueOfFunction(TestEnum.class);
   SerializableTester.reserializeAndAssert(function);
 }
 public void testStringConverter_reverse() {
   Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class);
   assertEquals("CHEETO", converter.reverse().convert(TestEnum.CHEETO));
   assertEquals("HONDA", converter.reverse().convert(TestEnum.HONDA));
   assertEquals("POODLE", converter.reverse().convert(TestEnum.POODLE));
 }
 public void testStringConverter_nullConversions() {
   Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class);
   assertNull(converter.convert(null));
   assertNull(converter.reverse().convert(null));
 }
 @GwtIncompatible("Class.getName()")
 public void testStringConverter_toString() {
   assertEquals(
       "Enums.stringConverter(com.google.common.base.EnumsTest$TestEnum.class)",
       Enums.stringConverter(TestEnum.class).toString());
 }
 public void testGetIfPresent_whenNoMatchingConstant() {
   assertEquals(Optional.absent(), Enums.getIfPresent(TestEnum.class, "WOMBAT"));
 }
Exemple #21
0
 static <T extends Enum<T>> Optional<T> getEnumIfPresent(Class<T> enumClass, String value) {
   WeakReference<? extends Enum<?>> ref = Enums.getEnumConstants(enumClass).get(value);
   return ref == null ? Optional.<T>absent() : Optional.of(enumClass.cast(ref.get()));
 }