软件实现技术小组

summergroup2008's profile软件实现技术小组BlogListsNetwork

Tools

Help

Blog

July 20

主要测试用例代码及注释1

#include "Elevator.h"
#include <stdio.h>

const int count=21; //the number of test cases
bool testcases[count]; //record whether every test case is passed or failed

void main()
{
/*********************************************************
basic testing according to some functions
测试电梯运行时的显示和停止时的显示
从1层到10层，又从10层下到1层
**********************************************************/
Elevator elevator;
Elevator *ep=&elevator;

//test case1
cout<<"test1：测试从1层到9层运行中的电梯状态是否正确"<<endl;
elevator.RequireUp(1);
elevator.mysleep(ONESEC*3); //3s开门等待乘客进入
elevator.CloseDoor();
elevator.mysleep(ONESEC); //等待关门
elevator.RequireGetOff(10); //请求上到10层
int num1=0;
for(int i=1;i<=8;i++)
{
  elevator.mysleep(ONESEC*3); //3s上升一层
  cout<<"第"<<i+1<<"层";
  if(elevator.GetElevatorState()==::ES_CLOSED&&elevator.GetElevatorDirection()==::ED_UP&&elevator.GetArrivedFloor()==i+1)
  {
   cout<<"passed";
   num1++;
  }
  else cout<<"failed";
  cout<<endl;
}
if(num1==8) testcases[0]=true;

12:55 AM | Add a comment | Permalink | Blog it

电梯程序模拟部分代码

#include "stdafx.h"
#include "Elevator.h"

//: Construction function
Elevator::Elevator()
{
curDir=::ED_STOP;
curState=::ES_CLOSED;
curFloor=1;
//lastTime=0;
for(int i=0;i<11;i++)
{
up[i]=false;
down[i]=false;
}
trend=0;
tenthNum=0;
thirtiethNum=0;
}

Elevator::~Elevator()
{
cout << "destruct" << endl;
}

ELEVATORDIRECTION Elevator::GetElevatorDirection()
{
return curDir;
}

//电梯的状态，确切的说是门的状态
ELEVATORSTATE Elevator::GetElevatorState()
{
return curState;
}

//: User send requirement to mount the elevator to go up
/*
* @parameter
*  floor: the floor which the user on
*/
void Elevator::RequireUp(int userfloor)
{
//if(userfloor==MAXFLOOR) return;
if(userfloor==curFloor&&curDir==::ED_STOP)
{
  OpenDoor();
  trend=1;
}
else
{
  if(up[userfloor]==false) up[userfloor]=true;
}
if(trend==0)
{
  int internalFloor=userfloor-curFloor;
  if(internalFloor>0) {trend=1;curDir=::ED_UP;}
  else if(internalFloor<0) {trend=-1;curDir=::ED_DOWN;}
}
}

//: User send requirement to mount the elevator to go down
/*
* @parameter
*  floor: the floor which the user on
*/
void Elevator::RequireDown(int userfloor)
{
//if(userfloor==1) return;
if(userfloor==curFloor&&curDir==::ED_STOP)
{
  OpenDoor();
  trend=-1;
}
else
{
  if(down[userfloor]==false) down[userfloor]=true;
}
}

//: User send selection on which floor they will get off
/*
* @parametr
*   floor: the dismount floor
*/
void Elevator::RequireGetOff(int userfloor)
{
if(trend==0)
{
  int internalFloor=userfloor-curFloor;
  if(internalFloor>0) trend=1;
  else if(internalFloor<0) trend=-1;
}
if(trend==1) RequireUp(userfloor);
else if(trend==-1) RequireDown(userfloor);
}

//: Open the door
void Elevator::OpenDoor()
{
if(curDir==::ED_STOP)
{
  if(curState==::ES_CLOSED||curState==::ES_CLOSING)
  {
   curState=::ES_OPENNING;
  }
}
}

//: Close the door
void Elevator::CloseDoor()
{
if(curDir==::ED_STOP)
{
  if(curState==::ES_OPENED||curState==::ES_OPENNING)
  {
   curState=::ES_CLOSING;
  }
}
}

int Elevator::GetArrivedFloor()
{
return curFloor;
}

void Elevator::mysleep(DWORD internalTime)
{
if(curState==::ES_CLOSED)
{
  int num=internalTime/1500;
  int remainder=internalTime%1500;
  for(int i=0;i<num;i++)
  {
   Sleep(ONEHALFSEC);
   if(trend==1)
   {
    curDir=::ED_UP;
    thirtiethNum=thirtiethNum+15;
    if(up[curFloor]==true)
    {
     curDir=::ED_STOP;
     curState=::ES_OPENNING;
     up[curFloor]=false;
     down[curFloor]=false;

     int j;
     for(j=curFloor;j<=MAXFLOOR;j++)
     {
      if(up[j]==true||down[j]==true) break;
     }
     if(j==MAXFLOOR+1)
     {
      for(j=curFloor;j>0;j--)
      {
       if(up[j]==true||down[j]) break;
      }
      if(j==0) trend=0;
      else trend=-1;
     }
    }
    else
    {
     if(i%2==0)
     {
      curFloor++;
      if(thirtiethNum>30) thirtiethNum=15;
     }
    }
   }
   else if(trend==-1)
   {
    curDir=::ED_DOWN;
    thirtiethNum=thirtiethNum-15;
    if(down[curFloor]==true)
    {
     curDir=::ED_STOP;
     curState=::ES_OPENNING;
     up[curFloor]=false;
     down[curFloor]=false;

     int j;
     for(j=curFloor;j>0;j--)
     {
      if(up[j]==true||down[j]==true) break;
     }
     if(j==0)
     {
      for(j=curFloor;j<=MAXFLOOR;j++)
      {
       if(up[j]==true||down[j]==true) break;
      }
      if(j==MAXFLOOR+1) trend=0;
      else trend=1;
     }
    }
    else
    {
     if(i%2==0)
     {
      curFloor--;
      if(thirtiethNum<0) thirtiethNum=15;
     }
    }
   }
  }
  //Sleep(remainder);
  int numS=remainder/100;
  int remainderS=remainder%100;

  for(int k=0;k<numS;k++)
  {
   Sleep(ONESEC/10);
   if(curDir==::ED_UP)
    thirtiethNum++;
   else if(curDir==::ED_DOWN)
    thirtiethNum--;
   else
   {
    if(trend==-1) curDir=::ED_DOWN;
    else if(trend==1) curDir=::ED_UP;
   }
  }
  Sleep(remainderS);
  if(thirtiethNum>=30)
  {
   if((trend==1&&up[curFloor]==true)||(trend==-1&&down[curFloor]==true))
   {
    curDir=::ED_STOP;
    curState=::ES_OPENNING;
    if(up[curFloor]==true)
     up[curFloor]=false;
    if(down[curFloor]==true)
     down[curFloor]=false;
    thirtiethNum=0;
   }
  }
  else if(thirtiethNum<=0)
  {
   if((trend==1&&up[curFloor]==true)||(trend==-1&&down[curFloor]==true))
   {
    curDir=::ED_STOP;
    curState=::ES_OPENNING;
    if(up[curFloor]==true)
     up[curFloor]=false;
    if(down[curFloor]==true)
     down[curFloor]=false;
    thirtiethNum=0;
   }
  }
}
else
{
  int num=internalTime/1000;
  int remainder=internalTime%1000;
  int done=0;
  if(num>0)
  {
   for(int i=0;i<num;i++)
   {
    Sleep(ONESEC);
    if(curState==::ES_OPENNING)
    {
     curState=::ES_OPENED;
     tenthNum=10;
    }
    if(curState==::ES_CLOSING)
    {
     curState=::ES_CLOSED;
     tenthNum=0;
    }
    if(curState==::ES_OPENED)
    {
     if(num-i>=5) done=1;
    }
   }
   if(done==1) curState=::ES_CLOSING;

   int numS=remainder/100;
   int remainderS=remainder%100;

   for(int k=0;k<numS;k++)
   {
    Sleep(ONESEC/10);
    if(curState==::ES_OPENNING)
     tenthNum++;
    if(curState==::ES_CLOSING)
     tenthNum--;
   }
   Sleep(remainderS);
   if(tenthNum>=10)
   {
    curState=::ES_OPENED;
    tenthNum=10;
   }
   if(tenthNum<=0)
   {
    curState=::ES_CLOSED;
    tenthNum=0;
   }
  }
  else if(num==0)
  {
   int numS=internalTime/100;
   int remainderS=internalTime%100;

   for(int k=0;k<numS;k++)
   {
    Sleep(ONESEC/10);
    if(curState==::ES_OPENNING)
     tenthNum++;
    if(curState==::ES_CLOSING)
     tenthNum--;
   }
   Sleep(remainderS);
   if(tenthNum>=10)
   {
    curState=::ES_OPENED;
    tenthNum=10;
   }
   if(tenthNum<=0)
   {
    curState=::ES_CLOSED;
    tenthNum=0;
   }
  }

}

}

12:53 AM | Add a comment | Permalink | Blog it

电梯系统测试部分8

其他测试

用例编号	Test case19
测试优先级	中
测试类型	特殊需求测试
用例设计者	余大江
设计日期	2008-6-30
测试描述	测试电梯停在一层按向上按钮，人2秒后按关门按钮，门是否关闭
涉及需求编号	4、6
输入	1层按下上升键，按下关门键
执行步骤	1、1层按下上升按钮 2、等待2秒 3、按下关门键
期望输出	电梯状态为停止，门的状态为closing，电梯所在楼层为1
实际结果	与期望输出相同
测试日期	2008-7-2
测试结果	Passed

用例编号	Test case20
测试优先级	中
测试类型	特殊需求测试
用例设计者	余大江
设计日期	2008-6-30
测试描述	测试电梯在开门状态中再次按开门键，忽略响应
涉及需求编号	9
输入	1层按下上升键，按下关门键
执行步骤	1、1层按下上升按钮 2、等待0.5秒 3、按下开门键 4、等待0.6秒
期望输出	电梯状态为停止，门的状态为opened，电梯所在楼层为1
实际结果	与期望输出相同
测试日期	2008-7-2
测试结果	Passed

用例编号	Test case21
测试优先级	中
测试类型	特殊需求测试
用例设计者	余大江
设计日期	2008-6-30
测试描述	测试电梯在上升状态中按开门键，忽略响应
涉及需求编号	4
输入	1层按下上升键，按下关门键，按下2层按钮，按下开门按钮
执行步骤	1、1层按下上升按钮 2、等待3秒 3、按下关门键 4、按下2层按钮 5、等待1秒 6、按下开门按钮 7、等待0.5秒
期望输出	电梯状态为上升，门的状态为closed，电梯所在楼层为1
实际结果	与期望输出相同
测试日期	2008-7-2
测试结果	Passed

12:48 AM | Add a comment | Permalink | Blog it

电梯系统测试部分7

用例编号	Test case16
测试优先级	较高
测试类型	状态转换测试
用例设计者	陈旭明
设计日期	2008-6-25
测试描述	在Test case15基础上，测试当请求下到1层的过程中，在3层是否会停（3层有向上的请求）
涉及需求编号	7
输入	按下关门键
执行步骤	1、按下关门键 2、按下1层按钮 3、等待关门 4、等待18秒
期望输出	电梯状态为下降，门的状态为closed，电梯所在楼层为3
实际结果	与期望输出相同
测试日期	2008-7-14
测试结果	Passed

用例编号	Test case17
测试优先级	较高
测试类型	状态转换测试
用例设计者	陈旭明
设计日期	2008-6-25
测试描述	在Test case16基础上，测试1层是否正常停止
涉及需求编号	7
输入	按下关门键
执行步骤	1、按下关门键 2、等待关门 3、等待6秒
期望输出	电梯状态为停止，门的状态为opening，电梯所在楼层为1
实际结果	与期望输出相同
测试日期	2008-7-14
测试结果	Passed

用例编号	Test case18
测试优先级	较高
测试类型	状态转换测试
用例设计者	陈旭明
设计日期	2008-6-26
测试描述	在Test case17基础上，测试3层请求是否相应
涉及需求编号	7
输入	按下关门键
执行步骤	1、按下关门键 2、等待关门 3、等待6秒
期望输出	电梯状态为停止，门的状态为opening，电梯所在楼层为1
实际结果	与期望输出相同
测试日期	2007-7-14
测试结果	Passed

12:47 AM | Add a comment | Permalink | Blog it

电梯系统测试部分6

用例编号	Test case13
测试优先级	较高
测试类型	状态转换测试
用例设计者	陈旭明
设计日期	2008-6-26
测试描述	测试多个请求的处理功能,在2层同时有到达10层和5层的请求
涉及需求编号	7
输入	按下10层和5层按钮，按下10层和5层按钮
执行步骤	1、按下10层和5层按钮 2、按下关门键 3、等待关门 4、等待9秒
期望输出	电梯状态为停止，门的状态为opening，电梯所在楼层为5
实际结果	与期望输出相同
测试日期	2008-7-14
测试结果	Passed

用例编号	Test case14
测试优先级	较高
测试类型	状态转换测试
用例设计者	陈旭明
设计日期	2008-6-25
测试描述	测试在从5层上升到10层的过程中有来自3层向上和9层向下的请求
涉及需求编号	7
输入	无
执行步骤	1按下关门键 2、等待关门 3、等待9.5秒 4、3层外按向上的按钮 5、9层外按向下的按钮 6、等待8.5秒
期望输出	电梯状态为停止，门的状态为opening，电梯所在楼层为10
实际结果	与期望输出相同
测试日期	2008-7-14
测试结果	Passed

用例编号	Test case15
测试优先级	较高
测试类型	状态转换测试
用例设计者	陈旭明
设计日期	2008-6-26
测试描述	在Test case14基础上，测试9层的请求是否响应
涉及需求编号	7
输入	按下关门键
执行步骤	1、按下关门键 2、等待关门 3、等待3秒
期望输出	电梯状态为停止，门的状态为opening，电梯所在楼层为9
实际结果	与期望输出相同
测试日期	2008-7-14
测试结果	Passed