tests/tests/text/src/android/text/format/cts/DateFormatTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.text.format.cts;


 import android.content.ContentResolver;
 import android.content.Context;
 import android.os.ParcelFileDescriptor;
 import android.provider.Settings;
 import android.test.InstrumentationTestCase;
 import android.text.format.DateFormat;

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.io.FileInputStream;
 import java.io.InputStream;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.Locale;
 import java.util.Scanner;
 import java.util.TimeZone;

 public class DateFormatTest extends InstrumentationTestCase {

     private Context mContext;
     private ContentResolver mContentResolver;

     // Date: 2008-12-18 05:30
     private static final int YEAR_FROM_1900 = 108;
     private static final int YEAR = 2008;
     private static final int MONTH = Calendar.DECEMBER; // java.util.Calendar months are 0-based.
     private static final int DAY = 18;
     private static final int HOUR = 5;
     private static final int MINUTE = 30;

     private boolean mIs24HourFormat;
     private Locale mDefaultLocale;

     @Override
     protected void setUp() throws Exception {
         super.setUp();
         enableAppOps();
         mContext = getInstrumentation().getContext();
         mContentResolver = mContext.getContentResolver();
         mIs24HourFormat = DateFormat.is24HourFormat(mContext);
         mDefaultLocale = Locale.getDefault();
     }

     private void enableAppOps() {
         StringBuilder cmd = new StringBuilder();
         cmd.append("appops set ");
         cmd.append(getInstrumentation().getContext().getPackageName());
         cmd.append(" android:write_settings allow");
         getInstrumentation().getUiAutomation().executeShellCommand(cmd.toString());

         StringBuilder query = new StringBuilder();
         query.append("appops get ");
         query.append(getInstrumentation().getContext().getPackageName());
         query.append(" android:write_settings");
         String queryStr = query.toString();

         String result = "No operations.";
         while (result.contains("No operations")) {
             ParcelFileDescriptor pfd = getInstrumentation().getUiAutomation().executeShellCommand(
                                         queryStr);
             InputStream inputStream = new FileInputStream(pfd.getFileDescriptor());
             result = convertStreamToString(inputStream);
         }
     }

     private String convertStreamToString(InputStream is) {
         try (Scanner scanner = new Scanner(is).useDelimiter("\\A")) {
             return scanner.hasNext() ? scanner.next() : "";
         }
     }

     @Override
     protected void tearDown() throws Exception {
         if (!mIs24HourFormat) {
             Settings.System.putString(mContentResolver, Settings.System.TIME_12_24, "12");
         }
         if (!Locale.getDefault().equals(mDefaultLocale)) {
             Locale.setDefault(mDefaultLocale);
         }

         super.tearDown();
     }


     public void test_is24HourFormat() {
         Settings.System.putString(mContentResolver, Settings.System.TIME_12_24, "24");
         assertTrue(DateFormat.is24HourFormat(mContext));
         Settings.System.putString(mContentResolver, Settings.System.TIME_12_24, "12");
         assertFalse(DateFormat.is24HourFormat(mContext));
     }

     public void test_format_M() {
         Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
         assertEquals("D", DateFormat.format("MMMMM", c));
         assertEquals("December", DateFormat.format("MMMM", c));
         assertEquals("Dec", DateFormat.format("MMM", c));
         assertEquals("12", DateFormat.format("MM", c));
         assertEquals("12", DateFormat.format("M", c));
     }

     public void test_format_L() {
         // TODO: we can't test other locales with this API so we can't test 'L' properly!
         Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
         assertEquals("D", DateFormat.format("LLLLL", c));
         assertEquals("December", DateFormat.format("LLLL", c));
         assertEquals("Dec", DateFormat.format("LLL", c));
         assertEquals("12", DateFormat.format("LL", c));
         assertEquals("12", DateFormat.format("L", c));
     }

     public void test_format_E() {
         Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
         assertEquals("T", DateFormat.format("EEEEE", c));
         assertEquals("Thursday", DateFormat.format("EEEE", c));
         assertEquals("Thu", DateFormat.format("EEE", c));
         assertEquals("Thu", DateFormat.format("EE", c));
         assertEquals("Thu", DateFormat.format("E", c));
     }

     public void test_format_c() {
         // TODO: we can't test other locales with this API, so we can't test 'c' properly!
         Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
         assertEquals("T", DateFormat.format("ccccc", c));
         assertEquals("Thursday", DateFormat.format("cccc", c));
         assertEquals("Thu", DateFormat.format("ccc", c));
         assertEquals("Thu", DateFormat.format("cc", c));
         assertEquals("Thu", DateFormat.format("c", c));
     }

     @SuppressWarnings("deprecation")
     public void testFormatMethods() throws ParseException {
         if (!mDefaultLocale.equals(Locale.US)) {
             Locale.setDefault(Locale.US);
         }

         java.text.DateFormat dateFormat = DateFormat.getDateFormat(mContext);
         assertNotNull(dateFormat);
         Date date = new Date(YEAR_FROM_1900, MONTH, DAY, HOUR, MINUTE);
         String source = dateFormat.format(date);
         Date parseDate = dateFormat.parse(source);
         assertEquals(date.getYear(), parseDate.getYear());
         assertEquals(date.getMonth(), parseDate.getMonth());
         assertEquals(date.getDay(), date.getDay());

         dateFormat = DateFormat.getLongDateFormat(mContext);
         assertNotNull(dateFormat);
         source = dateFormat.format(date);
         assertTrue(source.indexOf("December") >= 0);
         dateFormat = DateFormat.getMediumDateFormat(mContext);
         assertNotNull(dateFormat);
         source = dateFormat.format(date);
         assertTrue(source.indexOf("Dec") >= 0);
         assertTrue(source.indexOf("December") < 0);
         dateFormat = DateFormat.getTimeFormat(mContext);
         source = dateFormat.format(date);
         assertTrue(source.indexOf("5") >= 0);
         assertTrue(source.indexOf("30") >= 0);

         String format = "MM/dd/yy";
         String expectedString = "12/18/08";
         Calendar calendar = new GregorianCalendar(YEAR, MONTH, DAY);
         CharSequence actual = DateFormat.format(format, calendar);
         assertEquals(expectedString, actual.toString());
         Date formatDate = new Date(YEAR_FROM_1900, MONTH, DAY);
         actual = DateFormat.format(format, formatDate);
         assertEquals(expectedString, actual.toString());
         actual = DateFormat.format(format, formatDate.getTime());
         assertEquals(expectedString, actual.toString());
     }

     public void test2038() {
         Calendar calendar = new GregorianCalendar(TimeZone.getTimeZone("GMT+00:00"));

         calendar.setTimeInMillis(((long) Integer.MIN_VALUE + Integer.MIN_VALUE) * 1000L);
         assertEquals("Sun Nov 24 17:31:44 GMT+00:00 1833",
                 DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

         calendar.setTimeInMillis(Integer.MIN_VALUE * 1000L);
         assertEquals("Fri Dec 13 20:45:52 GMT+00:00 1901",
                 DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

         calendar.setTimeInMillis(0L);
         assertEquals("Thu Jan 01 00:00:00 GMT+00:00 1970",
                 DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

         calendar.setTimeInMillis(Integer.MAX_VALUE * 1000L);
         assertEquals("Tue Jan 19 03:14:07 GMT+00:00 2038",
                 DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

         calendar.setTimeInMillis((2L + Integer.MAX_VALUE + Integer.MAX_VALUE) * 1000L);
         assertEquals("Sun Feb 07 06:28:16 GMT+00:00 2106",
                 DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));
     }

     private static void checkFormat(String expected, String pattern, int hour) {
         TimeZone utc = TimeZone.getTimeZone("UTC");

         Calendar c = new GregorianCalendar(utc);
         c.set(2013, Calendar.JANUARY, 1, hour, 00);

         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
         sdf.setTimeZone(utc);

         if (pattern.equals("k") && (hour == 0 || hour == 24)) {
           // http://b/8359981: 'k' has always been broken on Android, and we keep it broken
           // for compatibility. Maybe one day we'll be able to fix this...
           assertEquals("0", DateFormat.format(pattern, c));
         } else {
           assertEquals(expected, DateFormat.format(pattern, c));
         }
         assertEquals(expected, sdf.format(c.getTime()));
     }

     public void test_bug_8359981() {
         checkFormat("24", "k", 00);
         checkFormat( "0", "K", 00);
         checkFormat("12", "h", 00);
         checkFormat( "0", "H", 00);

         checkFormat( "1", "k", 01);
         checkFormat( "1", "K", 01);
         checkFormat( "1", "h", 01);
         checkFormat( "1", "H", 01);

         checkFormat("12", "k", 12);
         checkFormat( "0", "K", 12);
         checkFormat("12", "h", 12);
         checkFormat("12", "H", 12);

         checkFormat("13", "k", 13);
         checkFormat( "1", "K", 13);
         checkFormat( "1", "h", 13);
         checkFormat("13", "H", 13);

         checkFormat("24", "k", 24);
         checkFormat( "0", "K", 24);
         checkFormat("12", "h", 24);
         checkFormat( "0", "H", 24);
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.text.format.cts;


	import android.content.ContentResolver;
	import android.content.Context;
	import android.os.ParcelFileDescriptor;
	import android.provider.Settings;
	import android.test.InstrumentationTestCase;
	import android.text.format.DateFormat;

	import java.text.ParseException;
	import java.text.SimpleDateFormat;
	import java.io.FileInputStream;
	import java.io.InputStream;
	import java.util.Calendar;
	import java.util.Date;
	import java.util.GregorianCalendar;
	import java.util.Locale;
	import java.util.Scanner;
	import java.util.TimeZone;

	public class DateFormatTest extends InstrumentationTestCase {

	private Context mContext;
	private ContentResolver mContentResolver;

	// Date: 2008-12-18 05:30
	private static final int YEAR_FROM_1900 = 108;
	private static final int YEAR = 2008;
	private static final int MONTH = Calendar.DECEMBER; // java.util.Calendar months are 0-based.
	private static final int DAY = 18;
	private static final int HOUR = 5;
	private static final int MINUTE = 30;

	private boolean mIs24HourFormat;
	private Locale mDefaultLocale;

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	enableAppOps();
	mContext = getInstrumentation().getContext();
	mContentResolver = mContext.getContentResolver();
	mIs24HourFormat = DateFormat.is24HourFormat(mContext);
	mDefaultLocale = Locale.getDefault();
	}

	private void enableAppOps() {
	StringBuilder cmd = new StringBuilder();
	cmd.append("appops set ");
	cmd.append(getInstrumentation().getContext().getPackageName());
	cmd.append(" android:write_settings allow");
	getInstrumentation().getUiAutomation().executeShellCommand(cmd.toString());

	StringBuilder query = new StringBuilder();
	query.append("appops get ");
	query.append(getInstrumentation().getContext().getPackageName());
	query.append(" android:write_settings");
	String queryStr = query.toString();

	String result = "No operations.";
	while (result.contains("No operations")) {
	ParcelFileDescriptor pfd = getInstrumentation().getUiAutomation().executeShellCommand(
	queryStr);
	InputStream inputStream = new FileInputStream(pfd.getFileDescriptor());
	result = convertStreamToString(inputStream);
	}
	}

	private String convertStreamToString(InputStream is) {
	try (Scanner scanner = new Scanner(is).useDelimiter("\\A")) {
	return scanner.hasNext() ? scanner.next() : "";
	}
	}

	@Override
	protected void tearDown() throws Exception {
	if (!mIs24HourFormat) {
	Settings.System.putString(mContentResolver, Settings.System.TIME_12_24, "12");
	}
	if (!Locale.getDefault().equals(mDefaultLocale)) {
	Locale.setDefault(mDefaultLocale);
	}

	super.tearDown();
	}


	public void test_is24HourFormat() {
	Settings.System.putString(mContentResolver, Settings.System.TIME_12_24, "24");
	assertTrue(DateFormat.is24HourFormat(mContext));
	Settings.System.putString(mContentResolver, Settings.System.TIME_12_24, "12");
	assertFalse(DateFormat.is24HourFormat(mContext));
	}

	public void test_format_M() {
	Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
	assertEquals("D", DateFormat.format("MMMMM", c));
	assertEquals("December", DateFormat.format("MMMM", c));
	assertEquals("Dec", DateFormat.format("MMM", c));
	assertEquals("12", DateFormat.format("MM", c));
	assertEquals("12", DateFormat.format("M", c));
	}

	public void test_format_L() {
	// TODO: we can't test other locales with this API so we can't test 'L' properly!
	Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
	assertEquals("D", DateFormat.format("LLLLL", c));
	assertEquals("December", DateFormat.format("LLLL", c));
	assertEquals("Dec", DateFormat.format("LLL", c));
	assertEquals("12", DateFormat.format("LL", c));
	assertEquals("12", DateFormat.format("L", c));
	}

	public void test_format_E() {
	Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
	assertEquals("T", DateFormat.format("EEEEE", c));
	assertEquals("Thursday", DateFormat.format("EEEE", c));
	assertEquals("Thu", DateFormat.format("EEE", c));
	assertEquals("Thu", DateFormat.format("EE", c));
	assertEquals("Thu", DateFormat.format("E", c));
	}

	public void test_format_c() {
	// TODO: we can't test other locales with this API, so we can't test 'c' properly!
	Calendar c = new GregorianCalendar(2008, Calendar.DECEMBER, 18);
	assertEquals("T", DateFormat.format("ccccc", c));
	assertEquals("Thursday", DateFormat.format("cccc", c));
	assertEquals("Thu", DateFormat.format("ccc", c));
	assertEquals("Thu", DateFormat.format("cc", c));
	assertEquals("Thu", DateFormat.format("c", c));
	}

	@SuppressWarnings("deprecation")
	public void testFormatMethods() throws ParseException {
	if (!mDefaultLocale.equals(Locale.US)) {
	Locale.setDefault(Locale.US);
	}

	java.text.DateFormat dateFormat = DateFormat.getDateFormat(mContext);
	assertNotNull(dateFormat);
	Date date = new Date(YEAR_FROM_1900, MONTH, DAY, HOUR, MINUTE);
	String source = dateFormat.format(date);
	Date parseDate = dateFormat.parse(source);
	assertEquals(date.getYear(), parseDate.getYear());
	assertEquals(date.getMonth(), parseDate.getMonth());
	assertEquals(date.getDay(), date.getDay());

	dateFormat = DateFormat.getLongDateFormat(mContext);
	assertNotNull(dateFormat);
	source = dateFormat.format(date);
	assertTrue(source.indexOf("December") >= 0);
	dateFormat = DateFormat.getMediumDateFormat(mContext);
	assertNotNull(dateFormat);
	source = dateFormat.format(date);
	assertTrue(source.indexOf("Dec") >= 0);
	assertTrue(source.indexOf("December") < 0);
	dateFormat = DateFormat.getTimeFormat(mContext);
	source = dateFormat.format(date);
	assertTrue(source.indexOf("5") >= 0);
	assertTrue(source.indexOf("30") >= 0);

	String format = "MM/dd/yy";
	String expectedString = "12/18/08";
	Calendar calendar = new GregorianCalendar(YEAR, MONTH, DAY);
	CharSequence actual = DateFormat.format(format, calendar);
	assertEquals(expectedString, actual.toString());
	Date formatDate = new Date(YEAR_FROM_1900, MONTH, DAY);
	actual = DateFormat.format(format, formatDate);
	assertEquals(expectedString, actual.toString());
	actual = DateFormat.format(format, formatDate.getTime());
	assertEquals(expectedString, actual.toString());
	}

	public void test2038() {
	Calendar calendar = new GregorianCalendar(TimeZone.getTimeZone("GMT+00:00"));

	calendar.setTimeInMillis(((long) Integer.MIN_VALUE + Integer.MIN_VALUE) * 1000L);
	assertEquals("Sun Nov 24 17:31:44 GMT+00:00 1833",
	DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

	calendar.setTimeInMillis(Integer.MIN_VALUE * 1000L);
	assertEquals("Fri Dec 13 20:45:52 GMT+00:00 1901",
	DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

	calendar.setTimeInMillis(0L);
	assertEquals("Thu Jan 01 00:00:00 GMT+00:00 1970",
	DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

	calendar.setTimeInMillis(Integer.MAX_VALUE * 1000L);
	assertEquals("Tue Jan 19 03:14:07 GMT+00:00 2038",
	DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));

	calendar.setTimeInMillis((2L + Integer.MAX_VALUE + Integer.MAX_VALUE) * 1000L);
	assertEquals("Sun Feb 07 06:28:16 GMT+00:00 2106",
	DateFormat.format("EEE MMM dd HH:mm:ss zzz yyyy", calendar));
	}

	private static void checkFormat(String expected, String pattern, int hour) {
	TimeZone utc = TimeZone.getTimeZone("UTC");

	Calendar c = new GregorianCalendar(utc);
	c.set(2013, Calendar.JANUARY, 1, hour, 00);

	SimpleDateFormat sdf = new SimpleDateFormat(pattern);
	sdf.setTimeZone(utc);

	if (pattern.equals("k") && (hour == 0 \|\| hour == 24)) {
	// http://b/8359981: 'k' has always been broken on Android, and we keep it broken
	// for compatibility. Maybe one day we'll be able to fix this...
	assertEquals("0", DateFormat.format(pattern, c));
	} else {
	assertEquals(expected, DateFormat.format(pattern, c));
	}
	assertEquals(expected, sdf.format(c.getTime()));
	}

	public void test_bug_8359981() {
	checkFormat("24", "k", 00);
	checkFormat( "0", "K", 00);
	checkFormat("12", "h", 00);
	checkFormat( "0", "H", 00);

	checkFormat( "1", "k", 01);
	checkFormat( "1", "K", 01);
	checkFormat( "1", "h", 01);
	checkFormat( "1", "H", 01);

	checkFormat("12", "k", 12);
	checkFormat( "0", "K", 12);
	checkFormat("12", "h", 12);
	checkFormat("12", "H", 12);

	checkFormat("13", "k", 13);
	checkFormat( "1", "K", 13);
	checkFormat( "1", "h", 13);
	checkFormat("13", "H", 13);

	checkFormat("24", "k", 24);
	checkFormat( "0", "K", 24);
	checkFormat("12", "h", 24);
	checkFormat( "0", "H", 24);
	}
	}