1.  阅读下列说明和图，回答下面问题。
    [说明]
    本流程图描述了某子程序的处理流程，现要求用白盒测试法对其进行测试。
   
    [问题]
    根据判定覆盖、条件覆盖、判定/条件覆盖、多重条件覆盖(条件组合覆盖)、路径覆盖5种覆盖标准，从供选择的答案中分别找出满足相应覆盖标准的最小的测试数据组(用①～⑩回答)。供选择的答案：
       

1.  阅读下列函数说明、图和C代码，填入______处的字句。
    [说明]
    当一元多项式中有许多系数为零时，可用一个单链表来存储，每个节点存储一个非零项的指数和对应系数。
    为了便于进行运算，用带头节点的单链表存储，头节点中存储多项式中的非零项数，且各节点按指数递减顺序存储。例如：多项式8x⁵-2x²+7的存储结构为：
   
    函数中使用的预定义符号如下：
    #define EPSI le-6
    struct Node {    /*多项式中的一项*/
    double c;    /*系数*/
    int e;    /*指数*/
    struct Node *next;
    };
    typedef struct {    /*多项式头节点*/
    int n;    /*多项式不为零的项数*/
    struct Node *head;
    } POLY;
    [函数]
    void Del (POLY *C, struct Node *P)
    /*若P是空指针则删除头节点，否则删除p节点的后继*/
    {
    struct Node *t;
    /*C是空指针或C没有节点*/
    if (C==NULL || C-＞head==NULL) return;
    if(______) {/*删除头节点*/
    t=C-＞head;
    C-＞head=t-＞next;
    return;
    }/*if*/
    t=P-＞next;
    P-＞next=t-＞next;
    };/*Del*/
    void Insert (POLY *C, struct Node *pC)
    /*将pC节点按指数降序插入到多项式C中*/
    /*若C中存在pC对应的指数项，则将系数相加：若其结果为零，则删除该节点*/
    {
    struct Node *t, *tp;
    /*pC为空指针或其系数近似为零*/
    if (pC==NULL || fabs (pC-＞c) ＜EPSI) return;
    if(C-＞head==NULL) {/*若C为空，作为头节点插入*/
    C-＞head=pC;
    pC-＞next=NULL;
    C-＞n++;
    return;
    }/*if*/
    /*若pC的指数比头节点的还大，插入到头节点之前*/
    if (pC-＞e＞C-＞head-＞e) {
    ______；
    C-＞head=pC;
    C-＞n++;
    return;
    }/*if*/
    ______;
    t=C-＞head;
    while (t!=NULL) {
    if (t-＞e＞pC-＞e) {
    tp=t;
    t=t-＞next;
    }
    else if(t-＞e==pC-＞e) {/*C中已经存在该幂次项*/
    t-＞c+=pC-＞c; /*系数相加*/
    if(fabs(t-＞c) ＜EPSI) {/*系数之和为零*/
    ______; /*删除对应节点*/
    C-＞n--;
    ______;
    }
    else t=NULL; /*C中已经不存在该幂次项*/
    } /*while*/
    if (t==NULL) {/*适当位置插入*/
    pC-＞next=tp-＞next;
    tp-＞next=pC;
    C-＞n++;
    } /*if*/
    }; /*Insert*/

1.  阅读下列函数说明和C++代码，填入______处的字句。
    [说明]
    对多个元素的聚合进行遍历访问时，需要依次推移元素，例如对数组通过递增下标的方式，数组下标功能抽象化、一般化的结果就称为迭代器(Iterator)。模式以下程序模拟将书籍(Book)放到书架(BookShelf)上并依次输出书名。这样就要涉及遍历整个书架的过程。使用迭代器Iterator实现。下图中显示了各个类间的关系。以下是C++语言实现，能够正确编译通过。
   
    [C++代码]
    template＜class ______＞
    class Iterator {
    public:
    virtual bool hasNext( )=0;
    ______ Object* next( )=0;
    };
    class Book {
    //省略具体方法和属性
    };
    class BookShelf {
    private:
    vector＜Book＞books;
    public:
    BookShelf( ) {
    }
    Book* getBookAt(int index) {
    return &books [index];
    }
    int getLength( ) {
    return books.size( );
    }
    };
    template＜class Object＞
    class BookShelfIterator: public ______ {
    private:
    BookShelf *bookShelf;
    int index;
    public:
    BookShelflterator(BookShelf *bookShelf) {
    this-＞bookShelf=bookShelf;
    index=0;
    }
    bool hasNext( ) {//判断是否还有下一个元素
    if(index ＜bookShelf-＞getLength( )) {
    return true;
    } else {
    return false;
    }
    }
    Objeot* next( ) {//取得下一个元素
    return bookShelf-＞getBookAt(index++);
    }
    };
    int main( )
    {
    BookShelf bookShelf;
    //将书籍上架，省略代码
    Book *book;
    Iterator＜Book＞ *it=new BookShelfIterator＜Book＞(______);
    while(______) {//遍历书架，输出书名
    book=(Book*)it-＞next( );
    /*访问元素*/
    }
    return 0;
    }

2.  阅读以下说明和Java代码，填入______处的字句。
    [说明]
    对多个元素的聚合进行遍历访问时，需要依次推移元素，例如对数组通过递增下标的方式，数组下标功能抽象化、一般化的结果就称为迭代器(Iterator)。模式以下程序模拟将书籍(Book)放到书架(BookShelf)上并依次输出书名。这样就要涉及遍历整个书架的过程。使用迭代器Iterator实现。下图中显示了各个类间的关系。以下是JAVA语言实现，能够正确编译通过。
   
    [Java代码]
    //Iterator.java文件
    public interface Iterator {
    public abstract boolean hasNext( );
    public abstract Object next( );
    }
    //Aggregate.java文件
    public interface Aggregate {
    public abstract Iterator iterator( );
    }
    //Book.Java
    public class Book {
    //省略具体方法和属性
    }
    //BookshelfIterator.java文件
    public class BookShelfIterator ______ Iterator {
    private BookShelf bookShelf;
    private int index;
    public BookShelfIterator (BookShelf bookShelf) {
    this.bookShelf=bookShelf;
    this.index=0;
    }
    public boolean hasNext( ) {//判断是否还有下一个元素
    if(index ＜bookShelf.getLength( )) {
    return true;
    } else {
    return false;
    }
    }
    public Object next( ) {//取得下一个元素
    Book book=bookShelf.getBookAt (index);
    index++;
    return book;
    }
    }
    //BookShelf.java
    import java.util.Vector;
    public class BookShelf {
    private Vector books;
    public BookShelf(int initialsize) {
    this.books=new Vector(initialsize);
    }
    public Book getBookAt (int index) {
    return (Book)books.get(index);
    }
    public int getLength( ) {
    return books.size( );
    }
    public Iterator iterator( ) {
    return new BookShelfIterator(______);
    }
    //Main.java文件
    public class Main {
    public static void main (String[ ]args) {
    BookShelf bookShelf=new BookShelf ______;
    //将书籍上架，省略代码
    Iterator it=bookShelf.______;
    while(______) {//遍历书架，输出书名
    Book book=(Book)it.______;
    System.out.println(""+book.getName( ));
    }
    }
    }

3.  阅读以下函数说明和C代码，填入______处的字句。
    [说明]
    对多个元素的聚合进行遍历访问时，需要依次推移元素，例如对数组通过递增下标的方式，数组下标功能抽象化、一般化的结果就称为迭代器(Iterator)。模式以下程序模拟将书籍(Book)放到书架(BookShelf)上并依次输出书名。这样就要涉及遍历整个书架的过程。使用迭代器Iterator实现。下图中显示了各个类间的关系。以下是JAvA语言实现，能够正确编译通过。
   
    [C代码]
    typedef bool (*funl) ( );
    typedef ______ (*fun2) ( );
    const int BOOK MAX=10;//最大书本数
    Struct Book {
    char name[30];
    };
    struct BookShelf {//书架
    struct Book books[BOOK_MAX];
    int index;//书架上最后一本书的下标加1，即下一本书的下标，如0表示有0本书
    };
    Struct Book* getBookAt (Struct BookShelf *BS, int index)
    //从书架BS上取得下标为index的书
    //只有当下标大于等于0且不大于当前书架上的最后一本书对应的下标，才取书成功：
    //否则失败，返回NULL
    {
    if (index ＞=0 ＆＆ ______) {
    return &BS-＞books[index];
    }
    return NULL;
    }
    bool appendBook (struct BookShelf *BS, Struct Book book)
    {
    if (BS-＞index ＜BOOK MAX) {
    BS-＞books[BS-＞index++]=book;
    return true;
    }
    return false;
    }
    int getLength (struct BookShelf *bookShelf)
    {
    return bookShelf-＞index;
    }
    struct Iterator {//迭代器
    funl hasNext;//判断是否还有下一个元素
    fun2 next;//取得下一个元素
    };
    struct BookShelfIterator {//书架迭代器
    int index;
    struct BookShelf* bookShelf;
    }bookShelfIterator={0, NULL};
    bool BShasNext( )//判断是否还有下一本书
    {
    if(bookShelfIterator.index
    ＜getLength(bookShelfIterator.bookShelf)) {
    return true;
    } else {
    return false;
    }
    }
    struct Book* BSnext( )//取得下一本书，并将index加1，以便下一次正确访问
    {
    return getBookAt (bookShelfIterator.bookShelf,
    ______ );
    }
    void main( )
    {
    Struct BookShelf bookShelf;
    bookShelf.index=0;
    //将书籍上架，省略代码
    //将bookShelf与bookshelfIterator相关联
    bookShelfIterator.bookShelf= ______;
    struct Iterator iterator;
    iterator.hasNext=BShasNext;
    iterator.next=BSnext;
    struct Book*b;
    while(______) {//遍历书架，输出书名
    b=iterator.next( );
    printf("%s\n", b-＞name);
    }
    }