下面列出了怎么用java.util.GregorianCalendar的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* Returns the current time as a byte array, useful for implementing {@link BleServices#currentTime()} for example.
*/
public static byte[] getCurrentTime()
{
final byte[] time = new byte[10];
final byte adjustReason = 0;
GregorianCalendar timestamp = new GregorianCalendar();
short year = (short) timestamp.get( Calendar.YEAR );
final byte[] year_bytes = Utils_Byte.shortToBytes(year);
Utils_Byte.reverseBytes(year_bytes);
System.arraycopy(year_bytes, 0, time, 0, 2);
time[2] = (byte)(timestamp.get( Calendar.MONTH ) + 1);
time[3] = (byte)timestamp.get( Calendar.DAY_OF_MONTH );
time[4] = (byte)timestamp.get( Calendar.HOUR_OF_DAY );
time[5] = (byte)timestamp.get( Calendar.MINUTE );
time[6] = (byte)timestamp.get( Calendar.SECOND );
time[7] = (byte)timestamp.get( Calendar.DAY_OF_WEEK );
time[8] = 0; // 1/256 of a second
time[9] = adjustReason;
return time;
}
protected void setFrom(DataValueDescriptor theValue) throws StandardException {
if (theValue instanceof SQLTime) {
restoreToNull();
SQLTime tvst = (SQLTime) theValue;
encodedTime = tvst.encodedTime;
encodedTimeFraction = tvst.encodedTimeFraction;
}
else
{
GregorianCalendar cal = ClientSharedData.getDefaultCleanCalendar();
setValue(theValue.getTime( cal), cal);
}
}
/**
* Creates a new instance.
*
* @param baseMillis the time zone (<code>null</code> not permitted).
*/
public RelativeDateFormat(long baseMillis) {
super();
this.baseMillis = baseMillis;
this.showZeroDays = false;
this.showZeroHours = true;
this.positivePrefix = "";
this.dayFormatter = NumberFormat.getInstance();
this.daySuffix = "d";
this.hourSuffix = "h";
this.minuteSuffix = "m";
this.secondFormatter = NumberFormat.getNumberInstance();
this.secondFormatter.setMaximumFractionDigits(3);
this.secondFormatter.setMinimumFractionDigits(3);
this.secondSuffix = "s";
// we don't use the calendar or numberFormat fields, but equals(Object)
// is failing without them being non-null
this.calendar = new GregorianCalendar();
this.numberFormat = new DecimalFormat("0");
}
/**
* Some checks for the getFirstMillisecond(TimeZone) method.
*/
@Test
public void testGetFirstMillisecondWithCalendar() {
Year y = new Year(2001);
GregorianCalendar calendar = new GregorianCalendar(Locale.GERMANY);
calendar.setTimeZone(TimeZone.getTimeZone("Europe/Frankfurt"));
assertEquals(978307200000L, y.getFirstMillisecond(calendar));
// try null calendar
boolean pass = false;
try {
y.getFirstMillisecond((Calendar) null);
}
catch (NullPointerException e) {
pass = true;
}
assertTrue(pass);
}
/**
* Some checks for the getFirstMillisecond(TimeZone) method.
*/
@Test
public void testGetFirstMillisecondWithCalendar() {
Millisecond m = new Millisecond(500, 55, 40, 2, 15, 4, 2000);
GregorianCalendar calendar = new GregorianCalendar(Locale.GERMANY);
calendar.setTimeZone(TimeZone.getTimeZone("Europe/Frankfurt"));
assertEquals(955766455500L, m.getFirstMillisecond(calendar));
// try null calendar
boolean pass = false;
try {
m.getFirstMillisecond((Calendar) null);
}
catch (NullPointerException e) {
pass = true;
}
assertTrue(pass);
}
/**
* 判断是否润年.
* @param ddate
* 时间字符串, “yyyy-MM-dd” 格式
* @return boolean<br>
* true: ddate 表示的年份是闰年;
* false: ddate 表示的年份不是闰年;
*/
public static boolean isLeapYear(String ddate) {
/**
* 详细设计: 1.被400整除是闰年, 2不能被400整除,能被100整除不是闰年 3.不能被100整除,能被4整除则是闰年 4.不能被4整除不是闰年
*/
Date d = strToDate(ddate);
GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
gc.setTime(d);
int year = gc.get(Calendar.YEAR);
if ((year % 400) == 0) {
return true;
} else if (year % 100 == 0) {
return false;
} else {
return ((year % 4) == 0);
}
}
private boolean processDate1Digit(java.util.GregorianCalendar _calendar, char[] _month, int _part1 ) {
// convert the month characters to a numeric
int month;
if(realLocale == null)
month = monthConverter.convertMonthToInt(_month);// returns month byte[] as an int index from 0;
else
month = monthConverter.convertMonthToInt(_month, new DateFormatSymbols(realLocale));
if ( month == -1 ) return false;
int defaultYear = _calendar.get( Calendar.YEAR );
// now we need to figure out whether the numerical part represents the year or the day
if (prelimDateCheck(_calendar, month + 1, _part1, defaultYear)){ // month/day
return setCalendar(_calendar, defaultYear, month, _part1);
}else if (prelimDateCheck(_calendar, 1, month + 1, _part1)){ // month/year
return setCalendar(_calendar, _part1, month, 1);
}
return false;
}
@Test
public void setDateTimeTest() {
BluetoothBytesParser parser = new BluetoothBytesParser();
Calendar calendar = Calendar.getInstance();
calendar.setTimeZone(TimeZone.getTimeZone("Europe/Amsterdam"));
long timestamp = 1578310812218L;
calendar.setTimeInMillis(timestamp);
parser.setDateTime(calendar);
parser.setOffset(0);
Date parsedDateTime = parser.getDateTime();
assertEquals(7, parser.getValue().length);
calendar.setTime(parsedDateTime);
assertEquals(2020, calendar.get(GregorianCalendar.YEAR));
assertEquals(1, calendar.get(GregorianCalendar.MONTH) + 1);
assertEquals(6, calendar.get(GregorianCalendar.DAY_OF_MONTH));
assertEquals(12, calendar.get(GregorianCalendar.HOUR_OF_DAY));
assertEquals(40, calendar.get(GregorianCalendar.MINUTE));
assertEquals(12, calendar.get(GregorianCalendar.SECOND));
}
public static double getExcelSerialDayNumber(Date date, Locale locale, TimeZone timeZone)
{
GregorianCalendar calendar = new GregorianCalendar(timeZone,locale);
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH); // starts from 0
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int min = calendar.get(Calendar.MINUTE);
int sec = calendar.get(Calendar.SECOND);
int millis = calendar.get(Calendar.MILLISECOND);
double result = getGregorianToJulianDay(year, month + 1, day) +
(Math.floor(millis + 1000 * (sec + 60 * (min + 60 * hour)) + 0.5) / 86400000.0);
return (result - JULIAN_1900) + 1 + ((result > 2415078.5) ? 1 : 0);
}
public static void main(String[] arg) {
int errors = 0;
DateFormat df = DateFormat.getDateInstance(LONG, FINNISH);
Date jan20 = new GregorianCalendar(2015, JANUARY, 20).getTime();
String str = df.format(jan20).toString();
// Extract the month name (locale data dependent)
String month = str.replaceAll(".+\\s([a-z]+)\\s\\d+$", "$1");
if (!month.equals(JAN_FORMAT)) {
errors++;
System.err.println("wrong format month name: got '" + month
+ "', expected '" + JAN_FORMAT + "'");
}
SimpleDateFormat sdf = new SimpleDateFormat("LLLL", FINNISH); // stand-alone month name
month = sdf.format(jan20);
if (!month.equals(JAN_STANDALONE)) {
errors++;
System.err.println("wrong stand-alone month name: got '" + month
+ "', expected '" + JAN_STANDALONE + "'");
}
if (errors > 0) {
throw new RuntimeException();
}
}
public static void main(String[] arg) {
int errors = 0;
DateFormat df = DateFormat.getDateInstance(LONG, FINNISH);
Date jan20 = new GregorianCalendar(2015, JANUARY, 20).getTime();
String str = df.format(jan20).toString();
// Extract the month name (locale data dependent)
String month = str.replaceAll(".+\\s([a-z]+)\\s\\d+$", "$1");
if (!month.equals(JAN_FORMAT)) {
errors++;
System.err.println("wrong format month name: got '" + month
+ "', expected '" + JAN_FORMAT + "'");
}
SimpleDateFormat sdf = new SimpleDateFormat("LLLL", FINNISH); // stand-alone month name
month = sdf.format(jan20);
if (!month.equals(JAN_STANDALONE)) {
errors++;
System.err.println("wrong stand-alone month name: got '" + month
+ "', expected '" + JAN_STANDALONE + "'");
}
if (errors > 0) {
throw new RuntimeException();
}
}
/**
* In Auckland, the end of Feb 2000 is java.util.Date(951,821,999,999L).
* Use this to check the Month constructor.
*/
public void testDateConstructor2() {
TimeZone zone = TimeZone.getTimeZone("Pacific/Auckland");
Calendar c = new GregorianCalendar(zone);
Month m1 = new Month(new Date(951821999999L), zone,
Locale.getDefault());
Month m2 = new Month(new Date(951822000000L), zone,
Locale.getDefault());
assertEquals(MonthConstants.FEBRUARY, m1.getMonth());
assertEquals(951821999999L, m1.getLastMillisecond(c));
assertEquals(MonthConstants.MARCH, m2.getMonth());
assertEquals(951822000000L, m2.getFirstMillisecond(c));
}
/**
* Creates a new instance.
*
* @param baseMillis the time zone (<code>null</code> not permitted).
*/
public RelativeDateFormat(long baseMillis) {
super();
this.baseMillis = baseMillis;
this.showZeroDays = false;
this.showZeroHours = true;
this.positivePrefix = "";
this.dayFormatter = NumberFormat.getNumberInstance();
this.daySuffix = "d";
this.hourFormatter = NumberFormat.getNumberInstance();
this.hourSuffix = "h";
this.minuteFormatter = NumberFormat.getNumberInstance();
this.minuteSuffix = "m";
this.secondFormatter = NumberFormat.getNumberInstance();
this.secondFormatter.setMaximumFractionDigits(3);
this.secondFormatter.setMinimumFractionDigits(3);
this.secondSuffix = "s";
// we don't use the calendar or numberFormat fields, but equals(Object)
// is failing without them being non-null
this.calendar = new GregorianCalendar();
this.numberFormat = new DecimalFormat("0");
}
public static void main(String[] args) {
Vimshottari v = new Vimshottari(300 + ( 59.00 / 60.00 ), new GregorianCalendar(1980, Calendar.DECEMBER, 11));
//v.getDasa().get(Planet.Rahu).getSubDasas();
//v.getDasa().get(Planet.Venus).getSubDasas().get(Planet.Venus).getSubDasas();
//System.out.println(v);
//System.out.println("Current:-> " + v.getCurrent());
EnumMap<Planet, Dasa> dasa = v.getDasa();
for(Planet p : Planet.dasaLords(v.getStartLord())){
Dasa d = dasa.get(p);
for(Dasa sb : d.subDasas()) {
System.out.println(TableDataFactory.toCSV(v.getVimDasaTableData(sb),getVimDasaTableColumnMetaData()));
System.out.println("**********************************************************");
}
System.out.println("---------------------------------------------------------");
}
//System.out.println(TableDataFactory.toCSV(v.getVimDasaTableData(),getVimDasaTableColumnMetaData()));
//System.out.println(v.printDasaTree());
}
@Test
public void testOverlappingByDayInWeekRegions() {
Date date1 = (new GregorianCalendar(2010, 01, 01)).getTime();
Date date2 = new Date( date1.getTime() + MS_PER_WEEK );
Date date3 = date2;
Date date4 = new Date( date3.getTime() + MS_PER_WEEK );
TemporalFeature t1 = new TemporalFeature();
t1.setValue(date1, date2);
TemporalFeature t2 = new TemporalFeature();
t2.setValue(date3, date4);
TemporalDistance d = new TemporalDistance(1);
double distance = d.distance(t1, t2);
double expected = 1.0 - (2.0 * MS_PER_DAY / (2.0 * MS_PER_WEEK));
assertTrue(isEqual(distance, expected));
distance = d.aveMinDistance(Collections.singletonList(t1), Collections.singletonList(t2));
assertTrue(isEqual(distance, expected));
}
private XMLGregorianCalendar toXMLCal(Calendar cal) {
if (cal == null) {
return null;
}
DatatypeFactory dtf = null;
try {
dtf = DatatypeFactory.newInstance();
} catch (DatatypeConfigurationException e) {
e.printStackTrace();
return null;
}
GregorianCalendar gc = new GregorianCalendar();
gc.setTimeInMillis(cal.getTimeInMillis());
return dtf.newXMLGregorianCalendar(gc);
}
/**
* 月最后一天
* @param date
* @return
*/
public static Date getMonthEndDate(Date date){
GregorianCalendar c = new GregorianCalendar();
c.setTime(date);
int maxMonth = c.getActualMaximum(Calendar.DAY_OF_MONTH);
c.set(Calendar.DAY_OF_MONTH, maxMonth);
c.set(Calendar.HOUR_OF_DAY, 23);
c.set(Calendar.MINUTE, 59);
c.set(Calendar.SECOND, 59);
return c.getTime();
}
public void testFactory_FromCalendarFields() throws Exception {
GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
cal.set(Calendar.MILLISECOND, 7);
TimeOfDay expected = new TimeOfDay(4, 5, 6, 7);
assertEquals(expected, TimeOfDay.fromCalendarFields(cal));
try {
TimeOfDay.fromCalendarFields(null);
fail();
} catch (IllegalArgumentException ex) {}
}
/**
* (non-API) Method initializeColumnHeaders. Called internally when the column
* header text needs to be updated.
*
* @param columns
* A LinkedList of CLabels representing the column objects
*/
protected void refreshColumnHeaders(LinkedList<CLabel> columns) {
Date startDate = getStartDate();
GregorianCalendar gc = new GregorianCalendar();
gc.setTime(startDate);
SimpleDateFormat formatter = new SimpleDateFormat("EE, MMM d");
formatter.applyLocalizedPattern(formatter.toLocalizedPattern());
for (Iterator<CLabel> iter = columns.iterator(); iter.hasNext();) {
CLabel headerLabel = iter.next();
headerLabel.setText(formatter.format(gc.getTime()));
gc.add(Calendar.DATE, 1);
}
}
private Date getRandomTime(Date minTime, Date maxTime) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(minTime == null ? (new GregorianCalendar(1970, 0, 1, 0, 0, 0)).getTime() : minTime);
cal.setTimeInMillis(cal.getTimeInMillis()
+ nextLong(random, (maxTime == null ? (new GregorianCalendar(1970, 0, 1, 23, 59, 59)).getTime() : maxTime).getTime() - cal.getTimeInMillis()));
return cal.getTime();
}
/**
* Before the fix, JDK8 prints: {@code
* <record>
* <date>3913-11-18T17:35:40</date>
* <millis>1384792540403</millis>
* <sequence>0</sequence>
* <level>INFO</level>
* <thread>1</thread>
* <message>test</message>
* </record>
* }
* After the fix, it should print: {@code
* <record>
* <date>2013-11-18T17:35:40</date>
* <millis>1384792696519</millis>
* <sequence>0</sequence>
* <level>INFO</level>
* <thread>1</thread>
* <message>test</message>
* </record>
* }
* @param args the command line arguments
*/
public static void main(String[] args) {
Locale locale = Locale.getDefault();
try {
Locale.setDefault(Locale.ENGLISH);
final GregorianCalendar cal1 = new GregorianCalendar();
final int year1 = cal1.get(Calendar.YEAR);
LogRecord record = new LogRecord(Level.INFO, "test");
XMLFormatter formatter = new XMLFormatter();
final String formatted = formatter.format(record);
System.out.println(formatted);
final GregorianCalendar cal2 = new GregorianCalendar();
final int year2 = cal2.get(Calendar.YEAR);
if (year2 < 1900) {
throw new Error("Invalid system year: " + year2);
}
StringBuilder buf2 = new StringBuilder()
.append("<date>").append(year2).append("-");
if (!formatted.contains(buf2.toString())) {
StringBuilder buf1 = new StringBuilder()
.append("<date>").append(year1).append("-");
if (formatted.contains(buf1)
&& year2 == year1 + 1
&& cal2.get(Calendar.MONTH) == Calendar.JANUARY
&& cal2.get(Calendar.DAY_OF_MONTH) == 1) {
// Oh! The year just switched in the midst of the test...
System.out.println("Happy new year!");
} else {
throw new Error("Expected year " + year2
+ " not found in log:\n" + formatted);
}
}
} finally {
Locale.setDefault(locale);
}
}
@Test
public void testRound2() {
long tsInMS = 1397016731576L;
long tsInHour = DateTimeUtil.roundDown(Calendar.HOUR, tsInMS);
Assert.assertEquals(1397016000000L, tsInHour);
GregorianCalendar cal = new GregorianCalendar();
cal.setTimeInMillis(tsInMS);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
Assert.assertEquals(tsInHour, cal.getTimeInMillis());
}
public static long daysBetween(Calendar start, Calendar end, Locale locale) {
// create copies
GregorianCalendar startDate = new GregorianCalendar(locale);
GregorianCalendar endDate = new GregorianCalendar(locale);
// switch calendars to pure Julian mode for correct day-between
// calculation, from the Java API:
// - To obtain a pure Julian calendar, set the change date to
// Date(Long.MAX_VALUE).
startDate.setGregorianChange(new Date(Long.MAX_VALUE));
endDate.setGregorianChange(new Date(Long.MAX_VALUE));
// set them
startDate.setTime(start.getTime());
endDate.setTime(end.getTime());
// force times to be exactly the same
startDate.set(Calendar.HOUR_OF_DAY, 12);
endDate.set(Calendar.HOUR_OF_DAY, 12);
startDate.set(Calendar.MINUTE, 0);
endDate.set(Calendar.MINUTE, 0);
startDate.set(Calendar.SECOND, 0);
endDate.set(Calendar.SECOND, 0);
startDate.set(Calendar.MILLISECOND, 0);
endDate.set(Calendar.MILLISECOND, 0);
// now we should be able to do a "safe" millisecond/day caluclation to
// get the number of days
long endMilli = endDate.getTimeInMillis();
long startMilli = startDate.getTimeInMillis();
// calculate # of days, finally
long diff = (endMilli - startMilli) / MILLISECONDS_IN_DAY;
return diff;
}
@Test
public void createReferencesEmpty1() {
//test time period too big
GregorianCalendar cal = new GregorianCalendar( 2014 , 10 , 22 , 11 , 30 , 1 );
cal.set( GregorianCalendar.MILLISECOND , 1 );
Instant start = cal.getTime().toInstant();
TimeInterval timeInterval = TimeInterval.between( start , start.plus( Duration.ofMillis( -5 ) ) );
List<Instant> references = TimeScales.createReferences( timeInterval , new TimePeriod( MILLISECOND , 1 ) );
assertThat( references.size() , equalTo(0) );
}
/**
* Gets the last modification time of this {@code ZipEntry}.
*
* @return the last modification time as the number of milliseconds since
* Jan. 1, 1970.
*/
public long getTime() {
if (time != -1) {
GregorianCalendar cal = new GregorianCalendar();
cal.set(Calendar.MILLISECOND, 0);
cal.set(1980 + ((modDate >> 9) & 0x7f), ((modDate >> 5) & 0xf) - 1,
modDate & 0x1f, (time >> 11) & 0x1f, (time >> 5) & 0x3f,
(time & 0x1f) << 1);
return cal.getTime().getTime();
}
return -1;
}
GetPrescriptionForExecutorResultSealed(String rid, Date creationDate, String patientId, boolean feedbackAllowed, boolean feedbackAllowedByPatient, byte[] prescription, String encryptionKeyId, String prescriptionType, String timestampingId, String prescriberId) {
this.rid = rid;
this.creationDate = new GregorianCalendar();
this.creationDate.setTime(creationDate);
this.patientId = Utils.formatId(patientId, 11);
this.feedbackAllowed = feedbackAllowed && feedbackAllowedByPatient;
this.prescription = prescription;
this.encryptionKeyId = encryptionKeyId;
this.prescriptionType = prescriptionType;
this.timestampingId = timestampingId;
this.prescriberId = prescriberId;
}
private void writeTIME() throws IOException
{
if (param.isModificationTimeSet())
{
ChunkStream cs = new ChunkStream("tIME");
Date date = param.getModificationTime();
TimeZone gmt = TimeZone.getTimeZone("GMT");
GregorianCalendar cal = new GregorianCalendar(gmt);
cal.setTime(date);
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH);
int day = cal.get(Calendar.DAY_OF_MONTH);
int hour = cal.get(Calendar.HOUR_OF_DAY);
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
cs.writeShort(year);
cs.writeByte(month + 1);
cs.writeByte(day);
cs.writeByte(hour);
cs.writeByte(minute);
cs.writeByte(second);
cs.writeToStream(dataOutput);
cs.close();
}
}
@Test
public void testKlinesEndpointWithOptions() throws Exception, BinanceApiException {
// picking interval of last 3 days
Long timeEnd = new Date().getTime();
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(new Date());
cal.add(Calendar.DATE, -3);
Long timeStart = cal.getTime().getTime();
Map<String, Long> options = ImmutableMap.of("startTime", timeStart, "endTime", timeEnd);
List<BinanceCandlestick> klines = binanceApi.klines(symbol, BinanceInterval.FIFTEEN_MIN, 50, options);
assertTrue("Klines should return non-empty array of candlesticks", klines.size() > 0);
BinanceCandlestick firstCandlestick = klines.get(0);
log.info(firstCandlestick.toString());
assertNotNull("Candlestick should contain open", firstCandlestick.getOpen());
assertNotNull("Candlestick should contain high", firstCandlestick.getHigh());
assertNotNull("Candlestick should contain low", firstCandlestick.getLow());
assertNotNull("Candlestick should contain close", firstCandlestick.getClose());
assertNotNull("Candlestick should contain openTime", firstCandlestick.getOpenTime());
assertNotNull("Candlestick should contain closeTime", firstCandlestick.getCloseTime());
assertNotNull("Candlestick should contain numberOfTrades", firstCandlestick.getNumberOfTrades());
assertNotNull("Candlestick should contain volume", firstCandlestick.getVolume());
assertNotNull("Candlestick should contain quoteAssetVolume", firstCandlestick.getQuoteAssetVolume());
assertNotNull("Candlestick should contain takerBuyBaseAssetVolume", firstCandlestick.getTakerBuyBaseAssetVolume());
assertNotNull("Candlestick should contain takerBuyQuoteAssetVolume", firstCandlestick.getTakerBuyQuoteAssetVolume());
}
/**
* If {@code exception} is null, gathers all the peers of the datanode that corresponds to the params in the request
* and returns them as a JSON with the field {@link #PEERS_FIELD_NAME} whose value is a JSON array of objects with
* fields {@link #NAME_QUERY_PARAM} and {@link #PORT_QUERY_PARAM}.
* @param result The result of the request. This would be non null when the request executed successfully
* @param exception The exception that was reported on execution of the request
*/
@Override
public void onCompletion(Void result, Exception exception) {
long processingStartTimeMs = SystemTime.getInstance().milliseconds();
metrics.getPeersSecurityPostProcessRequestTimeInMs.update(processingStartTimeMs - operationStartTimeMs);
ReadableStreamChannel channel = null;
try {
if (exception == null) {
DataNodeId dataNodeId = getDataNodeId(restRequest);
LOGGER.trace("Getting peer hosts for {}:{}", dataNodeId.getHostname(), dataNodeId.getPort());
Set<DataNodeId> peerDataNodeIds = new HashSet<>();
List<? extends ReplicaId> replicaIdList = clusterMap.getReplicaIds(dataNodeId);
for (ReplicaId replicaId : replicaIdList) {
List<? extends ReplicaId> peerReplicaIds = replicaId.getPeerReplicaIds();
for (ReplicaId peerReplicaId : peerReplicaIds) {
peerDataNodeIds.add(peerReplicaId.getDataNodeId());
}
}
channel = getResponseBody(peerDataNodeIds);
restResponseChannel.setHeader(RestUtils.Headers.DATE, new GregorianCalendar().getTime());
restResponseChannel.setHeader(RestUtils.Headers.CONTENT_TYPE, RestUtils.JSON_CONTENT_TYPE);
restResponseChannel.setHeader(RestUtils.Headers.CONTENT_LENGTH, channel.getSize());
}
} catch (Exception e) {
exception = e;
} finally {
metrics.getPeersProcessingTimeInMs.update(SystemTime.getInstance().milliseconds() - processingStartTimeMs);
callback.onCompletion(exception == null ? channel : null, exception);
}
}
@Test
public void createReferencesLowerBoundary4() {
GregorianCalendar cal = new GregorianCalendar( 2014 , 10 , 22 , 11 , 30 , 0 );
cal.set( GregorianCalendar.MILLISECOND , 999 );
Instant start = cal.getTime().toInstant();
TimeInterval timeInterval = TimeInterval.between( start , start.plus( Duration.ofMillis( 3 ) ) );
List<Instant> references = TimeScales.createReferences( timeInterval , new TimePeriod( MILLISECOND , 3 ) );
assertThat( references.size() , equalTo(2) );
assertThat( references.get( 0 ) , equalTo( create(2014 , 11 , 22 , 11 , 30 , 0 , 999 ) ) );
assertThat( references.get( 1 ) , equalTo( create(2014 , 11 , 22 , 11 , 30 , 1 , 2 ) ) );
}