慕测-软件测试NextDay

QUESTION

package net.mooctest;
public class Date {
    private Day d;
    private Month m;
    private Year y;

    public Date(int pMonth, int pDay, int pYear) {
        y = new Year(pYear);
        m = new Month(pMonth, y);
        d = new Day(pDay, m);
    }

    public void increment() {
        if (!d.increment()) {
            if (!m.increment()) {
                y.increment();
                m.setMonth(1, y);
            }
            d.setDay(1, m);
        }
    }

    public void printDate() {
        System.out.println(m.getMonth() + "/" + d.getDay() + "/" + y.getYear());
    }

    public Day getDay() {
        return d;
    }

    public Month getMonth() {
        return m;
    }

    public Year getYear() {
        return y;
    }

    public boolean equals(Object o) {
        if (o instanceof Date) {
            if (this.y.equals(((Date) o).y) && this.m.equals(((Date) o).m)
                    && this.d.equals(((Date) o).d))
                return true;
        }
        return false;
    }

    public String toString() {
        return (m.getMonth() + "/" + d.getDay() + "/" + y.getYear());
    }
}

package net.mooctest;
public class Month extends CalendarUnit {
    private Year y;
    private int[] sizeIndex = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    public Month(int pMonth, Year y) {
        setMonth(pMonth, y);
    }

    public void setMonth(int pMonth, Year y) {
        setCurrentPos(pMonth);
        this.y = y;
        if (!this.isValid()) {
            throw new IllegalArgumentException("Not a valid month");
        }
    }

    public int getMonth() {
        return currentPos;
    }

    public int getMonthSize() {
        if (y.isLeap())
            sizeIndex[1] = 29;
        else
            sizeIndex[1] = 28;
        return sizeIndex[currentPos - 1];
    }

    public boolean increment() {
        currentPos += 1;
        if (currentPos > 12)
            return false;
        else
            return true;
    }

    public boolean isValid() {
        if (y != null && y.isValid())
            if (this.currentPos >= 1 && this.currentPos <= 12)
                return true;
        return false;

    }

    public boolean equals(Object o) {
        if (o instanceof Month) {
            if (this.currentPos == ((Month) o).currentPos
                    && this.y.equals(((Month) o).y))
                return true;
        }
        return false;
    }
}

package net.mooctest;
public class Year extends CalendarUnit {
    public Year(int pYear) {
        setYear(pYear);
    }

    public void setYear(int pYear) {
        setCurrentPos(pYear);
        if (!this.isValid()) {
            throw new IllegalArgumentException("Not a valid month");
        }
    }

    public int getYear() {
        return currentPos;
    }

    public boolean increment() {
        currentPos = currentPos + 1;
        if (currentPos == 0)
            currentPos = 1;
        return true;
    }

    public boolean isLeap() {
        if (currentPos >= 0
                && (((currentPos % 4 == 0) && (currentPos % 100 != 0)) || (currentPos % 400 == 0)))
            return true;
        else if (currentPos < 0
                && ((((currentPos * -1) % 4 == 1) && ((currentPos * -1) % 100 != 1)) || ((currentPos * -1) % 400 == 1)))
            return true;
        return false;
    }

    protected boolean isValid() {
        if (this.currentPos != 0)
            return true;
        return false;
    }

    public boolean equals(Object o) {
        if (o instanceof Year) {
            if (this.currentPos == ((Year) o).currentPos)
                return true;
        }
        return false;
    }
}

package net.mooctest;
public abstract class CalendarUnit {
    protected int currentPos;

    protected void setCurrentPos(int pCurrentPos) {
        currentPos = pCurrentPos;
    }

    protected int getCurrentPos() {
        return currentPos;
    }

    protected abstract boolean increment();
    protected abstract boolean isValid();
}

package net.mooctest;
public class Nextday {

    public static Date nextDay(Date d) {
        Date dd = new Date(d.getMonth().getCurrentPos(), d.getDay().getCurrentPos(), d.getYear().getCurrentPos());
        dd.increment();
        return dd;
    }

}

ANSWER ()

package net.mooctest;

import static org.junit.Assert.*;
import org.junit.Test;

//我习惯从功能分析，次日函数是干嘛的，是输入今天告诉我明天。
//所以我们需要考虑今天到明天的日期变化。

public class NextdayTest {
     
  @Test

  public void testValid() {
   Nextday n = new Nextday();

   //首先是最简单的只增长date,我们可以随意挑选一个日期，
   //验证次日函数给我们的结果是否和已知的次日日期相同：

   Date currentday=new Date(2,22,2023);
   Date nextday=Nextday.nextDay(currentday);
   Date expectday=new Date(2,23,2023);
   assertEquals(expectday,nextday);
   
   //然后考虑date满了进到月份，相同的方法去验证：

   currentday=new Date(1,31,2023);  
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(2,1,2023);
   assertEquals(expectday,nextday);
   
   //如果说月份也满了，就要加年份
   currentday=new Date(12,31,2022);
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(1,1,2023);
   assertEquals(expectday,nextday);
   
   //这些都是理所应当一定会发生的，非常好想 

   //然后我们需要考虑一些奇奇怪怪的日子
   //首先能想到就是2月的分界点28、29
   //注意我们这里都是先讨论的可以发生的情况，像5201314月10086日这种日子我们先不管他  
  
   
   currentday=new Date(2,28,2020);
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(2,29,2020);
   assertEquals(expectday,nextday);

   
   currentday=new Date(2,27,2023);
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(2,28,2023);
   assertEquals(expectday,nextday);
   
   
   //因为题目中有
   //else if (currentPos < 0 && ((((currentPos * -1) % 4 == 1) && 
   //((currentPos * -1) % 100 != 1)) || ((currentPos * -1) % 400 == 1)))
   //    return true;
   //这样的判断，所以年份可能会是个负数

   currentday=new Date(2,28,-2017);
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(2,29,-2017);
   assertEquals(expectday,nextday);

   currentday=new Date(2,28,-2018);
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(3,1,-2018);
   assertEquals(expectday,nextday)；
  
   //-2017和-2018覆盖了
   //&& ((((currentPos * -1) % 4 == 1) && ((currentPos * -1) % 100 != 1)) ||((currentPos         
   //-1) % 400 == 1)))
   //   return true;
   //这条语句

   currentday=new Date(12,31,-1);
   nextday=Nextday.nextDay(currentday);
   expectday=new Date(1,1,1);
   assertEquals(expectday,nextday); 

   currentday.printDate();
   currentday.toString();
   

   //接下来对day-month-year(12,31,-1)的功能分析

   assertEquals(31,currentday.getDay().getDay());
   assertEquals(12,currentday.getMonth().getMonth());
   assertEquals(-1,currentday.getYear().getYear());
   Year y1=new Year(1111);
   Month m1=new Month(11,y1);
   Day d1=new Day(20,m1);
   
   //这里就是搞一个新日期和刚刚的日期比较年月日是否相等
   //这样get.get和get.equal就覆盖了

   assertEquals(false,currentday.getDay().equals(d1));
   assertEquals(false,currentday.getMonth().equals(m1));
   assertEquals(false,currentday.getYear().equals(y1));
   assertEquals(false,currentday.getYear().equals(m1));
   assertEquals(false,currentday.getMonth().equals(y1));
   assertEquals(false,currentday.getDay().equals(m1));
   assertEquals(false,currentday.equals(y1));

   y1=new Year(-1);
   m1=new Month(12,y1);
   d1=new Day(31,m1);
   
   //false有了，那就要搞一些true的测试

   assertEquals(true,currentday.getDay().equals(d1));
   assertEquals(true,currentday.getMonth().equals(m1));
   assertEquals(true,currentday.getYear().equals(y1));  
   

   //currentday.equal也要覆盖,然后注意false&true

   currentday=new Date(2,22,2023);
   nextday=new Date(2,22,2023);
   assertEquals(true,currentday.equals(nextday));
   nextday=new Date(2,23,2023);
   assertEquals(false,currentday.equals(nextday));
  }
  

  //下面来解决边界溢出的日期
  //日期大于31
  @Test(expected=IllegalArgumentException.class)
      public void testInvalidDay() {
          Year y=new Year(2023);
          Month m=new Month(11,y);
          Day d=new Day(32,m);
  }

  //月份为null
  @Test(expected=IllegalArgumentException.class)
      public void testInvalidMonth1() {
           Day d=new Day(2,null); 
      }

  //月份超过12
  @Test(expected=IllegalArgumentException.class)
      public void testInvalidMonth2() {
           //月份超过12
           Year y=new Year(2023);
           Month m=new Month(13,y);  
  }

  //年份null
  @Test(expected=IllegalArgumentException.class)
      public void testInvalidYear1() {
           Year y=null;
           Month m=new Month(1,y);  
  }

  //年份为0
  @Test(expected=IllegalArgumentException.class)
      public void testInvalidYear2() {
          Year y=new Year(0);   
        }
  }

RESULT