content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Mon Mar 18 17:12:03 GMT 2024
   */
  
  package org.apache.commons.lang3.time;
  
  import org.junit.jupiter.api.Test;
  import static org.junit.jupiter.api.Assertions.*;
  import org.junit.jupiter.api.Timeout;
  import java.util.concurrent.TimeUnit;
  import static org.evosuite.runtime.EvoAssertions.*;
  import java.text.ParseException;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.Locale;
  import java.util.NoSuchElementException;
  import java.util.TimeZone;
  import org.apache.commons.lang3.time.DateUtils;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.evosuite.runtime.mock.java.util.MockCalendar;
  import org.evosuite.runtime.mock.java.util.MockDate;
  import org.evosuite.runtime.mock.java.util.MockGregorianCalendar;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class DateUtils_Original_ESTest extends DateUtils_Original_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedCompareToTaking2DatesAnd1ReturningPositive() throws Throwable  {
        MockDate arg0 = new MockDate();
        Date arg1 = DateUtils.ceiling((Date) arg0, 1);
        int truncatedCompareTo = DateUtils.truncatedCompareTo((Date) arg0, arg1, 1);
        assertEquals(1, truncatedCompareTo);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1ReturningCalendarWhereIsLenientIsFalse() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        arg0.setLenient(false);
        Calendar truncate = DateUtils.truncate((Calendar) arg0, 0);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=true,lenient=false,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=1,MONTH=0,WEEK_OF_YEAR=1,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=1,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", truncate.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ReturningCalendarWhereGetMinimalDaysInFirstWeekIsZero() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        arg0.setMinimalDaysInFirstWeek(0);
        Calendar round = DateUtils.round((Calendar) arg0, 14);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=1392409281320,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=0,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=45,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=21,SECOND=21,MILLISECOND=320,ZONE_OFFSET=0,DST_OFFSET=0]", round.toString());
        assertNotSame(round, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ReturningCalendarWhereGetMinimalDaysInFirstWeekIsNegative() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2);
        arg0.setMinimalDaysInFirstWeek((-729));
        Calendar round = DateUtils.round((Calendar) arg0, 13);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=-62099049600000,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=-729,ERA=1,YEAR=2,MONTH=2,WEEK_OF_YEAR=10,WEEK_OF_MONTH=1,DAY_OF_MONTH=2,DAY_OF_YEAR=61,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", round.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ReturningCalendarWhereGetFirstDayOfWeekIsNegative() throws Throwable  {
        Calendar arg0 = MockCalendar.getInstance();
        arg0.setFirstDayOfWeek((-15));
        Calendar round = DateUtils.round(arg0, 0);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=-15,minimalDaysInFirstWeek=1,ERA=1,YEAR=1,MONTH=0,WEEK_OF_YEAR=1,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=1,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", round.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testParseDateStrictlyTaking2Arguments() throws Throwable  {
        String[] arg1 = new String[2];
        arg1[0] = "";
        Date parseDateStrictly = DateUtils.parseDateStrictly("", arg1);
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", parseDateStrictly.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testParseDateTaking3Arguments() throws Throwable  {
        Locale arg1 = Locale.PRC;
        String[] arg2 = new String[6];
        arg2[0] = "<";
        Date parseDate = DateUtils.parseDate("<", arg1, arg2);
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", parseDate.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ReturningZeroAndGetFragmentInSecondsTaking1And10() throws Throwable  {
        MockDate arg0 = new MockDate(1716, 1716, (-1));
        long fragmentInSeconds = DateUtils.getFragmentInSeconds((Date) arg0, 12);
        assertEquals(0L, fragmentInSeconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ReturningPositiveAndGetFragmentInSecondsTaking1And10() throws Throwable  {
        MockDate arg0 = new MockDate(285, 285, 852, 285, 1);
        long fragmentInSeconds = DateUtils.getFragmentInSeconds((Date) arg0, 1);
        assertEquals(3531660L, fragmentInSeconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ReturningZeroAndGetFragmentInSecondsTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInSeconds = DateUtils.getFragmentInSeconds((Calendar) arg0, 13);
        assertEquals(0L, fragmentInSeconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMinutesTaking1And1ReturningZeroAndGetFragmentInMinutesTaking1And10() throws Throwable  {
        MockDate arg0 = new MockDate(883, 883, 883);
        long fragmentInMinutes = DateUtils.getFragmentInMinutes((Date) arg0, 13);
        assertEquals(0L, fragmentInMinutes);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMinutesTaking1And1ReturningZeroAndGetFragmentInMinutesTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInMinutes = DateUtils.getFragmentInMinutes((Calendar) arg0, 14);
        assertEquals(0L, fragmentInMinutes);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMillisecondsTaking1And1ReturningZeroAndGetFragmentInMillisecondsTaking1And10() throws Throwable  {
        MockGregorianCalendar mockGregorianCalendar = new MockGregorianCalendar((-1), 8, (-1), (-1), 217);
        Date arg0 = mockGregorianCalendar.getGregorianChange();
        long fragmentInMilliseconds = DateUtils.getFragmentInMilliseconds(arg0, 14);
        assertEquals(0L, fragmentInMilliseconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMillisecondsTaking1And1ReturningZeroAndGetFragmentInMillisecondsTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2);
        long fragmentInMilliseconds = DateUtils.getFragmentInMilliseconds((Calendar) arg0, 12);
        assertEquals(0L, fragmentInMilliseconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInHoursTaking1And1ReturningPositiveAndGetFragmentInHoursTaking1And10() throws Throwable  {
        String[] arg2 = new String[1];
        arg2[0] = "";
        Date arg0 = DateUtils.parseDateStrictly("", (Locale) null, arg2);
        long fragmentInHours = DateUtils.getFragmentInHours(arg0, 1);
        assertEquals(1076L, fragmentInHours);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInHoursTaking1And1ReturningPositiveAndGetFragmentInHoursTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(6, 5, 1001, 3, (-3603));
        long fragmentInHours = DateUtils.getFragmentInHours((Calendar) arg0, 1);
        assertEquals(1262L, fragmentInHours);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInDaysTaking1And1AndGetFragmentInDaysTaking1And1AndGetFragmentInDaysTaking1And1ReturningPositive() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInDays = DateUtils.getFragmentInDays((Calendar) arg0, 2);
        assertEquals(14L, fragmentInDays);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1ReturningCalendarWhereGetFirstDayOfWeekIsNegative() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2, 2, 2);
        arg0.setFirstDayOfWeek((-3584));
        Calendar ceiling = DateUtils.ceiling((Calendar) arg0, 2);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=-3584,minimalDaysInFirstWeek=1,ERA=1,YEAR=2,MONTH=3,WEEK_OF_YEAR=9,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=60,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", ceiling.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddSeconds() throws Throwable  {
        MockDate arg0 = new MockDate();
        Date addSeconds = DateUtils.addSeconds(arg0, 812);
        assertEquals("Fri Feb 14 20:34:53 GMT 2014", addSeconds.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And10() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        DateUtils.iterator((Calendar) arg0, 3);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=1392409281320,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=45,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=21,SECOND=21,MILLISECOND=320,ZONE_OFFSET=0,DST_OFFSET=0]", arg0.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1WithZero() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.iterator((Calendar) arg0, 0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The range style 0 is not valid.
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        DateUtils.iterator((Calendar) arg0, 1);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=1392409281320,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=45,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=21,SECOND=21,MILLISECOND=320,ZONE_OFFSET=0,DST_OFFSET=0]", arg0.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2Calendars() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        MockGregorianCalendar arg1 = new MockGregorianCalendar(2444, 2444, 2444);
        boolean sameDay = DateUtils.isSameDay((Calendar) arg0, (Calendar) arg1);
        assertFalse(sameDay);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2CalendarsReturningTrue() throws Throwable  {
        MockGregorianCalendar arg1 = new MockGregorianCalendar();
        boolean sameDay = DateUtils.isSameDay((Calendar) arg1, (Calendar) arg1);
        assertTrue(sameDay);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedCompareToTaking2CalendarsAnd1() throws Throwable  {
        MockGregorianCalendar arg1 = new MockGregorianCalendar(2, 2, 2, 2, 2);
        int truncatedCompareTo = DateUtils.truncatedCompareTo((Calendar) arg1, (Calendar) arg1, 2);
        assertEquals(0, truncatedCompareTo);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedCompareToTaking2DatesAnd1ReturningZero() throws Throwable  {
        MockDate arg1 = new MockDate();
        int truncatedCompareTo = DateUtils.truncatedCompareTo((Date) arg1, (Date) arg1, 1);
        assertEquals(0, truncatedCompareTo);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNext() throws Throwable  {
        Locale arg0 = Locale.CHINESE;
        Calendar arg1 = MockCalendar.getInstance(arg0);
        DateUtils.DateIterator dateUtils_DateIterator = new DateUtils.DateIterator(arg1, arg1);
        // Undeclared exception!
        try { 
          dateUtils_DateIterator.next();
          fail("Expecting exception: NoSuchElementException");
        
        } catch(NoSuchElementException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.lang3.time.DateUtils$DateIterator", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedEqualsTaking2DatesAnd1ReturningFalse() throws Throwable  {
        MockDate arg1 = new MockDate(274, 274, 274);
        MockDate arg0 = new MockDate();
        boolean truncatedEquals = DateUtils.truncatedEquals((Date) arg0, (Date) arg1, 5);
        assertFalse(truncatedEquals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedEqualsTaking2CalendarsAnd1ReturningFalse() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        Calendar arg1 = DateUtils.truncate((Calendar) arg0, 2);
        boolean truncatedEquals = DateUtils.truncatedEquals((Calendar) arg0, arg1, 2);
        assertFalse(truncatedEquals);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=1,DAY_OF_YEAR=45,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", arg1.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ThrowsIllegalArgumentException0() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInSeconds((Calendar) arg0, 10);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 10 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ThrowsIllegalArgumentException1() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInSeconds((Calendar) arg0, 9);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 9 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInDaysTaking1And1ThrowsIllegalArgumentException0() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInDays((Calendar) arg0, 8);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 8 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ThrowsIllegalArgumentException2() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInSeconds((Calendar) arg0, 7);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 7 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInHoursTaking1And1ReturningZeroAndGetFragmentInHoursTaking1And10() throws Throwable  {
        MockDate arg0 = new MockDate(2155);
        long fragmentInHours = DateUtils.getFragmentInHours((Date) arg0, 6);
        assertEquals(0L, fragmentInHours);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMinutesTaking1And1ReturningPositiveAndGetFragmentInMinutesTaking1And10() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInMinutes = DateUtils.getFragmentInMinutes((Calendar) arg0, 5);
        assertEquals(1221L, fragmentInMinutes);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInDaysTaking1And1ThrowsIllegalArgumentException1() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInDays((Calendar) arg0, 3);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 3 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1ThrowsClassCastException() throws Throwable  {
        Locale arg0 = Locale.FRANCE;
        // Undeclared exception!
        try { 
          DateUtils.iterator((Object) arg0, 2104533975);
          fail("Expecting exception: ClassCastException");
        
        } catch(ClassCastException e) {
           //
           // Could not iterate based on fr_FR
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1WithNullAndIteratorTaking1And1ThrowsIllegalArgumentException0() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.iterator((Object) null, (-365));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And12() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(4, 4, 4, 4, 4, 4);
        DateUtils.iterator((Calendar) arg0, 4);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=-62030433356000,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=4,MONTH=4,WEEK_OF_YEAR=19,WEEK_OF_MONTH=2,DAY_OF_MONTH=4,DAY_OF_YEAR=125,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=4,HOUR_OF_DAY=4,MINUTE=4,SECOND=4,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", arg0.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And13() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        Iterator<Calendar> iterator = DateUtils.iterator((Calendar) arg0, 4);
        assertNotNull(iterator);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1ThrowsIllegalArgumentExceptionAndIteratorTaking1And10() throws Throwable  {
        Calendar arg0 = MockCalendar.getInstance();
        // Undeclared exception!
        try { 
          DateUtils.iterator((Object) arg0, (-1039));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The range style -1039 is not valid.
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And14() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        DateUtils.iterator((Calendar) arg0, 6);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=1392409281320,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=45,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=21,SECOND=21,MILLISECOND=320,ZONE_OFFSET=0,DST_OFFSET=0]", arg0.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And15() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        Iterator<Calendar> iterator = DateUtils.iterator((Calendar) arg0, 5);
        assertNotNull(iterator);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1AndIteratorTaking1And1AndIteratorTaking1And1ReturningNonNull0() throws Throwable  {
        MockDate arg0 = new MockDate(3, 1, 1);
        Iterator<Calendar> iterator = DateUtils.iterator((Date) arg0, 3);
        assertNotNull(iterator);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And16() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2);
        DateUtils.iterator((Calendar) arg0, 2);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=false,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=?,YEAR=2,MONTH=2,WEEK_OF_YEAR=?,WEEK_OF_MONTH=?,DAY_OF_MONTH=2,DAY_OF_YEAR=?,DAY_OF_WEEK=?,DAY_OF_WEEK_IN_MONTH=?,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=?,ZONE_OFFSET=?,DST_OFFSET=?]", arg0.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1WithNullAndIteratorTaking1And1ThrowsIllegalArgumentException1() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.iterator((Calendar) null, 5);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1ThrowsIllegalArgumentExceptionAndIteratorTaking1And11() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.iterator((Date) null, 1);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1ReturningCalendarWhereGetFirstDayOfWeekIsPositive() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        Calendar ceiling = DateUtils.ceiling((Calendar) arg0, 9);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=1392422400000,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=15,DAY_OF_YEAR=46,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=3,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", ceiling.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1AndCeilingTaking1And1() throws Throwable  {
        MockDate arg0 = new MockDate(2137);
        Date ceiling = DateUtils.ceiling((Date) arg0, 9);
        assertEquals("Thu Jan 01 12:00:00 GMT 1970", ceiling.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And10() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        Date ceiling = DateUtils.ceiling((Object) arg0, 1001);
        assertEquals("Sun Feb 16 00:00:00 GMT 2014", ceiling.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1AndTruncateTaking1And1AndTruncateTaking1And1ReturningNonNull0() throws Throwable  {
        MockDate arg0 = new MockDate();
        Date truncate = DateUtils.truncate((Date) arg0, 12);
        assertEquals("Fri Feb 14 20:21:00 GMT 2014", truncate.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1ThrowsArithmeticException() throws Throwable  {
        MockDate arg0 = new MockDate(280000000, 280000000, 280000000);
        // Undeclared exception!
        try { 
          DateUtils.iterator((Date) arg0, 4);
          fail("Expecting exception: ArithmeticException");
        
        } catch(ArithmeticException e) {
           //
           // Calendar value too large for accurate calculations
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1ThrowsClassCastException() throws Throwable  {
        Object arg0 = new Object();
        // Undeclared exception!
        try { 
          DateUtils.ceiling(arg0, 173);
          fail("Expecting exception: ClassCastException");
        
        } catch(ClassCastException e) {
           //
           // Could not find ceiling of for type: class java.lang.Object
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar((-1108), (-1108), 2155, (-15), (-15));
        Date ceiling = DateUtils.ceiling((Object) arg0, 1001);
        assertEquals("Mon Jul 01 00:00:00 GMT 1196", ceiling.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1WithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.ceiling((Object) null, 2578);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        MockDate arg0 = new MockDate(1747L);
        // Undeclared exception!
        try { 
          DateUtils.ceiling((Object) arg0, 1642);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The field 1642 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1ThrowsIllegalArgumentExceptionAndCeilingTaking1And10() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.ceiling((Calendar) null, 4);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCeilingTaking1And1ThrowsIllegalArgumentExceptionAndCeilingTaking1And11() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.ceiling((Date) null, (-1336));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1ThrowsClassCastException() throws Throwable  {
        Object arg0 = new Object();
        // Undeclared exception!
        try { 
          DateUtils.truncate(arg0, 20);
          fail("Expecting exception: ClassCastException");
        
        } catch(ClassCastException e) {
           //
           // Could not truncate java.lang.Object@7f0b33a4
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1AndTruncateTaking1And1AndTruncateTaking1And1ReturningNonNull1() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        Date truncate = DateUtils.truncate((Object) arg0, 1001);
        assertEquals("Fri Feb 14 00:00:00 GMT 2014", truncate.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1WithNullAndNegative() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.truncate((Object) null, (-2128));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        MockDate arg0 = new MockDate();
        // Undeclared exception!
        try { 
          DateUtils.truncate((Object) arg0, 499);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The field 499 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1ThrowsIllegalArgumentExceptionAndTruncateTaking1And10() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.truncate((Calendar) null, (-4875));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncateTaking1And1ThrowsIllegalArgumentExceptionAndTruncateTaking1And11() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.truncate((Date) null, (-2884));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And10() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2, 2, 2);
        Date round = DateUtils.round((Object) arg0, 1001);
        assertEquals("Thu Mar 02 00:00:00 GMT 2", round.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And11() throws Throwable  {
        MockDate arg0 = new MockDate();
        Date round = DateUtils.round((Object) arg0, 14);
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", round.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ThrowsIllegalArgumentExceptionAndRoundTaking1And1AndRoundTaking1And1WithNull0() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.round((Object) null, (-735));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ThrowsClassCastException() throws Throwable  {
        Locale arg0 = Locale.PRC;
        // Undeclared exception!
        try { 
          DateUtils.round((Object) arg0, 1001);
          fail("Expecting exception: ClassCastException");
        
        } catch(ClassCastException e) {
           //
           // Could not round zh_CN
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ThrowsIllegalArgumentExceptionAndRoundTaking1And1AndRoundTaking1And1WithNull1() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.round((Calendar) null, 1);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ThrowsIllegalArgumentExceptionAndRoundTaking1And1AndRoundTaking1And1WithNull2() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.round((Date) null, (-2609));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1AndRoundTaking1And1() throws Throwable  {
        MockDate arg0 = new MockDate((-119151112946000L));
        Date round = DateUtils.round((Date) arg0, 11);
        assertEquals("Wed Apr 18 05:00:00 GMT 1807", round.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testParseDateStrictlyTaking2ArgumentsThrowsNullPointerException() throws Throwable  {
        String[] arg1 = new String[2];
        arg1[0] = "(}X8ZZ";
        // Undeclared exception!
        try { 
          DateUtils.parseDateStrictly("(}X8ZZ", arg1);
          fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
           //
           // no message in exception (getMessage() returned null)
           //
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testParseDateTaking2ArgumentsThrowsParseException() throws Throwable  {
        String[] arg1 = new String[1];
        arg1[0] = "";
        try { 
          DateUtils.parseDate("Y?I~ZZ", arg1);
          fail("Expecting exception: ParseException");
        
        } catch(ParseException e) {
           //
           // Unable to parse the date: Y?I~ZZ
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testParseDateTaking2ArgumentsThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.parseDate("6+", (String[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Date and Patterns must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTimeAndTruncateTaking1And10() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2);
        Calendar arg1 = DateUtils.truncate((Calendar) arg0, 2);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2,MONTH=2,WEEK_OF_YEAR=9,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=61,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", arg1.toString());
        
        boolean sameLocalTime = DateUtils.isSameLocalTime(arg0, arg1);
        assertFalse(sameLocalTime);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTime0() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar((-201), (-201), (-2420), 1410, 0);
        MockGregorianCalendar arg1 = new MockGregorianCalendar(1410, 13, (-1));
        boolean sameLocalTime = DateUtils.isSameLocalTime(arg0, arg1);
        assertFalse(sameLocalTime);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTimeAndTruncateTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar(2, 2, 2, 2, 2);
        Calendar arg1 = DateUtils.truncate((Calendar) arg0, 2);
        boolean sameLocalTime = DateUtils.isSameLocalTime(arg0, arg1);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=-62099136000000,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2,MONTH=2,WEEK_OF_YEAR=9,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=60,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", arg1.toString());
        assertFalse(sameLocalTime);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTime1() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar((-201), (-2420), (-201), 0, 1410, (-201));
        MockGregorianCalendar arg1 = new MockGregorianCalendar(1410, 13, 11);
        boolean sameLocalTime = DateUtils.isSameLocalTime(arg0, arg1);
        assertFalse(sameLocalTime);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTimeReturningTrue() throws Throwable  {
        MockGregorianCalendar arg1 = new MockGregorianCalendar(2, 2, 2);
        boolean sameLocalTime = DateUtils.isSameLocalTime(arg1, arg1);
        assertTrue(sameLocalTime);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTimeThrowsIllegalArgumentException() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.isSameLocalTime(arg0, (Calendar) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLocalTimeWithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.isSameLocalTime((Calendar) null, (Calendar) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2CalendarsReturningFalse() throws Throwable  {
        Calendar arg0 = MockCalendar.getInstance();
        MockGregorianCalendar arg1 = new MockGregorianCalendar((-31), (-31), (-31));
        boolean sameInstant = DateUtils.isSameInstant(arg0, (Calendar) arg1);
        assertFalse(sameInstant);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2CalendarsThrowsIllegalArgumentException() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.isSameInstant((Calendar) arg0, (Calendar) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2CalendarsReturningTrue() throws Throwable  {
        Calendar arg1 = MockCalendar.getInstance();
        boolean sameInstant = DateUtils.isSameInstant(arg1, arg1);
        assertTrue(sameInstant);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2CalendarsWithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.isSameInstant((Calendar) null, (Calendar) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2DatesReturningTrue() throws Throwable  {
        MockDate arg1 = new MockDate();
        boolean sameInstant = DateUtils.isSameInstant((Date) arg1, (Date) arg1);
        assertTrue(sameInstant);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2DatesThrowsIllegalArgumentException() throws Throwable  {
        MockDate arg0 = new MockDate();
        // Undeclared exception!
        try { 
          DateUtils.isSameInstant((Date) arg0, (Date) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameInstantTaking2DatesWithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.isSameInstant((Date) null, (Date) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRoundTaking1And1ReturningCalendarWhereGetMinimalDaysInFirstWeekIsPositive() throws Throwable  {
        MockGregorianCalendar arg1 = new MockGregorianCalendar(2, 2, (-1));
        Calendar arg0 = DateUtils.round((Calendar) arg1, 2);
        boolean sameDay = DateUtils.isSameDay(arg0, (Calendar) arg1);
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=-62099136000000,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2,MONTH=2,WEEK_OF_YEAR=9,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=60,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=0,ZONE_OFFSET=0,DST_OFFSET=0]", arg0.toString());
        assertFalse(sameDay);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2DatesReturningFalse() throws Throwable  {
        MockDate arg1 = new MockDate(274, 274, 274);
        Date arg0 = DateUtils.ceiling((Date) arg1, 0);
        boolean sameDay = DateUtils.isSameDay(arg0, (Date) arg1);
        assertEquals("Sat Jan 01 00:00:00 GMT 1", arg0.toString());
        assertFalse(sameDay);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2CalendarsThrowsIllegalArgumentException() throws Throwable  {
        Calendar arg0 = MockCalendar.getInstance();
        // Undeclared exception!
        try { 
          DateUtils.isSameDay(arg0, (Calendar) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2CalendarsWithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.isSameDay((Calendar) null, (Calendar) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2DatesThrowsIllegalArgumentException() throws Throwable  {
        MockDate arg0 = new MockDate();
        // Undeclared exception!
        try { 
          DateUtils.isSameDay((Date) arg0, (Date) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2DatesReturningTrue() throws Throwable  {
        MockDate arg1 = new MockDate();
        boolean sameDay = DateUtils.isSameDay((Date) arg1, (Date) arg1);
        assertTrue(sameDay);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameDayTaking2DatesWithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.isSameDay((Date) null, (Date) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetYearsThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.setYears((Date) null, 0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetMilliseconds() throws Throwable  {
        String[] arg2 = new String[1];
        arg2[0] = "";
        Date arg0 = DateUtils.parseDateStrictly("", (Locale) null, arg2);
        Date setMilliseconds = DateUtils.setMilliseconds(arg0, (-835));
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", setMilliseconds.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedEqualsTaking2DatesAnd1ReturningTrue() throws Throwable  {
        MockDate arg1 = new MockDate(274, 274, 274);
        boolean truncatedEquals = DateUtils.truncatedEquals((Date) arg1, (Date) arg1, 5);
        assertTrue(truncatedEquals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMinutesTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInMinutes((Calendar) arg0, 1222);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 1222 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInHoursTaking1And1ReturningZeroAndGetFragmentInHoursTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInHours = DateUtils.getFragmentInHours((Calendar) arg0, 13);
        assertEquals(0L, fragmentInHours);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetSeconds() throws Throwable  {
        MockDate arg0 = new MockDate(883, 883, 883);
        Date setSeconds = DateUtils.setSeconds(arg0, 883);
        assertEquals("Tue Dec 31 00:00:00 GMT 2858", setSeconds.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testTruncatedEqualsTaking2CalendarsAnd1ReturningTrue() throws Throwable  {
        Calendar arg1 = MockCalendar.getInstance();
        boolean truncatedEquals = DateUtils.truncatedEquals(arg1, arg1, 0);
        assertTrue(truncatedEquals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesDateUtilsTakingNoArguments() throws Throwable  {
        DateUtils dateUtils = new DateUtils();
        assertEquals(1, DateUtils.RANGE_WEEK_SUNDAY);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddSecondsThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.addSeconds((Date) null, 4);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDays() throws Throwable  {
        MockGregorianCalendar mockGregorianCalendar = new MockGregorianCalendar(2, 2, 2, 2, 2);
        Date arg0 = mockGregorianCalendar.getGregorianChange();
        Date arg1 = DateUtils.addDays(arg0, 13);
        int truncatedCompareTo = DateUtils.truncatedCompareTo(arg0, arg1, 2);
        assertEquals("Thu Oct 28 00:00:00 GMT 1582", arg1.toString());
        assertEquals((-1), truncatedCompareTo);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDays() throws Throwable  {
        MockDate arg0 = new MockDate(2155);
        Date setDays = DateUtils.setDays(arg0, 2);
        assertEquals("Thu Jan 01 00:00:02 GMT 1970", setDays.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddWeeks() throws Throwable  {
        MockDate arg0 = new MockDate((-119151112946000L));
        Date addWeeks = DateUtils.addWeeks(arg0, 6);
        assertEquals("Wed May 30 04:37:34 GMT 1807", addWeeks.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMinutesTaking1And1ReturningPositiveAndGetFragmentInMinutesTaking1And11() throws Throwable  {
        MockDate arg0 = new MockDate(1, 71, 32, (-1569), 608);
        long fragmentInMinutes = DateUtils.getFragmentInMinutes((Date) arg0, 1);
        assertEquals(432068L, fragmentInMinutes);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddYears() throws Throwable  {
        MockDate arg0 = new MockDate();
        Date addYears = DateUtils.addYears(arg0, 2191);
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", addYears.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddMonths() throws Throwable  {
        MockDate arg0 = new MockDate();
        Date addMonths = DateUtils.addMonths(arg0, 1288);
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", addMonths.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInDaysTaking1And1AndGetFragmentInDaysTaking1And1AndGetFragmentInDaysTaking1And1ReturningZero() throws Throwable  {
        MockDate arg0 = new MockDate();
        long fragmentInDays = DateUtils.getFragmentInDays((Date) arg0, 14);
        assertEquals(0L, fragmentInDays);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInDaysTaking1And1WithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInDays((Calendar) null, 27);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetMinutes() throws Throwable  {
        String[] arg1 = new String[5];
        arg1[0] = "([-+][0-9][0-9]):([0-9][0-9])$";
        Date arg0 = DateUtils.parseDate("([-+][0-9][0-9]):([0-9][0-9])$", arg1);
        Date setMinutes = DateUtils.setMinutes(arg0, (-2766));
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", setMinutes.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMillisecondsTaking1And1ReturningPositiveAndGetFragmentInMillisecondsTaking1And10() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInMilliseconds = DateUtils.getFragmentInMilliseconds((Calendar) arg0, 12);
        assertEquals(21320L, fragmentInMilliseconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ThrowsIllegalArgumentExceptionAndGetFragmentInSecondsTaking1And1() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInSeconds((Date) null, 2013);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The date must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddMinutes() throws Throwable  {
        MockDate arg0 = new MockDate((-119151112946000L));
        Date addMinutes = DateUtils.addMinutes(arg0, (-824));
        assertEquals("Tue Apr 17 14:53:34 GMT 1807", addMinutes.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetMonths() throws Throwable  {
        MockDate arg0 = new MockDate(961, 961, 961, 961, 961, 961);
        Date setMonths = DateUtils.setMonths(arg0, 2510);
        assertEquals("Tue Oct 29 17:17:01 GMT 2943", setMonths.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testParseDateStrictlyTaking2ArgumentsThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try { 
          DateUtils.parseDateStrictly((String) null, (String[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Date and Patterns must not be null
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInMillisecondsTaking1And1ReturningPositiveAndGetFragmentInMillisecondsTaking1And11() throws Throwable  {
        MockDate arg0 = new MockDate((-119151112946000L));
        long fragmentInMilliseconds = DateUtils.getFragmentInMilliseconds((Date) arg0, 2);
        assertEquals(1485454000L, fragmentInMilliseconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInSecondsTaking1And1ReturningPositiveAndGetFragmentInSecondsTaking1And11() throws Throwable  {
        MockGregorianCalendar arg0 = new MockGregorianCalendar();
        long fragmentInSeconds = DateUtils.getFragmentInSeconds((Calendar) arg0, 1);
        assertEquals(3874881L, fragmentInSeconds);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddHours() throws Throwable  {
        MockGregorianCalendar mockGregorianCalendar = new MockGregorianCalendar(2, 2, 2, 2, 2);
        Date arg0 = mockGregorianCalendar.getGregorianChange();
        Date addHours = DateUtils.addHours(arg0, 2);
        assertEquals("Fri Oct 15 02:00:00 GMT 1582", addHours.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetHours() throws Throwable  {
        MockDate arg0 = new MockDate((-62099308800000L));
        Date setHours = DateUtils.setHours(arg0, 11);
        assertEquals("Mon Feb 27 00:00:00 GMT 2", setHours.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFragmentInHoursTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        MockDate arg0 = new MockDate(2143);
        // Undeclared exception!
        try { 
          DateUtils.getFragmentInHours((Date) arg0, 4);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The fragment 4 is not supported
           //
           verifyException("org.apache.commons.lang3.time.DateUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddMilliseconds() throws Throwable  {
        MockDate arg1 = new MockDate();
        Date arg0 = DateUtils.addMilliseconds(arg1, (-22));
        boolean sameInstant = DateUtils.isSameInstant(arg0, (Date) arg1);
        assertFalse(sameInstant);
        assertEquals("Fri Feb 14 20:21:21 GMT 2014", arg0.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemove() throws Throwable  {
        Locale arg0 = Locale.ITALY;
        Calendar arg1 = MockCalendar.getInstance(arg0);
        DateUtils.DateIterator dateUtils_DateIterator = new DateUtils.DateIterator(arg1, arg1);
        // Undeclared exception!
        try { 
          dateUtils_DateIterator.remove();
          fail("Expecting exception: UnsupportedOperationException");
        
        } catch(UnsupportedOperationException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.lang3.time.DateUtils$DateIterator", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHasNext() throws Throwable  {
        TimeZone arg0 = TimeZone.getDefault();
        Calendar arg1 = MockCalendar.getInstance(arg0);
        DateUtils.DateIterator dateUtils_DateIterator = new DateUtils.DateIterator(arg1, arg1);
        dateUtils_DateIterator.hasNext();
        assertEquals("org.evosuite.runtime.mock.java.util.MockGregorianCalendar[time=1392322881320,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=\"GMT\",offset=0,dstSavings=0,useDaylight=false,transitions=0,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=1,WEEK_OF_YEAR=7,WEEK_OF_MONTH=3,DAY_OF_MONTH=13,DAY_OF_YEAR=44,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=21,SECOND=21,MILLISECOND=320,ZONE_OFFSET=0,DST_OFFSET=0]", arg1.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIteratorTaking1And1AndIteratorTaking1And1AndIteratorTaking1And1ReturningNonNull1() throws Throwable  {
        MockDate arg0 = new MockDate(285, 285, 852, 285, 1);
        Iterator<?> iterator = DateUtils.iterator((Object) arg0, 1);
        assertNotNull(iterator);
    }
  }
  