public static Map<String, String> timeUnits() { Map<String, String> units = Maps.newHashMap(); for(TimeUnit unit : TimeUnit.values()) { String human = unit.toString().toLowerCase(Locale.ENGLISH); units.put(unit.toString(), Character.toUpperCase(human.charAt(0)) + human.substring(1)); } return units; }
private String[] getTimeUnits() { ArrayList<String> timeUnits = new ArrayList<String>(); for ( TimeUnit timeUnit : TimeUnit.values() ) { timeUnits.add( timeUnit.toString() ); } return timeUnits.toArray( new String[timeUnits.size()] ); }
/** * Returns the next smallest {@link TimeUnit} (i.e. {@code TimeUnit.DAYS -> TimeUnit.HOURS}). * If the parameter is {@code null} or {@code TimeUnit.NANOSECONDS}, an * {@link IllegalArgumentException} is thrown because there is no valid smaller TimeUnit. * * @param originalUnit the TimeUnit * @return the next smaller TimeUnit */ protected static TimeUnit getSmallerTimeUnit(TimeUnit originalUnit) { if (originalUnit == null || TimeUnit.NANOSECONDS == originalUnit) { throw new IllegalArgumentException("Cannot determine a smaller time unit than '" + originalUnit + "'"); } else { return TimeUnit.values()[originalUnit.ordinal() - 1]; } }
public void testFromArrayAndAppend() { FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values()).append(TimeUnit.SECONDS); }
private static TimeType convertToTimeType(Duration duration) { return Stream.of(java.util.concurrent.TimeUnit.values()) .sorted(comparing(unit -> unit.convert(duration.toNanos(), NANOSECONDS))) .filter(unit -> duration.equals(Duration.of(unit.convert(duration.toNanos(), NANOSECONDS), jucTimeUnitToTemporalUnit(unit)))) .findFirst() .map(unit -> new TimeType() .withValue(BigInteger.valueOf(unit.convert(duration.toNanos(), NANOSECONDS))) .withUnit(convertToXmlTimeUnit(unit)) ).orElseThrow(AssertionError::new); } }
public void testFromArrayAndIteratorRemove() { FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values()); try { Iterables.removeIf(units, Predicates.equalTo(TimeUnit.SECONDS)); fail("Expected an UnsupportedOperationException to be thrown but it wasn't."); } catch (UnsupportedOperationException expected) { } }
public static String duration( long durationMillis, TimeUnit highestGranularity, TimeUnit lowestGranularity ) { StringBuilder builder = new StringBuilder(); TimeUnit[] units = TimeUnit.values(); reverse( units ); boolean use = false; for ( TimeUnit unit : units ) { if ( unit == highestGranularity ) { use = true; } if ( use ) { durationMillis = extractFromDuration( durationMillis, unit, builder ); if ( unit == lowestGranularity ) { break; } } } if ( builder.length() == 0 ) { // The value is too low to extract any meaningful numbers with the given unit brackets. // So we append a zero of the lowest unit. builder.append( '0' ).append( shortName( lowestGranularity ) ); } return builder.toString(); }
private static List<CharSequence> timeUnitValues() { List<CharSequence> result = new ArrayList<CharSequence>(); for (TimeUnit tu : TimeUnit.values()) { result.add(tu.toString()); } return result; }
break; current = TimeUnit.values()[current.ordinal() - 1];
@Test public void stalenessSourceUnits() { long num = 7; for (TimeUnit units : TimeUnit.values()) { TimestampBound bound = TimestampBound.ofExactStaleness(num, units); assertThat(bound.getExactStaleness(TimeUnit.NANOSECONDS)) .named(units.toString()) .isEqualTo(units.toNanos(num)); } }
/** * Tests data serializing {@link TimeUnit}s using {@link DataSerializer#writeObject}. */ @Test public void testTimeUnitObject() throws Exception { DataOutputStream out = getDataOutput(); for (TimeUnit v : TimeUnit.values()) { DataSerializer.writeObject(v, out, false /* no java serialization allowed */); } out.flush(); DataInput in = getDataInput(); for (TimeUnit v : TimeUnit.values()) { assertEquals(v, DataSerializer.readObject(in)); } }
@Test public void testTimeUnit() throws IOException { final EnumSet<TimeUnit> optimizedTimeUnits = EnumSet.range(TimeUnit.NANOSECONDS, TimeUnit.SECONDS); for (TimeUnit v : TimeUnit.values()) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream out = new DataOutputStream(baos); DataSerializer.writeObject(v, out); byte[] bytes = baos.toByteArray(); String type = DataType.getDataType(bytes); // 4? if (optimizedTimeUnits.contains(v)) { assertEquals("for enum " + v, "java.util.concurrent.TimeUnit", type); } else { assertEquals("for enum " + v, "java.lang.Enum:java.util.concurrent.TimeUnit", type); } } }
@Test public void basic() throws Exception { String script = AutoComplete.bash("basicExample", new CommandLine(new BasicExample())); String expected = format(loadTextFromClasspath("/basic.bash"), CommandLine.VERSION, spaced(TimeUnit.values())); assertEquals(expected, script); }
@Test public void nestedSubcommands() throws Exception { CommandLine hierarchy = new CommandLine(new TopLevel()) .addSubcommand("sub1", new Sub1()) .addSubcommand("sub2", new CommandLine(new Sub2()) .addSubcommand("subsub1", new Sub2Child1()) .addSubcommand("subsub2", new Sub2Child2()) ); String script = AutoComplete.bash("picocompletion-demo", hierarchy); String expected = format(loadTextFromClasspath("/picocompletion-demo_completion.bash"), CommandLine.VERSION, spaced(TimeUnit.values())); assertEquals(expected, script); }
timeUnitByteMap.put(TimeUnit.DAYS, (byte)6); for (TimeUnit value : TimeUnit.values()) { assert timeUnitByteMap.containsKey(value) : value;
@Override public String toString() { TimeUnit bestUnit = TimeUnit.NANOSECONDS; for (TimeUnit unit : TimeUnit.values()) { if (picosIn(unit) > picos) { break; } bestUnit = unit; } BigDecimal divisor = ONE_IN_PICOS.get(bestUnit); return new BigDecimal(picos).divide(divisor, ROUNDER) + preferredAbbrev(bestUnit); }
private static Map<TimeUnit, BigDecimal> createUnitToPicosMap() { Map<TimeUnit, BigDecimal> map = Maps.newEnumMap(TimeUnit.class); for (TimeUnit unit : TimeUnit.values()) { map.put(unit, new BigDecimal(picosIn(unit))); } return Collections.unmodifiableMap(map); }
private static List<CharSequence> timeUnitValues() { List<CharSequence> result = new ArrayList<CharSequence>(); for (TimeUnit tu : TimeUnit.values()) { result.add(tu.toString()); } return result; }
private Duration readDuration(ObjectDataInput in) throws IOException { long da = in.readLong(); if (da > -1) { TimeUnit tu = TimeUnit.values()[in.readInt()]; return new Duration(tu, da); } return null; }
@Test public void getEnumId() { MetadataType enumType = typeBuilder.stringType().id(TimeUnit.class.getName()).with(new EnumAnnotation<>(TimeUnit.values())).build(); assertThat(getId(enumType).get(), is(TimeUnit.class.getName())); } }