测试--自动化工具篇--【Robotium】

【概论】

Robotium是一款国外的Android自动化测试框架，主要针对Android平台的应用进行黑盒自动化测试，它提供了模拟各种手势操作（点击、长按、滑动等）、查找和断言机制的API，能够对各种控件进行操作。Robotium结合Android官方提供的测试框架达到对应用程序进行自动化的测试。另外，Robotium 4.0版本已经支持对WebView的操作。Robotium 对Activity，Dialog，Toast，Menu 都是支持的。

另：

robotium框架，使用的类也是Instrumentation，而它由Java5（2004-10）推出，这是一个可以在main之前Java虚拟机加载类时改变Java类字节码或类classpath等内容的工具，同时JDK1.6还提供了运行过程中的动态改变，如在方法执行前后加入度量时间的代码，使Java代码可度量就是一个很典型的应用。不过这需要涉及到Java字节码有较深入的理解进行字节码直接编辑改写，或者需要借助开源字节码项目如bcel，ASM或javassist等，以简化对字节码的操作。

Android的Instrumentation对某个监控程序进行交互时，其大致采用如下步骤：  

1）启动时将项目配置文件AndroidManifest.xml文件中的instrumentation标签中的内容进行初始化，其中标明了所使用的测试运行类，目标项目的包名等  

2）执行测试时（可用adb命令触发），将启动目标应用的Activity，同时将待测试ActivityThread作为一个引用进行初始化，如果找不到目标应用则会报错  

3）在测试时测试项目的任何对目标项目进行的操作，都会用异步的方式，将消息体放在目标程序的MessageQueue里面，这样目标程序在看到自己的MessageQueue里有内容时，就会执行之。  

整个初始化过程还有待研究，关键应该是在于AndroidManifest.xml文件中内容的标识。

——————————————————————————————————————————

【基础理论】

当我们写完一个robotium自动化的脚本后，需要注意几点。

　　1.安卓软件基本有两层组成，第一层是基于java的应用层，第二层是基于linux的底层操作系统。

　　2.我们通过robotium写的自动化脚本是执行在java应用层上，也就是说我们获取的所有东东都是在布局上面取到的。

这里我们大概可以这么理解，其实我们制作了2个apk的软件应用程序，通过1个测试代码产生的apk来自动测试我们的被测程序apk，即同时通过测试的工程项目来与运行时的项目交互，触发其组件的动作等来进行操作测试。

　

——————————————————————————————————————————

【应用实例】

包名为：com.sinogain.test; java文件为：loginTax.java

//以下是为测试com.sinogain的实现
package com.sinogain.test;


import junit.framework.Test;
import junit.framework.TestResult;
import junit.framework.TestSuite;
import android.app.Activity;
import android.test.ActivityInstrumentationTestCase2;

import com.jayway.android.robotium.solo.Solo;
public class loginTax extends ActivityInstrumentationTestCase2 {
    private static Solo solo;
    public Activity activity;
    private static Class<?> launchActivityClass;

    // 对应re-sign.jar生成出来的信息框里的两个值
    private static String mainActiviy = "com.sinogain.Splash";
    private static String packageName = "com.sinogain";

    private static String SrcEnterDataFile ="D:/AtuoTestFile/文档/测试数据.xls";
    static {
        try {
            launchActivityClass = Class.forName(mainActiviy);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
    
    
    public loginTax(String packageName) {
        super(packageName, launchActivityClass);
    }

    protected void setUp() throws Exception {
        super.setUp();
        this.activity = this.getActivity();
        this.solo = new Solo(getInstrumentation(), getActivity());
        //solo.getCurrentActivity();
    }

    //登陆
    public void testLogin() throws Exception {
        //创建存储信息文件
        Txtoperate.creatTxtFile();
        
        //判定是否到登陆页面
        if(solo.waitForText("登陆", 1, 10000)){
            // 输入登陆信息        
            solo.clearEditText(0);
            solo.enterText(0, "4403007");
            solo.clickOnText("完成");
        }
    }    

    public Test suite() throws Exception
                  {  
                        TestSuite ts = new TestSuite();  
                        ts.addTest(new loginTax("testLogin")); 
        
                        TestResult rst = new TestResult();
                        ts.run(rst);
                        if(rst.wasSuccessful()){
                                System.out.println("ok");
                        }
                        return ts;      
                  } 
    
    public void main(String[] args) throws Exception{
                        suite();
                   }

    protected void tearDown() throws Exception {
        try {
            this.solo.finishOpenedActivities();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        this.activity.finish();
        super.tearDown();
    }
}

——————————————————————————————————————————

【自动化框架脚本】

这里的bat文件为实现下面的功能编写的脚本：

删除apk签名->重新签名->安装待测apk到手机或模拟器->安装测试用例apk到手机或模拟器->运行测试运行->拷贝记录信息的txt到pc端。

//以下为HandleApk.bat文件内容：
rename *.apk apk.apk
echo 删除原来的文件，重新命名新的apk >> D:\cmdMobile.txt

winrar d "%FilePath%" META-INF
echo 删除签名完成 >> D:\cmdMobile.txt
rem pause

jarsigner -keystore C:\Users\haphoon\.android\debug.keystore -storepass android -keypass android %FilePath% androiddebugkey  >> D:\cmdMobile.txt
echo 重新签名完成 >> D:\cmdMobile.txt
rem pause

zipalign 4 %FilePath% %cd%\apk_sign.apk
echo 生成新的签名文件 >> D:\cmdMobile.txt
rem pause

adb wait-for-device install -r %cd%\apk_sign.apk  >> D:\cmdMobile.txt
echo 安装完成待测apk >> D:\cmdMobile.txt
rem pause
adb wait-for-device install -r D:\Auto_robotium\sinogain\bin\sinogain.apk >> D:\cmdMobile.txt
echo 安装完成测试sinogain.apk >> D:\cmdMobile.txt
rem pause
adb shell am instrument -w com.sinogain.test/android.test.InstrumentationTestRunner >> D:\cmdMobile.txt
echo 运行测试完成 >> >> D:\cmdMobile.txt
rem pause

rem adb shell am instrument -e class com.sinogain.test.loginTax#testLogin -w com.sinogain.test.loginTax/com.zutubi.android.junitreport.JUnitReportTestRunner

rem Process process = Runtime.getRuntime().exec( "cmd.exe /c start " + path)
rem Process process = Runtime.getRuntime().exec(cmd);
rem process.getInputStream();  shortMsg=Process crashed

adb pull /sdcard/testMobile.txt D:/  >> D:\cmdMobile.txt
echo Mobile到PC日志文件testMobile.txt文件传输完成 >> D:\cmdMobile.txt
rem pause

——————————————————————————————————————————

【执行Android Junit Test】

一. 用ant， 通过修改build.xml来执行

1. 首先编译test project，注意，如果没有release key，只能编译 debug版本（在eclipse下会用自签名的key签名）

2. 执行ant -p，列出可执行的target选项。到底有哪些target， 由build.xml中说明来决定的

     <!-- Required pre-setup import -->

    <import file="${sdk.dir}/tools/ant/pre_setup.xml" />  

 

 

3. 然后用ant targetname， 做相应的事情

     eg. ant debug: Builds the application and signs it with a debug key.

           ant coverage:Runs the tests against the instrumented code and generates code coverage report

   ant run-tests: Runs tests from the package defined in test.package property

4. ant coverage 可以 生成html报表，但必须在emulaotr上跑才能生成，在device上跑不能生成

 

二. 用adb shell am instrument命令来执行

需要借助com.zutubi.android.junitreport.JUnitReportTestRunner

The runner supports two arguments:

  * reportFilePath: the path, relative to the root of the tested

    application's file storage area, of the report file to generate.

    Defaults to junit-report.xml.

  * filterTraces: if true, stack traces in the report will be filtered

    to remove common noise (e.g. framework methods).  Defaults to

    true.

命令格式为：

adb shell am instrument -w -e reportFilePath my-report.xml \

  com.example.test/com.zutubi.android.junitreport.JUnitReportTestRunner

【Robotium API】

　　 -----框架提供的所有的方法都封装在Solo的对象中，使用很方便大致包含一下几类方法：

　　 获取控件；如 getCurrentActivity()，getEditText(String text)

　　输入操作；如 enterText(EditText editText, String text)

　　控件操作；如 clickOnText(String text)

　　模拟操作；如 scrollDown()

　　结果判断；如 assertCurrentActivity(String, String)

　　按键模拟；如 sendKey(int key)

　　控件状态检查；如 isRadioButtonChecked(String text)

　　搜索操作；如；searchText(String);

 　  时间控制；如；sleep(int time) 和 waitForActivity(String , int )

　　全部API，详见：robotium-solo-4.0-javadoc内容。

—————————————————————————————————————

【协助控件工具】

　　编写Android自动化测试代码过程中每个人都会遇到的问题就是不知道程序界面对应的Activity名称或者布局和控件的属性导致工作缓慢，可能我想知道某个控件的String，界面上可能一目了然，但是对于控件的id等，通过被测工程的R.java文件或者Layout的xml文件去查询也是可以的，但是，即便如此信息量也很大，花费时间也很久，况且如果仅有APK包的情况下就无能为力了。当然Google官方很好的替我们解决了这个困扰：Hierarchy Viewer工具。

Hierarchy Viewer工具位于Android SDK/tools/hierarchyviewwe.bat  (Windows操作系统)，它提供了一个可视化布局的视图层次结构（视图层次窗口），通过此工具可以详细的理解当前界面的控件布局以及某个控件的属性（name、id、height等）。

使用Hierarchy Viewer很简单，但是前提是需要Android系统权限，个人推荐使用模拟器即可，遵循步骤：

1.连接设备（需要权限，真机可能无法连接）或者模拟器；

2.打开你要查看的某个应用的界面布局（前提是打开此应用的对应界面）

3.Windows系统的情况下进入Android SDK/tools/双击打开hierarchyviewer.bat，也可以配置环境变量直接在命令行输入，打开Hierarchy Viewer工具界面（可点击图片放大查看）；

　　

　　说明：图中红色部分就是表示当前的活动的Activity，ConversationList就是Activity名称，对应的类就是ConversationList.java（这里对于只存在APK包情况下就能够很容易的找到需要启动的Activity对应的那个类。），每次界面变化后点击面板的Refresh都会同步更新。

4.双击图中的红色部分右下角会出现Loading view hierarchy，加载完毕后会显示当前界面层次结构（可点击图片放大查看）；

　　

　　说明：View Hierarchy窗口显示了运行在设备或者模拟器上的活动的Activity的所有View对象，不仅仅可以查看整个布局以及层次结构，选中某个View还可以查看View的具体信息，记住最好选择工具中的Show Extras选项。

　　如果想查看某个控件的详细信息，在View Hierarchy窗口中点击搜索按钮所在的位置，即可看到。

—————————————————————————————————————

【重用封装】

java操作Txt

import java.io.*;
/**
 * 功能描述：创建TXT文件并进行读、写、修改操作
 * @author 
 * @version 
 */
public class ReadWriteFile{
    public static BufferedReader bufread;
    //指定文件路径和名称
    private static String path = "D:/testMobile.txt";
    private static  File filename = new File(path);
    private static String readStr ="";

    /**
     * 创建文本文件.
     * @throws IOException 
     * 
     */
    public static void creatTxtFile() throws IOException{
        if (!filename.exists()) {
            filename.createNewFile();
            System.err.println(filename + "已创建！");
        }
    }
    
    /**
     * 读取文本文件.
     * 
     */
    public static String readTxtFile(){
        String read;
        FileReader fileread;
        try {
            fileread = new FileReader(filename);
            bufread = new BufferedReader(fileread);
            try {
                while ((read = bufread.readLine()) != null) {
                    readStr = readStr + read+ "\r\n";
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("文件内容是:"+ "\r\n" + readStr);
        return readStr;
    }
    
    /**
     * 写文件.
     */
    public static void writeTxtFile(String newStr) throws IOException{
        //先读取原有文件内容，然后进行写入操作
        String filein = newStr + "\r\n" + readStr + "\r\n";
        RandomAccessFile mm = null;
        try {
            mm = new RandomAccessFile(filename, "rw");
            mm.writeBytes(filein);
        } catch (IOException e1) {
            // TODO 自动生成 catch 块
            e1.printStackTrace();
        } finally {
            if (mm != null) {
                try {
                    mm.close();
                } catch (IOException e2) {
                    // TODO 自动生成 catch 块
                    e2.printStackTrace();
                }
            }
        }
    }
    
    /**
     * 将文件中指定内容的第一行替换为其它内容.
     * @param oldStr
     *            查找内容
    * @param replaceStr
     *            替换内容
    */
    public static void replaceTxtByStr(String oldStr,String replaceStr) {
        String temp = "";
        try {
            File file = new File(path);
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis);
            BufferedReader br = new BufferedReader(isr);
            StringBuffer buf = new StringBuffer();

            // 保存该行前面的内容
            for (int j = 1; (temp = br.readLine()) != null
                    && !temp.equals(oldStr); j++) {
                buf = buf.append(temp);
                buf = buf.append(System.getProperty("line.separator"));
            }

            // 将内容插入
            buf = buf.append(replaceStr);

            // 保存该行后面的内容
            while ((temp = br.readLine()) != null) {
                buf = buf.append(System.getProperty("line.separator"));
                buf = buf.append(temp);
            }

            br.close();
            FileOutputStream fos = new FileOutputStream(file);
            PrintWriter pw = new PrintWriter(fos);
            pw.write(buf.toString().toCharArray());
            pw.flush();
            pw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
   /**
     * main方法测试
     * @param s
     * @throws IOException
     */
    public static void main(String[] s) throws IOException {
        ReadWriteFile.creatTxtFile();
        ReadWriteFile.readTxtFile();
        ReadWriteFile.writeTxtFile("20080808:12:13");
//      ReadWriteFile.replaceTxtByStr("ken", "zhang");
    }
}

—————————————————————————————————————

Java Serialization实现任意文件网络传输

摘要：

　　这里通过Java中提供的Serialization机制，通过网络(Socket)实现任意文件在不同机器之间的传输。这里将包含两个实验的代码：

　　1.     将文件从一个电脑(客户端)，传送到另外一个电脑(服务端)；

　　2.     将文件从一个Android 2.1手机(客户端)，通过WiFi传送到电脑(服务端)。

　　很多朋友发现在两台机器之间，通过TCP socket传送文件的时候，所得到的文件要么比源文件大，要么比源文件小。尤其是在传递多媒体文件的时候，由于文件大小的变化，最终导致多媒体文件无法正常播放。造成这种情况的原因有很多，但100%是程序自身的问题。同样，解决的办法也有很多，本文所介绍的两个小实验，就是试图采用Java中提供的Serialization机制，来解决这样的问题。

实验一：

1.     先创建一个Java项目，项目名为ObjectClient，作为客户端应用。在这个项目中创建一个实现了Serializable接口的类FilePojo，代码如下：

//类FilePojopackage com.pnf.transfer; 
import java.io.Serializable;
 
// 必须实现Serializable接口。否则无法调用ObjectOutputStream的
// writeObject方法，或者ObjectInputStream中的readObject方法

public class FilePojo implements Serializable
{
      private static final long serialVersionUID = 1L;
         
      private String fileName;            // 文件名称
      private long fileLength;             // 文件长度
      private byte[] fileContent;          // 文件内容
 
      public String getFileName()
         {
                   return fileName;
         }
         
         public void setFileName(String fileName)
         {

                  this.fileName = fileName;
         }
         
         public long getFileLength()
         {
                   return fileLength;
         }
         
         public void setFileLength(long fileLength)
         {
                   this.fileLength = fileLength;
         }
       
         public byte[] getFileContent()
         {
                   return fileContent;
         }

         public void setFileContent(byte[] fileContent)
         {
                   this.fileContent = fileContent;
         }
}

　　这个类将在服务器端也会被用到。

//客户端代码
package com.pnf.transfer;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class ObjectClient
{
         public static void main(String[] args)
         {
                   String serverName = "192.168.0.10";        // 服务器IP
                   int port = 6666;                                                                  // 服务器端口
                   String filePath = "E:\\";                  // 要传递文件的路径
                   String fileName = "full.jpg";              // 要传递文件的名称
                   try
                   {
                            // 连接服务器
                            System.out.println("Connecting to " + serverName + " on port " + port);
                            Socket client = new Socket(serverName, port);
                            System.out.println("Just connected to " + client.getRemoteSocketAddress());
                            
                            // 创建FilePojo对象
                            FilePojo fpo = new FilePojo();
                            
                            // 设定文件名
                            fpo.setFileName(fileName);                            

                            // 设定文件大小
                            File f = new File(filePath + fileName);

                            long fileLength = f.length();
                            fpo.setFileLength(fileLength);
                            
                            // 读取文件内容，并将其转换为byte[]
                            FileInputStream fis = new FileInputStream(filePath + fileName);
                            byte[] fileContent = new byte[(int) fileLength];
                            fis.read(fileContent, 0, (int) fileLength);
                            fpo.setFileContent(fileContent);                           

                            // 将FilePojo对象fpo写到Socket client指定的输出流
                            long start = System.currentTimeMillis();
                            ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());
                            oos.writeObject(fpo);
                            long end = System.currentTimeMillis();
                            
                            System.out.println("It takes " + (end - start) + "ms");
                            oos.flush();
                            oos.close();
                   }
                   catch(IOException e)
                   {
                            e.printStackTrace();
                   }
         }
}

//服务器端代码
package com.pnf.transfer;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ObjectServer
{
         public static void main(String[] args) throws ClassNotFoundException
         {
                   ServerSocket serverSocket;
                   FileOutputStream fos;
                   
                   try
                   {
                            serverSocket = new ServerSocket(6666);
                            while(true)
                            {
                                      Socket clientSocket = serverSocket.accept();                                     
                                     // 从clientSocket获取ObjectInputStream对象
                                     ObjectInputStream ois = new ObjectInputStream(clientSocket.getInputStream());
                                     // 读取从客户端传递过来的FilePojo对象
                                     FilePojo fpo = (FilePojo) ois.readObject();
                                     System.out.println(fpo.getFileName());
                                     System.out.println(fpo.getFileLength());
                                     
                                     // 初始化FileOutputStream对象fos
                                     fos = new FileOutputStream("D:\\" + fpo.getFileName());
                                     // 将fpo中的内容写入fpo
                                     fos.write(fpo.getFileContent(), 0, (int)fpo.getFileLength());
                                     
                                     fos.close();
                                     ois.close();
                            }
                   }
                   catch(IOException ioe)
                   {
                            ioe.printStackTrace();
                   }
         }
}

先运行服务端，在运行客户端。

实验二：

1、服务端的代码和实验一中的一样。

2、手机客户端代码如下：

//android 手机客户端代码
package com.pnf.transfer;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class AndroidObjectClientActivity extends Activity
implements
OnClickListener
{
         private Button btn_send;
         private String filePath = "/sdcard/image/";
         private String fileName = "bln.jpg";

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
       
        btn_send = (Button)this.findViewById(R.id.btn_send);
        btn_send.setOnClickListener(this);
    }
 
         public void onClick(View v)
         {
                   try
                   {
                            // 建立和服务器的连接
                           Socket socket = new Socket("192.168.0.10", 6666);

                            // 创建FilePojo对象
                            FilePojo fpo = new FilePojo();
                            
                            // 设定文件名
                            fpo.setFileName(fileName);

                            // 设定文件大小
                            File f = new File(filePath + fileName);
                            long fileLength = f.length();
                            fpo.setFileLength(fileLength);
                            
                            // 读取文件内容，并将其转换为byte[]
                            FileInputStream fis = new FileInputStream(filePath + fileName);
                            byte[] fileContent = new byte[(int) fileLength];
                            fis.read(fileContent, 0, (int) fileLength);
                            fpo.setFileContent(fileContent);                            

                            // 将FilePojo对象fpo写到Socket client指定的输出流
                            long start = System.currentTimeMillis();
                            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                            oos.writeObject(fpo);
                            long end = System.currentTimeMillis();
                            Toast.makeText(this.getApplicationContext(), "It takes " + (end - start) + "ms", Toast.LENGTH_LONG).show();
                            oos.flush();
                            oos.close();
                   }
                   catch(Exception ioe)
                   {
                            ioe.printStackTrace();
                   }
         }
}

3、在AndroidManifest.xml中增加permission如下(粗体字部分)：添加权限

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

         <uses-permission android:name="android.permission.INTERNET" />

4、先运行服务端，再在手机上运行客户端。

—————————————————————————————————————

JAVA操作Excel

package com.sinogain.test;

import java.io.File;

import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
import jxl.write.Label;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;

public class OperateExcel {
    public static void CreateExcel() {
        try {
            // 打开文件
            WritableWorkbook book = Workbook.createWorkbook(new File("D:/test.xls"));
            // 生成名为“第一页”的工作表，参数0表示这是第一页
            WritableSheet sheet = book.createSheet("第一页", 0);
            // 在Label对象的构造子中指名单元格位置是第一列第一行(0,0)
            // 以及单元格内容为test
            Label label = new Label(0, 0, "test");

            // 将定义好的单元格添加到工作表中
            sheet.addCell(label);

            /*
             * 生成一个保存数字的单元格 必须使用Number的完整包路径，否则有语法歧义 单元格位置是第二列，第一行，值为789.123
             */
            jxl.write.Number number = new jxl.write.Number(1, 0, 555.12541);
            sheet.addCell(number);

            // 写入数据并关闭文件
            book.write();
            book.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    
    //读取Excel的类
    public static String ReadExcel(String filePath,int Row,int colum){
        try {
            Workbook book = Workbook.getWorkbook(new File(filePath));
            // 获得第一个工作表对象
            Sheet sheet = book.getSheet(0);
            // 得到第一列第一行的单元格
            Cell cell1 = sheet.getCell(Row-1, colum-1);
            String result = cell1.getContents();
            System.out.println(result);
            book.close();
            return result;
        } catch (Exception e) {
            System.out.println(e);
        }
        return null;
    }
    
    public static void UpdateExcel() {
        try {
            // Excel获得文件
            Workbook wb = Workbook.getWorkbook(new File("test.xls"));
            // 打开一个文件的副本，并且指定数据写回到原文件
            WritableWorkbook book = Workbook.createWorkbook(new File("test.xls"),
                    wb);
            // 添加一个工作表
            WritableSheet sheet = book.createSheet("第二页", 1);
            sheet.addCell(new Label(0, 0, "第二页的测试数据"));
            book.write();
            book.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    
    public static void CountExcel() {
        try {
            Workbook book = Workbook.getWorkbook(new File("测试1.xls"));
            // 获得第一个工作表对象
            Sheet sheet = book.getSheet(0);
            // 得到第一列第一行的单元格
            int columnum = sheet.getColumns();// 得到列数
            int rownum = sheet.getRows();// 得到行数
            System.out.println(columnum);
            System.out.println(rownum);
            for (int i = 0; i < rownum; i++)// 循环进行读写
            {
                for (int j = 0; j < columnum; j++) {
                    Cell cell1 = sheet.getCell(j, i);
                    String result = cell1.getContents();
                    System.out.print(result);
                    System.out.print("\t");
                }
                System.out.println();
            }
            book.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

————————————————————————————————————————