修改文件夹结构

src/university/1.md

@@ -2,11 +2,11 @@
 
 **随着软件系统规模越来越大、越来越复杂，整个系统的结构和规格说明显得越来越重要。对于软件项目的开发来说，具有清晰的软件体系结构是非常重要的。软件体系结构 在软件需求和设计之间架起了一座桥梁，着重解决软件系统的结构和需求向实现平坦地过渡的问题。**
 
-![image-20211123103437918](概述.assets\image-20211123103437918.png)
+![image-20211123103437918](软件体系结构\image-20211123103437918.png)
 
 > 软件工程教育的定位
 
-![image-20211123103645580](概述.assets\image-20211123103645580.png)
+![image-20211123103645580](软件体系结构\image-20211123103645580.png)
 
 ## 软件危机
 
@@ -65,7 +65,7 @@
 
 将应用领域的概念按照从抽象到具体的顺序逐次分解为树状图
 
-![image-20211123110318892](概述.assets\image-20211123110318892.png)
+![image-20211123110318892](软件体系结构\image-20211123110318892.png)
 
 > 刻面分类法
 
@@ -82,7 +82,7 @@
 
 是一种非线性的网状信息组织方法，以节点为单位，链作为节点之间的联想式关联。
 
-![image-20211123110702665](概述.assets\image-20211123110702665-16376368250511.png)
+![image-20211123110702665](软件体系结构\image-20211123110702665-16376368250511.png)
 
 ### 构件重用
 
@@ -145,7 +145,7 @@
 
 >计算机硬件系统的“体系结构”
 
-![image-20211123130321861](概述.assets\image-20211123130321861.png)
+![image-20211123130321861](软件体系结构\image-20211123130321861.png)
 
 **包含两个因素：**
 

src/university/101.md

@@ -119,7 +119,7 @@
 
 ​		对测试结果与预期的结果进行比较以后，即可判断是否存在错误，决定是否进入排错阶段，进行调试任务。由于修改可能会带来新的问题，我们需要对修改以后的程序重新测试，即进行回归测试。
 
-![image-20211201164435770](软件测试概述.assets/image-20211201164435770.png)
+![image-20211201164435770](软件测试/image-20211201164435770.png)
 
 ### 软件测试停止标准
 

src/university/102.md

@@ -180,7 +180,7 @@
 
 ​		模块并不是一个独立的程序，在考虑测试模块时，同时要考虑它和外界的联系， 用一些辅助模块去模拟与被测模块相联系的其它模块。这些辅助模块分为两种：
 
-![image-20211201171933670](软件测试方法与过程.assets/image-20211201171933670.png)
+![image-20211201171933670](软件测试/image-20211201171933670.png)
 
 - **驱动模块（driver）**：用以模拟被测模块的上级模块，它接收测试数据，把这些数据传送给被测模块，启动被测模块，最后输出实测结果。
 - **桩模块（stub）**：也称为存根程序，用以模拟被测模块工作过程中所调用的子模块。桩模块由被测模块调用，它们一般只进行很少的数据处理，例如打印入口和返回，以便于检验被测模块与其下级模块的接口。桩模块可以做少量的数据操作，不需要把子模块所有功能都带进来，但不允许什么事情也不做。
@@ -344,7 +344,7 @@
 ​		当考虑面向对象软件时，单元的概念发生了变化。封装驱动了类和对象的定义，
 ​		这意味着每个类和类的实例(对象)包装了属性(数据)和操纵这些数据的操作。一个类可以包含一组不同的操作，而一个特定的操作也可能存在于一组不同的类中。因此，单元测试的意义发生了较大变化。我们不再孤立地测试单个操作，而是将操作作为类的一部分。此时最小的可测试单位是封装的类或对象，而不再是个体的模块。
 
-![image-20211201173618104](软件测试方法与过程.assets/image-20211201173618104.png)
+![image-20211201173618104](软件测试/image-20211201173618104.png)
 
 ### 面向对象软件的集成测试
 

src/university/103.md

@@ -4,7 +4,7 @@
 
 ​		黑盒测试又称为功能测试或数据驱动测试，着眼于程序外部结构，将被测试程序视为一个不能打开的黑盒子，完全不考虑程序内部逻辑结构和内部特性，主要针对软件界面、软件功能、外部数据库访问以及软件初始化等方面进行测试。
 
-![image-20211201173901972](黑盒测试.assets/image-20211201173901972.png)
+![image-20211201173901972](软件测试/image-20211201173901972.png)
 
 > 主要目的
 
@@ -18,7 +18,7 @@
 
 > 黑盒测试常用的方法和技术
 
-![image-20211201174008210](黑盒测试.assets/image-20211201174008210.png)
+![image-20211201174008210](软件测试/image-20211201174008210.png)
 
 ## 边界值测试
 
@@ -56,35 +56,35 @@
 
 ​		为便于理解，假设有两个变量 x1 和 x2 的函数 F，其中函数 F 实现为一个程序， x1、x2 在下列范围内取值： a≤x1≤bc≤x2≤d 区间[a，b]和[c，d]是 x1、x2 的值域，程序 F 的输入定义域如下图所示，即带阴影矩 形中的任何点都是程序 F 的有效输入。
 
-![image-20211201183816380](黑盒测试.assets/image-20211201183816380.png)
+![image-20211201183816380](软件测试/image-20211201183816380.png)
 
 ​		采用边界值分析测试的基本原理是：故障往往出现在输入变量的边界值附近。
 ​		例如，当一个循环条件为“≤”时，却错写成“<”，计时器发生少计数一次。
 
-![image-20211201183838327](黑盒测试.assets/image-20211201183838327.png)
+![image-20211201183838327](软件测试/image-20211201183838327.png)
 
 ​		边界值分析测试的基本思想是使用在最小值（min）、略高于最小值（min+）、正常值（nom）、略低于最大值（max-）和最大值（max）处取输入变量值。同时，对于有多个输入变量的情况我们通常是基于可靠性理论中称为“单故障”的假设，这种假设认为有两个或两个以上故障同时出现而导致软件失效的情况很少，也就是说，软件失效基本上是由单故障引起的。因此，边界值分析测试用例的获得，是通过使一个变量取极值，剩下所有变量取正常值。
 
 ​		因此，边界值分析测试用例的获得，是通过使一个变量 取极值，剩下所有变量取正常值。前面有两个输入变量的程序 F 的边界值分析测试用例（如图 3.2 所示）是： 
 
-![image-20211201184120162](黑盒测试.assets/image-20211201184120162.png)
+![image-20211201184120162](软件测试/image-20211201184120162.png)
 
 ​		 { < x1nom ,x2min >, < x1nom ,x2min+ >, < x1nom , x2nom >, < x1nom , x2max- >, < x1nom , x2max >,< x1min , x2nom >,< x1min+ , x2nom >, < x1max- , x2nom >, < x1max , x2nom > } 
 ​		对于一个含有 n 个变量的程序，保留其中一个变量，让其余的变量取正常值，被 保留的变量依次取 min、 min+、nom、max-、max 值，对每个变量都重复进行。这样， 对于一个有 n 个变量的程序，边界值分析测试程序会产生 4n+1 个测试用例。如果没有显式的给出边界，如三角形问题，则必须创建一种人工边界，可以先设定下限值（边长应大于等于 1），并规定上限值，如 100，或取默认的最大可表示的整数值。
 
-![image-20211201184148234](黑盒测试.assets/image-20211201184148234.png)
+![image-20211201184148234](软件测试/image-20211201184148234.png)
 
 > 健壮性测试
 
 ​		健壮性测试是边界分析测试的一种简单扩展，除了取 5 个边界值分析取值外，还需要考虑采用一个略超过最大值（max+）以及略小于最小值（min-）的取值，检查超过极限值时系统的表现会是什么。健壮性测试最有意义的部分不是输入，而是预期的 输出。它要观察例外情况如何处理，比如某个部分的负载能力超过其最大值可能出现的情形。健壮性测试如图 3.3 所示。
 
-![image-20211201184223797](黑盒测试.assets/image-20211201184223797.png)
+![image-20211201184223797](软件测试/image-20211201184223797.png)
 
 ### 边界值分析法测试实例
 
 > 三角形问题
 
-![image-20211201184332302](黑盒测试.assets/image-20211201184332302.png)
+![image-20211201184332302](软件测试/image-20211201184332302.png)
 
 问题描述：
 		三角形问题接受三个整数 a、b 和 c 作为输入，用做三角形的边。
@@ -93,7 +93,7 @@
 ​		通过提供更多细节可以改进这个定义。于是这个问题变成以下的形式。
 ​		三角形问题接受三个整数 a、b 和 c 作为输入，用做三角形的边。整数 a、b 和 c 必须满足以下条件：
 
-![image-20211201184514708](黑盒测试.assets/image-20211201184514708.png)
+![image-20211201184514708](软件测试/image-20211201184514708.png)
 
 ​		程序的输出是由这三条边确定的三角形类型：等边三角形、等腰三角形、不等边三角形或非三角形。如果输入值没有满足 c1、c2 和 c3 这些条件中的任何一个，则程序会通过输出消息来进行通知，例如，“b 的取值不在允许取值的范围内。”如果 a、b 和 c 取值满足 c1、c2 和 c3，则给出以下四种相互排斥输出中的一个： 
 
@@ -104,7 +104,7 @@
 
 ​		在三角形问题描述中，除了要求边长是整数外，没有给出其它的限制条件。边界下限为 1，上限为 100。表 3.1 给出了边界值分析测试用例。
 
-![image-20211201184707417](黑盒测试.assets/image-20211201184707417.png)
+![image-20211201184707417](软件测试/image-20211201184707417.png)
 
 >NextDate 函数
 
@@ -117,13 +117,13 @@
 
 ​		在NextDate 函数中，规定了变量 month、day、year 相应的取值范围，即 1 ≤ month ≤ 12，1 ≤ day ≤31，1912 ≤ year ≤ 2050，表 3.2 给出了其健壮性测试用例。
 
-![image-20211201184826162](黑盒测试.assets/image-20211201184826162.png)
+![image-20211201184826162](软件测试/image-20211201184826162.png)
 
 边界值分析局限性:
 
 ​		如果被测程序是多个独立变量的函数，这些变量受物理量的限制，则很适合采用边界值分析。这里的关键是“独立”和“物理量”。
 
-![image-20211201184826162](黑盒测试.assets/image-20211201184826162.png)
+![image-20211201184826162](软件测试/image-20211201184826162.png)
 
 ​		简单地看一下表 3.2 中 NextDate 函数的边界分析测试用例，就会发现其实这些测试用例是不充分的。
 
@@ -156,23 +156,23 @@
 ​		如果这样做了， 则可以预期不会从诸如（3，3，3）和（100，100，100）这样的测试用例中得到多少新东西。直觉告诉我们，这些测试用例会以与第一个测试用例一样的方式进行“相同处理”，因此，这些测试用例是冗余。
 ​		当我们在考虑结构性测试时，将会看到“相同处理”映射到“遍历相同的执行路径。”
 
-![image-20211201185246770](黑盒测试.assets/image-20211201185246770.png)
+![image-20211201185246770](软件测试/image-20211201185246770.png)
 
 ​		等价类测试的关键就是选择确定类的等价关系。通常我们通过预测可能的实现， 考虑在现实中必须提供的功能操作来做出这种选择。我们将用一系列例子说明这一 点，但是首先必须区分弱和强等价类测试。 
 
 ​		为了便于理解，我们还是讨论与有两个变量 x1 和 x2 的函数 F 联系起来。如果 F 实现为一个程序，则输入变量 x1 和 x2 将拥有以下边界，以及边界内的区间：
 
-![image-20211201185314275](黑盒测试.assets/image-20211201185314275.png)
+![image-20211201185314275](软件测试/image-20211201185314275.png)
 
 ​		其中方括号和圆括号分别表示闭区间和开区间的端点。x1 和 x2 的无效值是：x1<a，x1>d 以及 x2<e，x2>g。
 
 - **弱一般等价类测试**
 
-![image-20211201185353718](黑盒测试.assets/image-20211201185353718.png)
+![image-20211201185353718](软件测试/image-20211201185353718.png)
 
 ​		弱一般等价类测试通过使用测试用例的每个等价类（区间）的一个变量实现（单缺陷 假设的作用）。对于上面给出的例子，可得到如图 3.4 所示的弱等价类测试用例。
 
-![image-20211201185411375](黑盒测试.assets/image-20211201185411375.png)
+![image-20211201185411375](软件测试/image-20211201185411375.png)
 
 ​		这三个测试用例使用每个等价类中的一个值。事实上，永远都有等量的弱等价类测试用例，因为划分中的类对应最大子集数。
 
@@ -180,7 +180,7 @@
 
 ​		强一般等价类测试基于多缺陷假设，它需要等价类笛卡儿积的每个元素对应的测试用 例（如图 3.5 所示）。笛卡儿积可保证两种意义上的“完备性”：一是覆盖所有的等价类， 二是覆盖所有可能的输入组合中的每一个。
 
-![image-20211201185510350](黑盒测试.assets/image-20211201185510350.png)
+![image-20211201185510350](软件测试/image-20211201185510350.png)
 
 ​		“好的”等价类测试的关键是等价关系的选择，要注意被“相同处理”的输入。在大多数情况下，等价类测试定义输入定义域的等价类。不过，其实也没有理由不能根据被测程序函数的输出值域定义等价关系。事实上，这对于三角形问题是最简单的方法。 
 
@@ -191,19 +191,19 @@
 （1）对于有效输入，弱健壮等价类测试使用每个有效类的一个值，就像我们在弱一般等价类测试中所做的一样。请注意，这些测试用例中的所有输入都是有效的。 
 （2）对于无效输入，弱健壮等价类测试的测试用例将拥有一个无效值，并保持其余的值都是有效的。此时，“单缺陷”会造成测试用例失败。
 
-![image-20211201185622304](黑盒测试.assets/image-20211201185622304.png)
+![image-20211201185622304](软件测试/image-20211201185622304.png)
 
 ​		对于健壮等价类测试通常有两个问题。
 ​		第一是：规格说明常常并没有定义无效测试用例所预期的输出是什么。因此，测试人员需要花大量时间定义这些测试用例的输出。
 ​		第二是：强类型语言没有必要考虑无效输入。
 
-![image-20211201185646617](黑盒测试.assets/image-20211201185646617.png)
+![image-20211201185646617](软件测试/image-20211201185646617.png)
 
 - **强健壮等价类测试**
 
 ​		强健壮等价类测试，“强”是指该类测试用例的获得是基于多缺陷假设，“健壮” 则和前面的定义一样，是指考虑了无效值。如图 3.7 所示，强健壮等价类测试从所有等价类笛卡尔积的每个元素中获得测试用例
 
-![image-20211201185720758](黑盒测试.assets/image-20211201185720758.png)
+![image-20211201185720758](软件测试/image-20211201185720758.png)
 
 ### 等价类测试实例
 
@@ -218,31 +218,31 @@
 
 ​		四个弱一般等价类测试用例是：
 
-![image-20211201185855380](黑盒测试.assets/image-20211201185855380.png)
+![image-20211201185855380](软件测试/image-20211201185855380.png)
 
 ​		 由于变量 a、b 和 c 没有有效区间划分，则强一般等价类测试用例与弱一般等价类测试用例相同。 
 
 ​		考虑 a、b 和 c 的无效值产生的以下额外弱健壮等价类测试用例：
 
-![image-20211201185914625](黑盒测试.assets/image-20211201185914625.png)
+![image-20211201185914625](软件测试/image-20211201185914625.png)
 
 ​		以下是额外强健壮等价类测试用例三维立方的一个“角”：
 
-![image-20211201185928154](黑盒测试.assets/image-20211201185928154.png)
+![image-20211201185928154](软件测试/image-20211201185928154.png)
 
 ​		请注意，预期输出如何完备地描述无效输入值。
 
 ​		等价类测试显然对于用来定义的等价关系很敏感。如果在输入定义域上定义等价类，则可以得到更丰富的测试用例集合。三个整数 a、b 和 c 有些什么可能的取值呢？ 这些整数相等（有三种相等方式），或都不相等。
 
-![image-20211201185951454](黑盒测试.assets/image-20211201185951454.png)
+![image-20211201185951454](软件测试/image-20211201185951454.png)
 
 ​		作为一个单独的问题，我们可以通过三角形的性质来判断三条边是否构成一个三角形（例如，三元组有一对相等的边，但是这些边不构成一个三角形）
 
-![image-20211201190007123](黑盒测试.assets/image-20211201190007123.png)
+![image-20211201190007123](软件测试/image-20211201190007123.png)
 
 ​		如果我们要彻底一些，可以将“小于或等于”分解为两种不同的情况，这样D6就变成：
 
-![image-20211201190021538](黑盒测试.assets/image-20211201190021538.png)
+![image-20211201190021538](软件测试/image-20211201190021538.png)
 
 ​		同样对于 D7 和 D8 也有类似的情况。 
 
@@ -262,15 +262,15 @@
 
 ​		由于每个独立变量的有效区间均为 1 个，因此只有弱一般等价类测试用例出现， 并且与强一般等价类测试用例相同：
 
-![image-20211201190152773](黑盒测试.assets/image-20211201190152773.png)
+![image-20211201190152773](软件测试/image-20211201190152773.png)
 
 ​		以下是弱健壮测试用例的完整集合：
 
-![image-20211201190219195](黑盒测试.assets/image-20211201190219195.png)
+![image-20211201190219195](软件测试/image-20211201190219195.png)
 
 ​		与三角形问题一样，以下是额外强健壮性等价类测试用例三维立方的一个“角”：
 
-![image-20211201190232104](黑盒测试.assets/image-20211201190232104.png)
+![image-20211201190232104](软件测试/image-20211201190232104.png)
 
 ​		划分等价关系的重点是等价类中的元素要被“同样处理”。上述方法所得测试用例集其实是不足的，因为它只注意到在单个变量处理的有效/无效层次上进行，而没有进一步分析具体处理的过程与特征。对该函数如果更仔细地选择等价关系，所得到的等价类和测试用例集将会更有用。
 
@@ -295,15 +295,15 @@
 
 ​		这些类产生以下弱等价类测试用例。与前面一样，机械地从对应类的取值范围中选择输入：
 
-![image-20211201190356493](黑盒测试.assets/image-20211201190356493.png)
+![image-20211201190356493](软件测试/image-20211201190356493.png)
 
  		机械选择输入值不考虑领域知识，因此没有考虑两种不可能出现的日期。“自动” 测试用例生成永远都会有这种问题，因为领域知识不是通过等价类选择获得的。
 
 ​		经过改进的强一般等价类测试用例是：
 
-![image-20211201190417520](黑盒测试.assets/image-20211201190417520.png)
+![image-20211201190417520](软件测试/image-20211201190417520.png)
 
-![image-20211201190447624](黑盒测试.assets/image-20211201190447624.png)
+![image-20211201190447624](软件测试/image-20211201190447624.png)
 
 ​		从弱一般测试转向强一般测试会产生一些边界值测试中也出现的冗余问题。从弱到强的转换，不管是一般类还是健壮类，都是以等价类的叉积表示。3 个月份类乘以 4 个日期类乘以 3 个年类，产生 36 个强一般等价类测试用例。对每个变量加上 2 个无效类，得到 150 个强健壮等价类测试用例。
 
@@ -335,23 +335,23 @@
 
 ​		根据上述等价类的划分，可得如下所示佣金问题的弱一般等价类测试用例，这个 测试用例同样也等于强一般等价类测试用例。
 
-![image-20211201230357490](黑盒测试.assets/image-20211201230357490.png)
+![image-20211201230357490](软件测试/image-20211201230357490.png)
 
 ​		七个弱健壮测试用例如下。 
 
-![image-20211201230412831](黑盒测试.assets/image-20211201230412831.png)
+![image-20211201230412831](软件测试/image-20211201230412831.png)
 
 ​		最后，额外强健壮等价类测试用例三维立方的一个“角”是：
 
-![image-20211201230430165](黑盒测试.assets/image-20211201230430165.png)
+![image-20211201230430165](软件测试/image-20211201230430165.png)
 
 ​		请注意，对于强测试用例，不管是强一般测试用例还是强健壮测试用例，都只有一个是合理输入。如果确实担心错误案例，那么这就是很好的测试用例集合。但是这样很 难确信佣金问题的计算部分没有问题。在本例中，我们可以通过对输出值域定义等价类来进一步完善测试。前面提到过，销售额是所售出的枪机、枪托和枪管数量的函数：
 
-![image-20211201230451253](黑盒测试.assets/image-20211201230451253.png)
+![image-20211201230451253](软件测试/image-20211201230451253.png)
 
 ​		由此得到如下的输出值域等价类测试用例：
 
-![image-20211201230507137](黑盒测试.assets/image-20211201230507137.png)
+![image-20211201230507137](软件测试/image-20211201230507137.png)
 
 ​		这些测试用例让人感觉到正在接触问题的重要部分。与弱健壮测试用例结合在一 起，就可得到佣金问题的相当不错的测试。另外，可能还希望增加一些边界检查，只是为了保证从 1000 美元到 1800 美元的转移是正确的。
 
@@ -376,7 +376,7 @@
 
 ​		自从 20 世纪 60 年代初以来，决策表一直被用来表示和分析复杂逻辑关系。决策 61 表很适合描述不同条件集合下采取行动的若干组合的情况。
 
-![image-20211201230705200](黑盒测试.assets/image-20211201230705200.png)
+![image-20211201230705200](软件测试/image-20211201230705200.png)
 
 ​		决策表有四个部分：粗竖线左侧是桩部分；右侧是条目部分。横粗线的上面是条件部分，下面是行动部分。因此，我们可以引用条件桩、条件条目、行动桩和行动条目。条目部分中的一列是一条规则。规则只是在规则的条件部分中指示的条件环境下要采取什么行动。在表 3.3 给出的决策表中，如果 c1、c2 和 c3 都为真，则采取行动 a1 和 a2。如果 c1 和 c2 都为真而 c3 为假，则采取行动 a1 和 a3。在 c1 为真 c2 为假的 条件下采取行动 a4，此时规则中的 c3 条目叫做“不关心”条目。不关心条目有两种主 要解释：条件无关或条件不适用。 
 
@@ -390,61 +390,61 @@
 
 
 
-![image-20211201230807856](黑盒测试.assets/image-20211201230807856.png)
+![image-20211201230807856](软件测试/image-20211201230807856.png)
 
 ​		在表 3.4 所示的决策表中，给出了不关心条目和不可能规则使用的例子。正如第 一条规则所指示，如果整数 a、b 和 c 不构成三角形，则我们根本不关心可能的相关系。在规则 3、4 和 6 中，如果两对整数相等，则根据传递性，第三对整数也一定相等，因此这些规则不可能满足。
 
 
 
-![image-20211201230820493](黑盒测试.assets/image-20211201230820493.png)
+![image-20211201230820493](软件测试/image-20211201230820493.png)
 
 ​		表 3.5 所示的决策表给出了有关表示方法的另一种考虑：条件的选择可以大大地 扩展决策表的规模。这里将老条件（c1:a、b、c 构成三角形？）扩展为三角形特性的三个不等式的详细表示。如果有一个不等式不成立，则三个整数就不能构成三角形。 我们还可以进一步扩展，因为不等式不成立有两种方式：一条边等于另外两条边的和， 或严格大于另外两条边的和。
 
 
 
-![image-20211201230833672](黑盒测试.assets/image-20211201230833672.png)
+![image-20211201230833672](软件测试/image-20211201230833672.png)
 
 ​		如果条件引用了等价类，则决策表会有一种典型的外观。如表 3.6 所示的决策表来自 NextDate 问题，引用了可能的月份变量相互排斥的可能性。由于一个月份就是一 个等价类，因此不可能有两个条目同时为真的规则。不关心条目（-）的实际含义是“必须失败”。有些决策表使用者用 F 表示这一点。
 
 
 
-![image-20211201230852544](黑盒测试.assets/image-20211201230852544.png)
+![image-20211201230852544](软件测试/image-20211201230852544.png)
 
 ​		不关心条目的使用，对完整决策表的识别方式有微妙的影响。对于有限的条目决策表，如果有 n 个条件，则必须有 2 n 条规则。如果不关心条目实际地表明条件是不相关的，则可以按以下方法统计规则数：没有不关心条目的规则统计为 1 条规则；规则中每出现一个不关心条目，该规则数乘一次 2。表 3.5 所示决策表的规则条目数统 计如表 3.7 所示。请注意，规则总数是 64（正好是应该得到的规则条数）。
 
 
 
-![image-20211201230920870](黑盒测试.assets/image-20211201230920870.png)
+![image-20211201230920870](软件测试/image-20211201230920870.png)
 
 ​		如果将这种简化算法应用于表 3.6 所示的决策表，会得到如表 3.8 所示的规则条数统计。
 
 
 
-![image-20211201230939629](黑盒测试.assets/image-20211201230939629.png)
+![image-20211201230939629](软件测试/image-20211201230939629.png)
 
 ​		应该只有八条规则，所以显然有问题。为了找出问题所在，我们扩展所有三条规则，用可能的 T 或 F 替代“-”，如图 3.9 所示。
 
 
 
-![image-20211201230953248](黑盒测试.assets/image-20211201230953248.png)
+![image-20211201230953248](软件测试/image-20211201230953248.png)
 
 ​		请注意，所有条目都是 T 的规则有三条：规则 1.1、2.1、和 3.1；条目是 T、T、 F 的规则有两条：规则 1.2 和 2.2。类似地，规则 1.3 和 3.2、2.3 和 3.3 也是一样的。 如果去掉这种重复，最后可得到七条规则，缺少的规则是所有条件都是假的规则。这 种处理的结果如表 3.10 所示，表中还给出了不可能出现的规则。
 
 
 
-![image-20211201231007415](黑盒测试.assets/image-20211201231007415.png)
+![image-20211201231007415](软件测试/image-20211201231007415.png)
 
 ​		这种识别完备决策表的能力，使我们在解决冗余性和不一致性方面处于很有利的 地位，表 3.11 给出的决策表是冗余的，因为有三个条件则应该是 2³=8 条规则，此处却有九条规则。（规则 9 和规则 1~4 中某一条相同，是冗余规则。）
 
 
 
-![image-20211201231023187](黑盒测试.assets/image-20211201231023187.png)
+![image-20211201231023187](软件测试/image-20211201231023187.png)
 
 ​		注意规则 9 的行为条目与规则 1~4 的条目相同。只要冗余规则中的行为与决策表相同的部分相同，就不会有什么大问题。如果行为条目不同，例如表 3.12 所示的情况， 则会遇到比较大的问题。
 
 
 
-![image-20211201231037464](黑盒测试.assets/image-20211201231037464.png)
+![image-20211201231037464](软件测试/image-20211201231037464.png)
 
 ​		如表 3.12 所示的决策表被用来处理事务，其中 c1 是真，c2 和 c3 都是假，则规则 4 和规则 9 都适用。我们可以观察到两点： 
 
@@ -459,13 +459,13 @@
 
 - **三角形问题的测试用例**
 
-![image-20211201231150972](黑盒测试.assets/image-20211201231150972.png)
+![image-20211201231150972](软件测试/image-20211201231150972.png)
 
 ​		使用表 3.5 所示的决策表，可得到 11 个功能性测试用例：3 个不可能测试用例， 3 个测试用例违反三角形性质，1 个测试用例可得到等边三角形，1 个测试用例可得到 不等边三角形，3 个测试用例可得到等腰三角形（如表 3.13 所示）如果扩展决策表以 显示两种违反三角形性质的方式，可以再选三个测试用例（一条边正好等于另外两条边的和）。做到这一点需要做一定的判断，否则规则会呈指数级增长。在这种情况下，最终会再得到很多不关心条目和不可能的规则。
 
 
 
-![image-20211201231212352](黑盒测试.assets/image-20211201231212352.png)
+![image-20211201231212352](软件测试/image-20211201231212352.png)
 
 ​		使用表 3.5 所示的决策表，可得到 11 个功能性测试用例：3 个不可能测试用例， 3 个测试用例违反三角形性质，1 个测试用例可得到等边三角形，1 个测试用例可得到 不等边三角形，3 个测试用例可得到等腰三角形（如表 3.13 所示）如果扩展决策表以 显示两种违反三角形性质的方式，可以再选三个测试用例（一条边正好等于另外两条边的和）。做到这一点需要做一定的判断，否则规则会呈指数级增长。在这种情况下，最终会再得到很多不关心条目和不可能的规则。
 
@@ -493,7 +493,7 @@
 
 
 
-![image-20211201231332009](黑盒测试.assets/image-20211201231332009.png)
+![image-20211201231332009](软件测试/image-20211201231332009.png)
 
 ​		如表 3.14 所示是决策表，共有 22 条规则。
 
@@ -501,19 +501,19 @@
 
 
 
-![image-20211201231402291](黑盒测试.assets/image-20211201231402291.png)
+![image-20211201231402291](软件测试/image-20211201231402291.png)
 
 ​		规则 1~5 处理有 30 天的月份，其中不可能规则也列出，如规则 5 处理在有 30 天 的月份中考虑 31 日；规则 6~10 和规则 11~15 处理有 31 天的月份，其中规则 6~10 处 理 12 月之外的月份，规则 11~15 处理 12 月；最后的 7 条规则关注 2 月和闰年问题。
 
 
 
-![image-20211201231426127](黑盒测试.assets/image-20211201231426127.png)
+![image-20211201231426127](软件测试/image-20211201231426127.png)
 
 ​		可进一步简化这 22 条规则。若决策表中有两条规则的动作项相同，则一定至少 68 有一个条件能够把这两条规则用不关心条件合并。例如，规则 1、2、3 都涉及有 30 天的月份 day 类 D1、D2 和 D3，并且它们的动作项都是 day 加 1，因此可以将规则 1、 2、3 合并。类似地，有 31 天的月份的 day 类 D1、D2、D3 和 D4 也可合并，2 月的 D4 和 D5 也可合并。简化后的决策表如表 3.15 所示。 
 
 
 
-![image-20211201231447352](黑盒测试.assets/image-20211201231447352.png)
+![image-20211201231447352](软件测试/image-20211201231447352.png)
 
 ​		根据简化后的决策表 3.15，可设计测试用例，如表 3.16 所示。
 
@@ -558,7 +558,7 @@
 
 > 现有一个学生标准化考试批阅试卷，产生成绩报告的程序。其规格说明如下：程序的输入文件由一些有 80 个字符的记录组成，所有记录分为 3 组，如图：
 >
-> ![image-20211201231722813](黑盒测试.assets/image-20211201231722813.png)
+> ![image-20211201231722813](软件测试/image-20211201231722813.png)
 >
 > - 标题：该组只有一个记录，其内容是成绩报告的名字。 
 > - 各题的标准答案：每个记录均在第 80 个字符处标以数字 2。该组的记录： 

src/university/104.md

@@ -17,16 +17,16 @@
 
 ​		常见语句的控制流图如图4.1所示。
 
-![image-20211201232227736](白盒测试.assets/image-20211201232227736.png)
+![image-20211201232227736](软件测试/image-20211201232227736.png)
 
 ​		包含条件的节点被称为判定节点（也叫谓词节点），由判定节点发出的边必须终止于某一个相同节点，由边和节点所限定的范围被称为区域。
 ​		如果将一个典型的程序流程图转换为控制流图，转换结果如图4.2 所示。
 
-![image-20211201232254292](白盒测试.assets/image-20211201232254292.png)
+![image-20211201232254292](软件测试/image-20211201232254292.png)
 
 ​		对于复合条件，则可将其分解为多个单个条件，并映射成控制流图，图4.3 所示。
 
-![image-20211201232307614](白盒测试.assets/image-20211201232307614-16383721926481.png)
+![image-20211201232307614](软件测试/image-20211201232307614-16383721926481.png)
 
 ### 环形复杂度
 
@@ -45,15 +45,15 @@
 ​		独立路径是指从程序入口到出口的多次执行中，每次至少有一个语句（包括运算、赋值、输入、输出或判断）是新的，未被重复的。如果用前面提到的控制流图来描述，独立路径就是在从入口进入控制流图后，至少要经历一条从未走过的弧。
 ​		因此，路径p6＝A、B、C、B、E、F、G，p7＝A、B、C、B、C、B、C、G不是独立路径。因为p6可以由路径pl、p2和p3组合而成，p7可由路径pl和p2组合而成。
 
-![image-20211201232450418](白盒测试.assets/image-20211201232450418.png)
+![image-20211201232450418](软件测试/image-20211201232450418.png)
 
-![image-20211201232455647](白盒测试.assets/image-20211201232455647.png)
+![image-20211201232455647](软件测试/image-20211201232455647.png)
 
 ### 图矩阵
 
 ​		图矩阵即流图的邻接矩阵表示形式，其阶数等于流图的节点数。矩阵中的每列和每行都对应于标识的某一节点，矩阵元素对应于节点之间的边。如图4.5 和图4.6所示，描述了一个简单的流图及其对应的矩阵。
 
-![image-20211201232521619](白盒测试.assets/image-20211201232521619.png)
+![image-20211201232521619](软件测试/image-20211201232521619.png)
 
 ## 逻辑覆盖
 
@@ -65,7 +65,7 @@
 
 ​		为了暴露程序中的错误，至少每个语句应该执行一次。语句覆盖的含义是，选择足够多的测试数据，使被测程序中每个语句至少执行一次。例如，图4.7所示的程序流程图描绘了一个被测试模块的处理算法。
 
-![image-20211201232718644](白盒测试.assets/image-20211201232718644.png)
+![image-20211201232718644](软件测试/image-20211201232718644.png)
 
 ​		为了使每个语句都执行一次，程序的执行路径应该是sacbed ，为此只需要输入下面的测试数据（实际上X可以是任意实数）：
 A = 2，B = 0，X = 4
@@ -160,21 +160,21 @@ A = 2，B = 0，X = 4
 
 
 
-![image-20211201233525287](白盒测试.assets/image-20211201233525287.png)
+![image-20211201233525287](软件测试/image-20211201233525287.png)
 
 ​		图4.8给出了类似于流程图的N-S图表示的基本控制结构（图中A、B、C、D、S均表示要执行的操作，P是可取真假值的谓词，Y表真值，N表假值）。其中图4.8（c）和图4.8（d）两种重复型结构代表了两种循环。在作了如上简化循环的假设以后，对于一般的程序控制流，我们只考虑选择型结构。事实上它已能体现顺序型和重复型结构了。
 
-![image-20211201233540283](白盒测试.assets/image-20211201233540283.png)
+![image-20211201233540283](软件测试/image-20211201233540283.png)
 
 ​		例如，图4.9表达了两个顺序执行的分支结构。两个分支谓词P1和P2取不同值时，将分别执行a或b及c或d操作。显然，要测试这个小程序，需要至少提供4个测试用例才能做到逻辑覆盖。使得ac、ad、bc及bd操作均得到检验。其实，这里的4是图中第1个分支谓词引出的两个操作，及第2个分支谓词引出的两个操作组合起来而得到的。
 
 
 
-![image-20211201233552055](白盒测试.assets/image-20211201233552055.png)
+![image-20211201233552055](软件测试/image-20211201233552055.png)
 
 ​		对于一般的、更为复杂的问题，估算最少测试用例数的原则也是同样的。现以图4.10表示的程序为例。该程序中共有9个分支谓词，尽管这些分支结构交错起来似乎十分复杂，很难一眼看出应至少需要多少个测试用例，但如果仍用上面的方法，也是很容易解决的。我们注意到该图可分上下两层：分支谓词1的操作域是上层，分支谓词8的操作域是下层。这两层正像前面简单例子中的P1和P2的关系一样。只要分别得到两层的测试用例个数，再将其相乘即得总的测试用例数。这里需要首先考虑较为复杂的上层结构。
 
-![image-20211201233608834](白盒测试.assets/image-20211201233608834.png)
+![image-20211201233608834](软件测试/image-20211201233608834.png)
 
 ​		谓词1不满足时要作的操作又可进一步分解为两层，这就是图4.11中的子图（a）和（b）。它们所需测试用例个数分别为1+1+1+1+1 = 5及1+1+1 = 3。因而两层组合，得到5×3 = 15。于是整个程序结构上层所需测试用例数为1+15 = 16。而下层显然为3。故最后得到整个程序所需测试用例数至少为6×3 = 48。
 
@@ -206,7 +206,7 @@ A = 2，B = 0，X = 4
 
 
 
-![image-20211201233822574](白盒测试.assets/image-20211201233822574.png)
+![image-20211201233822574](软件测试/image-20211201233822574.png)
 
 ​		循环测试是一种白盒测试技术，它专注于测试循环结构的有效性。在结构化的程序中通常只有3种循环，即简单循环、串接循环和嵌套循环，如图4.12所示。下面讨论这3种循环的测试方法。
 
@@ -281,7 +281,7 @@ A = 2，B = 0，X = 4
 
 
 
-![image-20211201234242354](白盒测试.assets/image-20211201234242354.png)
+![image-20211201234242354](软件测试/image-20211201234242354.png)
 
 ​		这里所说的对循环化简是指限制循环的次数。无论循环的形式和实际执行循环体的次数多少，我们只考虑循环一次和零次两种情况。即只考虑执行时进入循环体一次和跳过循环体这两种情况。图4.13中（a）和（b）表示了两种最典型的循环控制结构。前者先作判断，循环体B可能执行（假定只执行一次），也可能不执行。这就如同（c）所表示的条件选择结构一样。后者先执行循环体B（假定也执行一次），再经判断转出，其效果也与（c）中给出的条件选择结构只执行右支的效果一样。 
 
@@ -299,11 +299,11 @@ A = 2，B = 0，X = 4
 
 > 对图所示程序段进行语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、条件组合覆盖和路径覆盖方法进行测试用例设计。
 >
-> ![image-20211201234335330](白盒测试.assets/image-20211201234335330.png)
+> ![image-20211201234335330](软件测试/image-20211201234335330.png)
 
 
 
 > 对于下面N-S图，计算所需的最少测试用例数
 >
-> ![image-20211201234503930](白盒测试.assets/image-20211201234503930.png)
+> ![image-20211201234503930](软件测试/image-20211201234503930.png)
 

src/university/105.md

@@ -25,7 +25,7 @@ Selenium框架由多个工具组成，包括：Selenium IDE，Selenium RC，Sele
 
 Jason Huggins在2004年发起的 Selenium 项目，使用 JavaScript 编写的一个类库，这个 JavaScript 类库就是Selenium core，同时也是seleniumRC、Selenium IDE的核心组件。Selenium由此诞生。
 
-![image-20211202161830598](Selenium使用教程—Java.assets/image-20211202161830598.png)
+![image-20211202161830598](软件测试/image-20211202161830598.png)
 
 - **Selenium 2.0**
 
@@ -37,7 +37,7 @@ Jason Huggins在2004年发起的 Selenium 项目，使用 JavaScript 编写的
 
 所以，我们在学习Selenium2.0的时候，核心是学习WebDriver。它的工作原理是这样的：
 
-![image-20211202161915574](Selenium使用教程—Java.assets/image-20211202161915574.png)
+![image-20211202161915574](软件测试/image-20211202161915574.png)
 
 - **Selenium 3.0**
 
@@ -59,7 +59,7 @@ Jason Huggins在2004年发起的 Selenium 项目，使用 JavaScript 编写的
 - **出租车司机：**他按照乘客的要求来操控出租车。
 - **出租车：**出租车按照司机的操控完成真正的行驶，把乘客送到目的地。
 
-![image-20211202162100830](Selenium使用教程—Java.assets/image-20211202162100830.png)
+![image-20211202162100830](软件测试/image-20211202162100830.png)
 
 在WebDriver中也有类似的三个角色：
 
@@ -67,7 +67,7 @@ Jason Huggins在2004年发起的 Selenium 项目，使用 JavaScript 编写的
 - **浏览器的驱动**：它来解析这些自动化测试的代码，解析后把它们发送给浏览器
 - **浏览器**：执行浏览器驱动发来的指令，并最终完成工程师想要的操作。
 
-![image-20211202162129084](Selenium使用教程—Java.assets/image-20211202162129084.png)
+![image-20211202162129084](软件测试/image-20211202162129084.png)
 
 ## Selenium 环境搭建
 
@@ -727,11 +727,11 @@ public void switchWindow(String title){
 
 1.进入2345.com首页，点击头部【切换】进行城市切换，我们切换省份为北京。
 
-![image-20211202195927913](Selenium使用教程—Java.assets/image-20211202195927913.png)
+![image-20211202195927913](软件测试/image-20211202195927913.png)
 
 2.HTML页面DOM结构。
 
-![image-20211202200007592](Selenium使用教程—Java.assets/image-20211202200007592.png)
+![image-20211202200007592](软件测试/image-20211202200007592.png)
 
 3.代码编写，这里需要注意下拉选是在一个iframe中，需要先切换到这个iframe后再操作。
 
@@ -760,7 +760,7 @@ public void switchWindow(String title){
 
 **示例：12306 网站购票页面日期。**
 
-![image-20211202200027415](Selenium使用教程—Java.assets/image-20211202200027415.png)
+![image-20211202200027415](软件测试/image-20211202200027415.png)
 
 selenium 代码实现：
 

src/university/2.md

@@ -50,13 +50,13 @@
 
 Enterprise Java Beans Architecture
 
-![image-20211124100804135](建模.assets\image-20211124100804135.png)
+![image-20211124100804135](软件体系结构\image-20211124100804135.png)
 
 Microsoft .Net Framework Architecture
 
-![image-20211124100922322](建模.assets\image-20211124100922322.png)DC-LMP – Link Management Protocol Software用于光纤网物理介质连接器的软件
+![image-20211124100922322](软件体系结构\image-20211124100922322.png)DC-LMP – Link Management Protocol Software用于光纤网物理介质连接器的软件
 
-![image-20211124100946327](建模.assets\image-20211124100946327.png)
+![image-20211124100946327](软件体系结构\image-20211124100946327.png)
 
 ### UML
 
@@ -152,7 +152,7 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > 图例
 
-![image-20211124102114540](建模.assets\image-20211124102114540.png)
+![image-20211124102114540](软件体系结构\image-20211124102114540.png)
 
 ### 构件
 
@@ -298,7 +298,7 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > 4+1视图模型结构
 
-![image-20211124105113697](建模.assets\image-20211124105113697.png)
+![image-20211124105113697](软件体系结构\image-20211124105113697.png)
 
 #### 用例视图(Use Case View)
 
@@ -309,9 +309,9 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > UML图表示
 
-![image-20211124105521861](建模.assets\image-20211124105521861.png)
+![image-20211124105521861](软件体系结构\image-20211124105521861.png)
 
-![image-20211124144105800](建模.assets/image-20211124144105800.png)
+![image-20211124144105800](软件体系结构/image-20211124144105800.png)
 
 #### 逻辑视图(Logical View)
 
@@ -328,7 +328,7 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > UML图表示
 
-![image-20211124144128770](建模.assets/image-20211124144128770.png)
+![image-20211124144128770](软件体系结构/image-20211124144128770.png)
 
 #### 开发视图(Module View)
 
@@ -341,13 +341,13 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > UML图表示
 
-![image-20211124144235294](建模.assets/image-20211124144235294.png)
+![image-20211124144235294](软件体系结构/image-20211124144235294.png)
 
 
 
-![image-20211124144217788](建模.assets/image-20211124144217788.png)
+![image-20211124144217788](软件体系结构/image-20211124144217788.png)
 
-![image-20211124144250066](建模.assets/image-20211124144250066.png)
+![image-20211124144250066](软件体系结构/image-20211124144250066.png)
 
 #### 进程视图(Process View)
 
@@ -365,7 +365,7 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > UML图表示
 
-![image-20211124144407434](建模.assets/image-20211124144407434.png)
+![image-20211124144407434](软件体系结构/image-20211124144407434.png)
 
 #### 物理视图(Physical View)
 
@@ -380,9 +380,9 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > UML图表示
 
-![image-20211124144430510](建模.assets/image-20211124144430510.png)
+![image-20211124144430510](软件体系结构/image-20211124144430510.png)
 
-![image-20211124144437805](建模.assets/image-20211124144437805.png)
+![image-20211124144437805](软件体系结构/image-20211124144437805.png)
 
 #### 总结
 
@@ -403,7 +403,7 @@ Architecture = Components + Connectors + Topology + Constraints + Performance
 
 > 软件研发过程
 
-![image-20211124144455983](建模.assets/image-20211124144455983.png)
+![image-20211124144455983](软件体系结构/image-20211124144455983.png)
 
 > 软件体系结构的生命周期
 

src/university/3.md

@@ -6,7 +6,7 @@
 
 > 经典体系结构风格的分类
 
-![image-20211124121847033](风格.assets\image-20211124121847033.png)
+![image-20211124121847033](软件体系结构\image-20211124121847033.png)
 
 ## 数据流体系结构风格
 
@@ -14,7 +14,7 @@
 
 处理：**数据到达即被激活，无数据时不工作**
 
-![image-20211124122008414](风格.assets\image-20211124122008414.png)
+![image-20211124122008414](软件体系结构\image-20211124122008414.png)
 
 - **数据的可用性决定着处理(计算单元)是否执行**
 - **系统结构：数据在各处理之间的有序移动**
@@ -27,7 +27,7 @@
   - 从输入端口读取数据，向输出端口写入数据
   - 计算模型：从输入端口读数，经过计算/处理，然后写到输出端口
 
-![image-20211124122303131](风格.assets\image-20211124122303131.png)
+![image-20211124122303131](软件体系结构\image-20211124122303131.png)
 
 > 数据流风格的连接件(Connector)
 
@@ -36,11 +36,11 @@
   - 接口角色：reader和writer
   - 计算模型: 把数据从一个处理的输出端口传送到另一个处理的输入端口
 
-![image-20211124122452644](风格.assets\image-20211124122452644.png)
+![image-20211124122452644](软件体系结构\image-20211124122452644.png)
 
 > 数据流风格的拓扑结构(Topology)
 
-![image-20211124122526863](风格.assets\image-20211124122526863.png)
+![image-20211124122526863](软件体系结构\image-20211124122526863.png)
 
 > 三种典型的数据流风格
 
@@ -52,9 +52,9 @@
 
 ### 顺序批处理风格
 
-![image-20211124122910850](风格.assets\image-20211124122910850.png)
+![image-20211124122910850](软件体系结构\image-20211124122910850.png)
 
-![image-20211124122931219](风格.assets\image-20211124122931219.png)
+![image-20211124122931219](软件体系结构\image-20211124122931219.png)
 
 > 基本定义
 
@@ -80,11 +80,11 @@
 
 >批处理风格示例：重复代码检测工具
 
-![image-20211124123424235](风格.assets\image-20211124123424235.png)
+![image-20211124123424235](软件体系结构\image-20211124123424235.png)
 
 ### 管道与过滤器风格
 
-![image-20211124123517514](风格.assets\image-20211124123517514.png)
+![image-20211124123517514](软件体系结构\image-20211124123517514.png)
 
 > 基本定义
 
@@ -124,7 +124,7 @@
 - **递增的读取和消费数据流**
   - 数据到来时便被处理，不是收集然后处理，即在输入被完全消费之前，输出便产生了。
 
-![image-20211124124429298](风格.assets\image-20211124124429298.png)
+![image-20211124124429298](软件体系结构\image-20211124124429298.png)
 
 >过滤器的状态
 
@@ -154,7 +154,7 @@
 - 把任务分解成为一系列固定顺序的计算单元 
 - 彼此间只通过数据传递交互
 
-![image-20211124125017301](风格.assets\image-20211124125017301.png)
+![image-20211124125017301](软件体系结构\image-20211124125017301.png)
 
 > 不同点
 
@@ -188,7 +188,7 @@
 
 - 输出：音频数据传递给声卡，图像数据传递给显示器。
 
-![image-20211124125602466](风格.assets\image-20211124125602466.png)
+![image-20211124125602466](软件体系结构\image-20211124125602466.png)
 
 > 管道-过滤器风格的优点
 

src/university/4.md

@@ -7,7 +7,7 @@
 - 在层次系统中，系统被组织成若干个层次，每个层次由一系列构件组成
 - 下层构件向上层构件提供服务,上层构件被看作是下层构件的客户端
 
-![image-20211124144720587](层次体系结构.assets/image-20211124144720587.png)
+![image-20211124144720587](软件体系结构/image-20211124144720587.png)
 
 > 层次系统的基本组成
 
@@ -49,7 +49,7 @@
 
 > J2EE中层次体系结构
 
-![image-20211124145531444](层次体系结构.assets/image-20211124145531444.png)
+![image-20211124145531444](软件体系结构/image-20211124145531444.png)
 
 ## 分层模式的交互模式
 
@@ -86,27 +86,27 @@
 
 > DBMS中的“三级模式-两层映像”
 
-![image-20211124150837698](层次体系结构.assets/image-20211124150837698.png)
+![image-20211124150837698](软件体系结构/image-20211124150837698.png)
 
 > ISO/OSI网络的分层模型
 
-![image-20211124150916503](层次体系结构.assets/image-20211124150916503.png)
+![image-20211124150916503](软件体系结构/image-20211124150916503.png)
 
 > 计算机操作系统(OS)的层次结构
 
-![image-20211124151059669](层次体系结构.assets/image-20211124151059669.png)
+![image-20211124151059669](软件体系结构/image-20211124151059669.png)
 
 > C/S (Client/Server)
 
-![image-20211124151117808](层次体系结构.assets/image-20211124151117808.png)
+![image-20211124151117808](软件体系结构/image-20211124151117808.png)
 
 > B/S (Browser/Server)
 
-![image-20211124151224676](层次体系结构.assets/image-20211124151224676.png)
+![image-20211124151224676](软件体系结构/image-20211124151224676.png)
 
 > 信息系统的典型分层结构
 
-![image-20211124151333763](层次体系结构.assets/image-20211124151333763.png)
+![image-20211124151333763](软件体系结构/image-20211124151333763.png)
 
 ## 分层系统设计的过程
 

src/university/5.md

@@ -18,7 +18,7 @@
   - C/S降低了网络通讯量：提供请求/应答模式，而非文件传输
   - 多用户通过GUI访问共享数据库
 
-![image-20211124162422729](CS和BS体系结构.assets/image-20211124162422729.png)
+![image-20211124162422729](软件体系结构/image-20211124162422729.png)
 
 - 客户机/服务器：一个应用系统被分为两个逻辑上分离的部分，每一部分充当不同的角色、完成不同的功能，多台计算机共同完成统一的任务。
   - 客户机(前端，front-end)：业务逻辑、与服务器通讯的接口；
@@ -31,7 +31,7 @@
   - 三层C/S
   - 多层C/S
 
-![image-20211124162719095](CS和BS体系结构.assets/image-20211124162719095.png)
+![image-20211124162719095](软件体系结构/image-20211124162719095.png)
 
 - 在三层和多层C/S中，**每两层之间形成C/S关系；**
   - 例如，在三层C/S中，应用服务器既可以看作是客户机的“服务器”，同时也是数据库服务器的“客户机”；

src/university/6.md

@@ -1,13 +1,13 @@
 ## 事件系统风格(独立构件)
 
-![image-20211125191009114](其它体系结构.assets/image-20211125191009114.png)
+![image-20211125191009114](软件体系结构/image-20211125191009114.png)
 
 > 定义
 
 - 能够激活对象功能的动作。当发生这种动作后将给所涉及对象发送一个消息,对象便可执行相应的功能
 - 对某一对象发生什么事件，该对象便找到相应的处理该事件的程序去处理这一事件
 
-![image-20211125185917327](其它体系结构.assets/image-20211125185917327.png)
+![image-20211125185917327](软件体系结构/image-20211125185917327.png)
 
 > 事件的隐式调用
 
@@ -23,7 +23,7 @@
 
 > 基本构成和工作原理
 
-![image-20211125190410320](其它体系结构.assets/image-20211125190410320.png)
+![image-20211125190410320](软件体系结构/image-20211125190410320.png)
 
 | 特点             | 描述                                                    |
 | ---------------- | ------------------------------------------------------- |
@@ -36,7 +36,7 @@
 
 遇到断点，编辑器将源代码滚动到断点处，变量监测器则更新当前变量值并显示出来。
 
-![image-20211125190730334](其它体系结构.assets/image-20211125190730334.png)
+![image-20211125190730334](软件体系结构/image-20211125190730334.png)
 
 > 事件系统的优缺点
 
@@ -53,7 +53,7 @@
 
 ## 仓库风格
 
-![image-20211125191101728](其它体系结构.assets/image-20211125191101728.png)
+![image-20211125191101728](软件体系结构/image-20211125191101728.png)
 
 > 定义
 
@@ -61,7 +61,7 @@
 
 在这种风格中，**数据仓库（如文件或数据库）位于这种体系结构的中心，**其他构件会经常访问该数据仓库，并对仓库中的数据进行增加、修改或删除操作。
 
-![image-20211125191219430](其它体系结构.assets/image-20211125191219430.png)
+![image-20211125191219430](软件体系结构/image-20211125191219430.png)
 
 > 仓库风格实例
 
@@ -71,7 +71,7 @@
 - 这些文件散落在系统的各个角落，很难对其进行维护;
 - 为此，引入注册表，其思想是将所有.ini文件集中起来,形成共享仓库,为系统运行趣起到了集中的资源配置管理和控制调度的作用
 
-![image-20211125191453040](其它体系结构.assets/image-20211125191453040.png)
+![image-20211125191453040](软件体系结构/image-20211125191453040.png)
 
 剪贴板
 
@@ -92,9 +92,9 @@
 - 黑板体系结构是仓库体系结构的特殊化。黑板体系结构模型通常由知识源、黑板数据结构和控制器三部分构成。
 - 黑板风格是人工智能应用系统的重要设计方法之一。
 
-![image-20211125191916042](其它体系结构.assets/image-20211125191916042.png)
+![image-20211125191916042](软件体系结构/image-20211125191916042.png)
 
-![image-20211125191922457](其它体系结构.assets/image-20211125191922457.png)
+![image-20211125191922457](软件体系结构/image-20211125191922457.png)
 
 > 知识源
 

src/university/7.md

@@ -46,7 +46,7 @@
 
 **SOA=Service(服务)+体系结构(Architecture)**
 
-![image-20211124172500395](面向服务的体系结构.assets/image-20211124172500395.png)
+![image-20211124172500395](软件体系结构/image-20211124172500395.png)
 
 > SOA的核心要素
 
@@ -65,7 +65,7 @@ SOA通过三个途径来达到灵活性：
 
 - 软件**复用**，即软件的重用，也叫再用，是指同一事物不作修改或稍加改动就多次重复使用。从软件复用技术的发展来看，就是不断提升抽象级别，扩大复用范围。
 
-![image-20211124172753984](面向服务的体系结构.assets/image-20211124172753984.png)
+![image-20211124172753984](软件体系结构/image-20211124172753984.png)
 
 > 耦合关系
 
@@ -73,7 +73,7 @@ SOA通过三个途径来达到灵活性：
 - **分布式对象技术将连接逻辑进行分离**，消息中间件将连接逻辑进行异步处理，增加了更大的灵活性。消息代理和一些分布式对象中间件将数据转换也进行了分离。
 - 而**SOA架构**，通过服务的封装，实现了业务逻辑与网络连接、数据转换等进行完全的解耦。
 
-![image-20211124172820419](面向服务的体系结构.assets/image-20211124172820419.png)
+![image-20211124172820419](软件体系结构/image-20211124172820419.png)
 
 ## SOA的基本构件和连接件
 
@@ -92,15 +92,15 @@ SOA通过三个途径来达到灵活性：
 
 > 分布式异构系统的集成与互操作
 
-![image-20211124173623513](面向服务的体系结构.assets/image-20211124173623513.png)
+![image-20211124173623513](软件体系结构/image-20211124173623513.png)
 
 
 
-![image-20211124173642611](面向服务的体系结构.assets/image-20211124173642611.png)
+![image-20211124173642611](软件体系结构/image-20211124173642611.png)
 
 
 
-![image-20211124173704681](面向服务的体系结构.assets/image-20211124173704681.png)
+![image-20211124173704681](软件体系结构/image-20211124173704681.png)
 
 虽然目前已经存在成熟的远程方法调用机制以实现异构系统的集成与互操作，**但在Internet这样的分布式环境下，SOA才能实现这一目标。**
 
@@ -158,7 +158,7 @@ SOA通过三个途径来达到灵活性：
 - 服务提供商使用公共（或私有）的注册表（服务器）注册其业务服务（服务描述）。注册表中包含服务提供商提供的服务信息 
 - 客户可使用各种平台或设备（手机、电脑、各种终端、家电设备等），通过Internet或其他网络途径查找服务注册表来找到相应的Web服务，然后调用该服务的功能 
 
-![image-20211124200957259](面向服务的体系结构.assets/image-20211124200957259.png)
+![image-20211124200957259](软件体系结构/image-20211124200957259.png)
 
 > Web Services的特点
 
@@ -179,7 +179,7 @@ SOA通过三个途径来达到灵活性：
 - 服务注册中心（Service Registry）
   - 对于静态绑定的服务请求者，服务注册中心是体系结构中的可选角色
 
-![image-20211124201225578](面向服务的体系结构.assets/image-20211124201225578.png)
+![image-20211124201225578](软件体系结构/image-20211124201225578.png)
 
 **角色之间的三个操作 ：**
 
@@ -200,11 +200,11 @@ SOA通过三个途径来达到灵活性：
 
 - Web Services支持一种标准的协议栈模型，以支持发布、发现和绑定的互操作。
 
-![image-20211124201631391](面向服务的体系结构.assets/image-20211124201631391.png)
+![image-20211124201631391](软件体系结构/image-20211124201631391.png)
 
 - 最简单的协议栈包括传输层的HTTP，基于XML的消息传递层的SOAP协议以及服务描述层的WSDL ： 
 
-![image-20211124201649067](面向服务的体系结构.assets/image-20211124201649067.png)
+![image-20211124201649067](软件体系结构/image-20211124201649067.png)
 
 - **Web Services体系结构的基础是XML消息传递，XML消息传递的行业标准是SOAP。**SOAP是一种简单的、轻量级的基于XML的机制，用于在网络应用程序之间进行结构化数据交换，它包括三部分：
   - 一个定义描述消息内容的框架的信封
@@ -239,7 +239,7 @@ SOA通过三个途径来达到灵活性：
 - 一个ESB是一个预先组装的SOA实现，它包含了实现SOA分层目标所必需的基础功能部件。
 - ESB是传统中间件技术与XML、Web服务等技术相互结合的产物，用于实现企业应用不同消息和信息的准确、高效和安全传递。
 
-![image-20211124202427148](面向服务的体系结构.assets/image-20211124202427148.png)
+![image-20211124202427148](软件体系结构/image-20211124202427148.png)
 
 > 企业服务总线的功能
 

src/university/8.md

@@ -13,11 +13,11 @@
 - 动态协作 
   - 参与协作的应用允许**位置透明性、迁移透明性、负载平衡性等需求。**
 
-![image-20211124202944204](中间件与框架.assets/image-20211124202944204.png)
+![image-20211124202944204](软件体系结构/image-20211124202944204.png)
 
 
 
-![image-20211124202953926](中间件与框架.assets/image-20211124202953926.png)
+![image-20211124202953926](软件体系结构/image-20211124202953926.png)
 
 > 已经接触了许多的中间件
 
@@ -36,7 +36,7 @@
 - **(ObjectWeb)中间件**：分布式计算环境中一种处于操作系统和应用系统之间的软件层
 - **(Wikipedia) 中间件**：一种软件，用来连接不同的软构件或应用系统
 
-![image-20211124203326252](中间件与框架.assets/image-20211124203326252.png)
+![image-20211124203326252](软件体系结构/image-20211124203326252.png)
 
 > 中间件的理解
 
@@ -74,7 +74,7 @@
   - 远程系统上的程序逻辑可以简单的看作本地函数而加以执行
   - 可能是异步/同步
 
-![image-20211124203831857](中间件与框架.assets/image-20211124203831857.png)
+![image-20211124203831857](软件体系结构/image-20211124203831857.png)
 
 ### MOM
 
@@ -82,11 +82,11 @@
 
 
 
-![image-20211124204024836](中间件与框架.assets/image-20211124204024836.png)
+![image-20211124204024836](软件体系结构/image-20211124204024836.png)
 
 
 
-![image-20211124204032053](中间件与框架.assets/image-20211124204032053.png)
+![image-20211124204032053](软件体系结构/image-20211124204032053.png)
 
 ### ORB
 
@@ -105,7 +105,7 @@
   - (分布式)组件对象模型
   - 支持Windows 平台
 
-![image-20211124204402692](中间件与框架.assets/image-20211124204402692.png)
+![image-20211124204402692](软件体系结构/image-20211124204402692.png)
 
 ### SQL
 
@@ -117,14 +117,14 @@
   - Java Data Base Connectivity
   - Java数据库互连
 
-![image-20211124204529573](中间件与框架.assets/image-20211124204529573.png)
+![image-20211124204529573](软件体系结构/image-20211124204529573.png)
 
 ### TP Monitor
 
 - Transaction processing (TP) monitors (**事务处理监控器**)
   - 负责控制事务性应用系统以事务的方式执行业务逻辑或数据更新
 
-![image-20211124204625635](中间件与框架.assets/image-20211124204625635.png)
+![image-20211124204625635](软件体系结构/image-20211124204625635.png)
 
 ### 应用服务器和企业服务总线
 
@@ -150,7 +150,7 @@
 
 > 三层C/S结构中的应用服务器
 
-![image-20211124204920308](中间件与框架.assets/image-20211124204920308.png)
+![image-20211124204920308](软件体系结构/image-20211124204920308.png)
 
 
 
@@ -166,7 +166,7 @@
 - 基本功能：作为3层C/S或B/S结构中的功能性中间件层
   - 负责驻留应用程序业务逻辑
 
-![image-20211124205108347](中间件与框架.assets/image-20211124205108347.png)
+![image-20211124205108347](软件体系结构/image-20211124205108347.png)
 
 - **其他功能：作为复杂应用系统中的非功能性中间件——提供系统运行时的性能保障**
   - Data and code integrity (数据和代码的完整性) 
@@ -187,7 +187,7 @@
 - **框架(Framework)**：可实例化的、部分完成的软件系统或子系统，它为一组系统或子系统定义了统一的**体系结构(architecture)**，并提供了构造系统的基本构造块(building blocks)，还为实现具体功能定义了扩展点(extending points)。
 - 框架实现了体系结构级别的复用。 
 
-![image-20211124205315182](中间件与框架.assets/image-20211124205315182.png)
+![image-20211124205315182](软件体系结构/image-20211124205315182.png)
 
 ### Struts：J2EE MVC Model 2的一种典型实现
 
@@ -248,7 +248,7 @@
 - 开发J2EE程序的时候，无需考虑后台的关系数据存储，Hibernate通过配置完成Java class与JDBC之间的连接。
 - Hibernate通过基于XML的配置文件来定义映射关系：
 
-![image-20211124210214190](中间件与框架.assets/image-20211124210214190.png)
+![image-20211124210214190](软件体系结构/image-20211124210214190.png)
 
 ## 讨论题