Mathematical Problems in Engineering
Volume 2018 (2018), Article ID 6982821, 10 pages
https://doi.org/10.1155/2018/6982821

Research Article

Source Codes Oriented Software Trustworthiness Measure Based on Validation

Hongwei Tao¹ and Jie Zhao²

¹College of Computer and Communication Engineering, Zhengzhou University of Light Industry, Zhengzhou, China
²College of Energy and Power Engineering, Zhengzhou University of Light Industry, Zhengzhou, China

Correspondence should be addressed to Hongwei Tao; tthhww_811@163.com

Received 11 June 2018; Revised 29 August 2018; Accepted 6 November 2018; Published 19 November 2018

Academic Editor: Ioannis T. Christou

Copyright © 2018 Hongwei Tao and Jie Zhao. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Abstract.

Validation is critical to the success of software trustworthiness measurement. A large number of software trustworthiness measures are proposed; however, most of them are not validated from a theory perspective. Therefore, they lack theoretical foundation and will induce unnecessary cost and useless calculation. In this paper, we bring measurement theory into software trustworthiness measurement, construct a source codes oriented software trustworthiness measure based on extensive structure in the measurement theory, and validate the developed measure by use of axiomatic approaches. Compared with some software trustworthiness measures that are already presented, this measure can evaluate software trustworthiness better from a theory perspective.

1. Introduction

Because of the outstanding problems with software trustworthiness, people pay more and more attention to the research into trustworthy software. One of the core scientific problems in this research is the software trustworthiness measurement [1]. However, few research works carry out theoretical validation for their measures. It is important that the measures we use are valid. That is, measures must measure what they are supposed to measure. Theoretical validation is a required activity for using or defining measures that make sense and is a necessary step for the empirical validation of measures [2]. On the other side, many researches do not present the methods to translate the measure results back to the empirical world. Then it is difficult to use the measure results to provide guidance for the improvement of software trustworthiness. Meanwhile, most researchers in software trustworthiness measurement area do not address scale types. Scale types are very important for meaningful statistical operations. Because many empirical and numerical conditions are not covered by a certain scale type, for example, comparisons of arithmetic means are not a meaningful statistic [3, 4].

There are two main approaches in theoretical validation and they are measurement theory and axiomatic approaches [5, 6]. In measurement theory, the empirical understanding of an attribute is formalized through the definition of an empirical relational system and a numerical relational system is defined to provide measure values for that attribute and relations among these values [7]. Measurement theory presents a clear definition of a measure under the assumption of a homomorphism from the empirical world into the numerical world and gives the conditions for the use of measures on certain scale levels. The major advantage of measurement theory is the representational condition, which attests that the properties of the attributes in the empirical world should be preserved by the measures in the numerical world and vice versa. Part of the empirical understanding of a software attribute may be formally defined as desirable properties of the measures for that attribute. Axiomatic approaches are used with a number of properties for theoretical validation [8, 9]. A property is a condition or a basic assumption of reality. The measure’s properties in axiomatic approaches must be seen as properties that characterize the numerical world. However, they indirectly affect the empirical world. Therefore, properties in axiomatic approaches can be used as guidelines for the definition of a measure.

Software trustworthiness measures based on measurement theory and axiomatic approaches are appropriate methods to deal with problems, like theoretical validation of measures, measurement scales, the empirical interpretation of numerical results, and properties of measures. However, measurement theory and axiomatic approaches are mostly applied to measure internal attributes such as size, complexity, and cohesion or used to validate the software internal attributes measures from theory [2, 9–13]. The fundamental problem of the application of measurement theory or axiomatic approaches in software external attributes measurement is that, for many software external attributes, it is not known what the empirical relational system looks like. In order to make software trustworthiness measurement more rigorous, we used axiomatic approaches to measure software trustworthiness and presented some desirable properties of the measures for software trustworthiness in the view of trustworthy attributes [8], including monotonicity, acceleration, sensitivity, and substitutivity. In this paper, we construct a source codes oriented software trustworthiness measure based on extensive structure in the measurement theory, present four desirable properties of the measures for software trustworthiness from the standpoint of module, and carry out theoretical validation for the developed measure by use of axiomatic approaches.

The rest of this paper is organized as follows. In Section 2 we review some related works. We describe some basic definitions and notations from measurement theory and present extensive structure based software trustworthiness measures in Section 3. In Section 4 we introduce four desirable properties of software trustworthiness measures from the standpoint of module and validate the nonadditive software trustworthiness measure based on extensive structure established in Section 3 by use of axiomatic approaches. The measurement procedure based on the measures built in Section 3 is presented in Section 5. We make a case study in Section 6. Section 7 contains the comparative study. The conclusion and future work come in the last section.

2. Related Works

There are three kinds of software trustworthiness measurements: attribute-based software trustworthiness measurement, behavior-based software trustworthiness measurement, and process-based software trustworthiness measurement [14].

The general framework for the attribute-based software trustworthiness measurement is as follows. The attributes that affect software trustworthiness are firstly selected. Then, measurement models are built to measure these selected attributes. Finally, models and methods are presented to measure software trustworthiness based on measurement results of the selected attributes. Typical models and methods include axiomatic approaches [8, 15–20], fuzzy comprehensive evaluation method [21, 22], rough set theory [23], Bayesian Networks [24–26], evidence theory [27, 28], weakness analysis [29], questionnaire survey and statistical analysis [30–33], and dynamic system [34–36].

The software normal behavior model is firstly built under trustworthy environment in the behavior-based software trustworthiness measurement. Then, the software actual behavior is extracted based on the monitored actual operating statuses of the software at the checkpoint. Finally, the actual behavior is compared with the normal behavior to evaluate software trustworthiness. Typical comparison methods include program slicing [37, 38], data mining [39, 40], and concurrency theory [41–46].

Process-based software trustworthiness measurement uses the collected data describing the behaviors and attributes of the process as evidence to measure software trustworthiness. Classic methods contain Trusted Software Methodology [47, 48], Trustworthy Process Management Framework [49, 50], and so on.

3. Software Trustworthiness Measure Based on Extensive Structure

We first present some basic concepts from measurement theory.

Definition 1 (empirical relational system [7]). Given an attribute, an empirical relational system is an ordered tuple , where

(1)E denotes a nonempty set of empirical objects for which we want to measure the attribute;(2) are -ary empirical relations on capturing our intuitive knowledge on the attribute;(3) are empirical binary operations on , i.e., .

The empirical relational system is used to model our empirical understanding of the objects’ attributes that we want to measure.

Definition 2 (numerical relational system [7]). Given an attribute, a numerical relational system is an ordered tuple , where

(1) is the set of values that we use to measure the attribute;(2) denote -ary relations on ;(3) denote numerical binary operations on , i.e., .

The numerical relational system is purposefully defined to mirror the empirical relational system in the realm of values. The link between the empirical relational system and the numerical relational system is made via measure.

Definition 3 (measure [7]). A function is said to be a measure.

However, with the exception of empirical objects, the empirical relational system also presents information about our empirical understanding of an attribute of a set of empirical objects. If this information is not considered, any function that maps into is a measure according to Definition 3. In order to discard all of those measures that are at variance with our intuition, measurement theory introduces the definition of scale.

Definition 4 (scale [7]). Let be an empirical relational system, be a numerical relational system, and be a measure. The triple is a scale if and only if for all and for , the following holds:

Extensive structure is one of the most important measurement structures. It is essential in physics and is very important in the area of software measurement too. They are not brought into software external attributes measurement and software trustworthiness measurement. The reason is that it is difficult to build the extensive structure about software external attributes or software trustworthiness. The following is the definition of extensive structure.

Definition 5 (extensive structure [7]). Let be a nonempty set, a binary relation on , and a closed binary operation on . The empirical relational system is an extensive structure if the following axioms are satisfied:

(1)Weak order: is a weak order; i.e., it satisfies transitivity and strong completeness.(2)Weak associativity: (3)Monotonicity: (4)Archimedean: : if , then for any there exists a natural number n, such that .

One has

The most practical use of measurement is the representation theorem of extensive structure.

Theorem 6 (representation theorem of extensive structure [7]). Suppose is a nonempty set, a binary relation on , a closed binary operation on , and the set of all real numbers. Then there is a real-valued function satisfying

if and only if is an extensive structure. If another function fulfills these properties, then there exists a positive real value that

holds.

In order to apply extensive structure in software trustworthiness measurement, the first step is to define an empirical relational system about software trustworthiness. Therefore, the software entity must be represented in one way or another. In this paper, we use the software abstraction presented in [12] and define software as a system. However, we modify the definition of module given in [12].

Definition 7 (system [12]). A system is represented as a pair , where is the set of elements of and represents a binary relation on expressing the relationships between ’s elements.

Definition 8 (module). For a given system , a module is a system such that

As an example, can be defined as the set of code statements and as the set of data flows from one statement to another. A module may be a code segment or a subprogram.

Given a system , let be the set of all the modules in . Then is the set that are to be measured. Suppose , and let

Then, we define the binary operation on as

where is a multiset composed of the elements in and . From the definition of module, we know that .

Now we need to define the empirical ordering : equally or more trustworthy than. Software trustworthiness is the ability of software to satisfy user expectation with its behaviors and results. Both the software behaviors and the results are decided by the implementations of software. Then the software trustworthiness can be obtained by computing the quantification of the conformance of the implementations adopted by software with the implementations expected by users. The implementations expected by users are referenced as the properties and functions that the program elements and program unit should carry if a program is trustworthy; for example, a variable should be initialized before used [51]. Moreover, software is composed of the modules through some relations and the module is the collection of program elements. So we let be determined by the following observation criterion: If , then is observed if and only if when the ratio of the number of program elements with the implementations expected by users in to the number of program elements in is greater or equal than the ratio of the number of program elements with the implementations expected by users in to the number of program elements in .

Claim 1. is an extensive structure.

Proof. Transitivity: let , . Suppose the ratios of the number of program elements with the implementations expected by users in to the number of program elements in are , and , respectively.
Then, from the definition of , we know that implies and implies . As the relation is transitive for real numbers, then it holds that , leading to the observation that .
Strong completeness: since any pair of real numbers can be compared using , then strong completeness is shown by the definition of .
From and , we can get is a weak order.
Weak associativity: because

therefore

Similarly, since

then

Notice that associativity is satisfied by , therefore

(4) Monotonicity: we first prove that ,
The number of program elements with the implementations expected by users in is the sum of the number of program elements with the implementations expected by users in and that in . Because implies the number of program elements with the implementations expected by users in is equal or more than the number of program elements with the implementations expected by users in , therefore, the number of program elements with the implementations expected by users in is equal or more than the number of program elements with the implementations expected by users in ; then it follows that

Likewise, if , we can deserve that .
In a similar way, we can prove that
(5) Archimedean: since satisfies monotonicity, then it is easy to get that Archimedean holds for .
In summary, is an extensive structure.

Definition 9 (an additive module trustworthiness measure based on extensive structure). For a given software system , let be the set of all the modules in and be the set of all positive real number. Suppose . Denote the number of program elements with the implementations expected by users in by and the number of program elements in by . Then, the additive module trustworthiness measure based on extensive structure is defined as , where

According to the representation theorem of extensive structure and the definition of , it is easy to obtain the following result.

Claim 2. (1) assumes the extensive structure .
(2) For ,

i.e., is an additive homomorphism from to .

Definition 10 (a nonadditive module trustworthiness measure based on extensive structure). For a given software system , let be the set of all the modules in and be the set of all positive real numbers. Suppose , , . Then, the nonadditive module trustworthiness measure based on extensive structure is defined as , where

Claim 3. (1) assumes the extensive structure , and for ,

i.e., is a nonadditive homomorphism from to .
(2) can be used as a ratio scale.

Proof. Let Because

then

and

From Claim 2, we know that

Then we can get

Because , therefore is a nonadditive measure and can be modified to the additive measure by a strictly monotonic function. From the result in [18], it follows that assumes the extensive structure too.
(2) Noticing that

it follows that can be used as a ratio scale.
To sum up, the conclusion can be verified.

In the following, on the basis of the module trustworthiness measures described in Definitions 9 and 10, we present an additive software trustworthiness measure based on extensive structure and a nonadditive software trustworthiness measure based on extensive structure. For a given software system , let be a collection of modules of such that

and

i.e, the set of elements of is partitioned into the sets of elements of the modules in . Suppose the number of the module in is and denote them by separately.

Definition 11 (an additive software trustworthiness measure based on extensive structure). For a given software system , an additive software trustworthiness measure based on extensive structure is defined as

Definition 12 (a nonadditive software trustworthiness measure based on extensive structure). For a given software system , a nonadditive software trustworthiness measure based on extensive structure is defined as

4. Numerical Relational System Based on Axiomatic Approaches

There may be many nonadditive software trustworthiness measures that assume the extensive structure and can be used as a ratio scale. Now the problem is how to prove is a proper software trustworthiness measure. Axiomatic approaches have already been used to check if the existing measures comply with a specific set of properties for the attribute that they purport to measure. We once used axiomatic approaches to measure software trustworthiness and presented some desirable properties of software trustworthiness measures from the standpoint of trustworthy attributes [8]. Consulting the properties given in [8], in this section we give four desirable properties of software trustworthiness measures in the view of module and prove that complies with these four properties.

For generality, let

where

(i): a parameter related to the substitutivity between module trustworthiness(ii): the module trustworthiness obtained through with

The desirable properties of software trustworthiness measures in the view of module are depicted below.

(1) Monotonicity

where . It means that the increment of a module trustworthiness leads to software trustworthiness increase.

(2) Acceleration

where . It states that the increase of the module trustworthiness leads to their utilization efficiency to decrease.

(3) Sensitivity

Sensitivity is used to describe the percentage changes of software trustworthiness caused by the percentage changes of module trustworthiness. They should be positive.

(4) Substitutivity

where

are used to express the difficulty of the substitution between module trustworthiness. Substitutivity implies that the module trustworthiness can substitute each other to some extent.

Claim 4. Monotonicity holds for .

Proof. From the definition of , we know that is a continuously differentiable function. By solving the partial derivatives of with respect to , we can obtain

Since Then

Therefore, the conclusion can be verified.

Claim 5. satisfies the acceleration.

Proof. By computing the second order partial derivatives of with respect to , we get that

Because and , therefore

Then we can obtain the conclusion that the acceleration is satisfied by .

Claim 6. Sensitivity is satisfied by .

Proof. For , by calculating it is easy to get that

Due to , then

In summary, is sensitive to module trustworthiness.

Claim 7. complies with substitutivity.

Proof. Since is a continuously differentiable function, and

Then, for , we can get

According to (33), it follows that

Since Then substitutivity holds for .

5. The Measurement Procedure Based on the Measures Established in Section 3

The measures given in this paper are used to measure source codes trustworthiness in the software implementation phase, and the source codes can be written in an imperative language or in an object-oriented language. We have presented specifications for the implementations expected by users of the program elements involved in the imperative languages [51]; if you want to use the measures built in this paper to measure the trustworthiness of source codes written in an object-oriented language, you need to propose the specifications for the implementations expected by users of the program elements involved in the corresponding object-oriented language.

The measurement procedure based on the proposed measures in Section 3 consists of four steps as shown in Figure 1. For a given software system , we first find a partition of , where is the set of all modules in . Then, for , we compute according to Definition 9 in Step 2. For , based on the results of computation of , are calculated according to Definition 10 in Step 3. In the final step, on the basis of the results of Step 3, the software trustworthiness is obtained by utilizing Definition 12.

Figure 1: The measurement procedure based on the measures established in Section 3.

6. Case Study

To demonstrate the effectiveness of our measure, we apply to measure the trustworthiness of quick sort program written in the C language in Algorithm 1. For simplicity, we just consider the program element: variable. Here we use the trustworthy properties of variable given in [51] as variables’ implementations expected by users. Let , where

(i) is composed of the variables in line -, i.e., (ii) consists of the variables in line -, i.e., (iii) is made up of the variables in line -, i.e.,

#include stdio.h

int Partition(int R,int i,int j)

int pivot=R;

while(i<j)

while(i<j&&R[j]>=pivot)

j--;

if(i<j)

R[i++]=R;

while(i<j&&R[i]<=pivot)

i++;

if(i<j)

R[j- -]=R[i];

R=pivot;

return i;

void QuickSort(int R,int low,int high)

int pivotpos;

if(low<high)

pivotpos=Partition(R,low,high);

QuickSort(R,low,pivotpos-1);

QuickSort(R,pivotpos+1,high);

//QuickSort

int main()

int s;

printf(input 10 number);

for(int i=0;i<10;i++)

scanf(%d,&s);

QuickSort(s,0,9);

for (int j=0;j<10;j++)

printf(%d ,s);

Algorithm 1: Quick sort program written in the C language.

Then . From the trustworthy properties of variable described in [51], we know that do not have one and only one purpose, the same identifiers are still used in main function, and then they are not expected by users. Moreover, and do not have meaningful names; therefore, they are not expected by users. So, we can get , , and . It follows that , , and .

Suppose ; then , , , and

7. Comparative Study in Terms of Measurement Theory and the Properties Given in Section 4

In this section, we compare with the decomposition of trustworthy attributes based software trustworthiness measure (DTABSTM) [16], axiomatic approaches based software trustworthiness measure (AABSTM) [17], fuzzy theory based software trustworthiness measure (FTBSTM) [22], and evidence theory based software trustworthiness measure (ERBSTM) [28] through the measurement theory and the properties presented in Section 4. The comparative results are given in Table 1, where represents that the measure holds for corresponding property and expresses that the measure does not comply with the corresponding property. DTABSTM, AABSTM, ERBSTM, and FTBSTM do not build measurement structures in the measurement theory; therefore they do not comply with measurement theory. References [16, 17] have proved that monotonicity, acceleration, sensitivity, and substitutivity hold for DTABSTM and AABSTM separately. ERBSTM and FTBSTM do not satisfy acceleration and substitutivity. The reason is that both of them do not consider the efficiency of using attributes and the quantitative relations between trustworthy attributes, while correlations between trustworthy attributes are the cause that trustworthy attributes can substitute each other to some extent. From Table 1, we can get that is better than all the four measures in terms of measurement theory and the properties introduced in Section 4.

Table 1: Comparative study in terms of measurement theory and the properties given in Section 4.

Property
T
DTABSTM
AABSTM
FTBSTM
ERBSTM

Measurement theory

Monotonicity

Acceleration

Sensitivity

Substitutivity

8. Conclusion and Future Work

In this paper, we apply measurement theory to measure the source codes trustworthiness, present an extensive structure based software trustworthiness measure , and validate with axiomatic approaches from a theory perspective. Compared with some popular software trustworthiness measures, the measure can evaluate software trustworthiness better in terms of measurement theory and the properties described in Section 4.

However, only a small case is given to demonstrate the effectiveness of , in order to support ’s practical usefulness, we will experiment using the real cases and develop a tool based on . The specifications for the implementations expected by users of the program elements involved in the imperative languages that are given by us in [51] are not complete, and the specifications are only suitable for imperative languages. In the future, we will expand the specifications proposed in [51] and establish specifications for the implementations expected by users of the program elements involved in the object-oriented languages. We do not give methods for computing the values of and ; how to determine the values of and is an important future work. The set of properties presented in Section 4 should be considered sets of necessary properties that need to be satisfied by a software trustworthiness measure. It is possible that some important properties are omitted due to oversight; extending and refining the set of properties are the future works too.

Data Availability

The data used to support the findings of this study are available from the corresponding author upon request.

Disclosure

A preliminary version of this work was presented at the 2016 International Symposium on System and Software Reliability (ISSSR2016) [Research of Software Trustworthiness Measure Based on Validation [52]].

Conflicts of Interest

The authors declare that they have no conflicts of interest.

Acknowledgments

This work is supported by the Innovation Group Project of National Natural Science Foundation (61321064), National Key R&D Plan Inter-Governmental R&T Cooperation Subproject (2016YFE0100600, 2016YFE0100300), National Natural Science Foundation of China (61370100), Doctoral Research Fund of Zhengzhou University of Light Industry (13501050045), and Science and Technology Project of Henan Province (182102210617).

References

K. Liu, Z. Shan, J. Wang, J. He, Z. Zhang, and Y. Qin, “Overview On Major Research Plan of Trustworthy Software,” Bulletin of National Natural Science Foundation of China, vol. 22, no. 3, pp. 145–151, 2008.

S. Morasca, “Fundamental aspects of software measurement,” Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics): Preface, vol. 7171, pp. 1–45, 2013.

L. Briand, K. El Emam, and S. Morasca, “On the application of measurement theory in software engineering,” Empirical Software Engineering, vol. 1, no. 1, pp. 61–88, 1996.

H. Zuse, A Framework for Software Measurement, Walter de Gruyter, Berlin, Germany, 1998.

A. Meneely, B. Smith, and L. Williams, “Validating software metrics: A spectrum of philosophies,” ACM Transactions on Software Engineering and Methodology, vol. 21, no. 4, 2012.

K. Srinivasan and T. Devi, “Software Metrics Validation Methodologies in Software Engineering,” International Journal of Software Engineering & Applications, vol. 5, no. 6, pp. 87–102, 2014.

D. Krantz, R. Luce, P. Suppes, and A. Tversky, “Foundations of Measurement,” in Additive and Polynomial Representations, vol. 1, Academic Press, London, UK, 1971.

H. Tao and Y. Chen, “A metric model for trustworthiness of softwares,” in Proceedings of the 2009 IEEE/WIC/ACM International Conference on Web Intelligence and Intelligent Agent Technology - Workshops, WI-IAT Workshops 2009, pp. 69–72, September 2009.

G. Poels and G. Dedene, “Distance-based software measurement: Necessary and sufficient properties for software measures,” Information and Software Technology, vol. 42, no. 1, pp. 35–46, 2000.

E. J. Weyuker, “Evaluating software complexity measures,” Institute of Electrical and Electronics Engineers. Transactions on Software Engineering, vol. 14, no. 9, pp. 1357–1365, 1988.

K. B. Lakshmanan, S. Jayaprakash, and P. K. Sinha, “Properties of Control-Flow Complexity Measures,” IEEE Transactions on Software Engineering, vol. 17, no. 12, pp. 1289–1295, 1991.

L. C. Briand, S. Morasca, and V. R. Basili, “Property-based software engineering measurement,” IEEE Transactions on Software Engineering, vol. 22, no. 1, pp. 68–86, 1996.

S. Morasca, “Refining the axiomatic definition of internal software attributes,” in Proceedings of the 2nd International Symposium on Empirical Software Engineering and Measurement, ESEM 2008, pp. 188–197, Germany, October 2008.

V. Del Bianco, L. Lavazza, S. Morasca, and D. Taibi, “A survey on open source software trustworthiness,” IEEE Software, vol. 28, no. 5, pp. 67–75, 2011.

H. Tao and Y. Chen, “A new metric model for trustworthiness of softwares,” Telecommunication Systems, vol. 51, no. 2-3, pp. 95–105, 2012.

H. Tao, Y. Chen, and J. Pang, “A software trustworthiness measure based on the decompositions of trustworthy attributes and its validation,” Lecture Notes in Electrical Engineering, vol. 349, pp. 981–990, 2015.

H. W. Tao, Y. X. Chen, and J. M. Pang, “Axiomatic approaches based on the software trustworthiness measure,” in Proceedings of the International Conference on Applied System Innovation, ICASI 2015, pp. 135–142, Japan, May 2015.

J. Wang, Y. Chen, B. Gu et al., “An approach to measuring and grading software trust for spacecraft software,” Scientia Sinica Techologica, vol. 45, pp. 221–228, 2015.

H. W. Tao and J. Zhao, “An improved attributes-based software trustworthiness metric model,” Journal of Wuhan University. Natural Science Edition. Wuhan Daxue Xuebao. Lixue Ban, vol. 63, no. 2, pp. 151–157, 2017.

Y. Li and Y. Chen, “A measurement model for trustworthy software based on trusted evidences,” in Proceedings of the 2nd International Symposium on System and Software Reliability, ISSSR 2016, pp. 20–24, China, October 2016.

Y. Zhang, Y. Zhang, and M. Hai, “An Evaluation Model of Software Trustworthiness Based on Fuzzy Comprehensive Evaluation Method,” in Proceedings of the 2012 International Conference on Industrial Control and Electronics Engineering (ICICEE), pp. 616–619, Xi'an, China, August 2012.

S. Huiling, M. Jun, and Z. Fengyi, “A fuzzy comprehensive evaluation model for software dependability based on entropy weight,” in Proceedings of the International Conference on Computer Science and Software Engineering, CSSE 2008, pp. 683–685, IEEE Computer Society Press, Washington, DC, USA, December 2008.

B. Li and Y. Cao, “An improved comprehensive evaluation model of software dependability based on rough set theory,” Journal of Software , vol. 4, no. 10, pp. 1152–1159, 2009.

N. Fenton, B. Littlewood, M. Neil, L. Strigini, A. Sutcliffe, and D. Wright, “Assessing dependability of safety critical systems using diverse evidence,” IEE Proceedings Software, vol. 145, no. 1, pp. 35–39, 1998.

G. Si, Y. Ren, J. Xu, and J. Yang, “A dependability evaluation model for internetware based on Bayesian network,” Jisuanji Yanjiu yu Fazhan/Computer Research and Development, vol. 49, no. 5, pp. 1028–1038, 2012.

H.-Q. Liang and W. Wu, “Research of trust evaluation model based on dynamic Bayesian network,” Tongxin Xuebao/Journal on Communication, vol. 34, no. 9, pp. 68–76, 2013.

S. Yang, S. Ding, and W. Chu, “Trustworthy software evaluation using utility based evidence theory,” Jisuanji Yanjiu yu Fazhan/Computer Research and Development, vol. 46, no. 7, pp. 1152–1159, 2009.

S. Ding, S.-L. Yang, and C. Fu, “A novel evidential reasoning based method for software trustworthiness evaluation under the uncertain and unreliable environment,” Expert Systems with Applications, vol. 39, no. 3, pp. 2700–2709, 2012.

X. Li, X. Wang, T. Zhang, and J. Yi, “Software Trustworthness Evaluation Based on Weakness Analysis and Testing Assessment,” Journal of Tsinghua University (Science and Technology), vol. 51, no. 10, pp. 1287–1293, 2011.

A. Immonen and M. Palviainen, “Trustworthiness evaluation and testing of open source components,” in Proceedings of the 7th International Conference on Quality Software, QSIC 2007, pp. 316–321, USA, October 2007.

D. Taibi, V. del Bianco, D. D. Carbonare, L. Lavazza, and S. Morasca, “Towards the evaluation of OSS trustworthiness: Lessons learned from the observation of relevant OSS projects,” International Federation for Information Processing, vol. 275, pp. 389–395, 2008.

V. del Bianco, L. Lavazza, S. Morasca, and D. Taibi, “Quality of Open Source Software: The QualiPSo Trustworthiness Model,” in Open Source Ecosystems: Diverse Communities Interacting, vol. 299 of IFIP Advances in Information and Communication Technology, pp. 199–212, 2009.

L. Lavazza, S. Morasca, D. Taibi, and D. Tosi, “Predicting OSS trustworthiness on the basis of elementary code assessment,” in Proceedings of the 4th International Symposium on Empirical Software Engineering and Measurement, ESEM 2010, September 2010.

Z. Zheng, S. Ma, W. Li et al., “Dynamical characteristics of software trustworthiness and their evolutionary complexity,” Science China Information Sciences, vol. 52, no. 8, pp. 1328–1334, 2009.

Z. Zheng, S. Ma, W. Li et al., “Complexity of software trustworthiness and its dynamical statistical analysis methods,” Science in China, Series F: Information Sciences, vol. 52, no. 9, pp. 1651–1657, 2009.

X. Zhang, W. Li, Z. Zheng, and B. Guo, “Optimized statistical analysis of software trustworthiness attributes,” Science China Information Sciences, vol. 55, no. 11, pp. 2508–2520, 2012.

D. Wang, Y. Lu, W. Zhao, and L. Fu, “Trust-measuring model for software using dependent relation between variables,” Huazhong Keji Daxue Xuebao (Ziran Kexue Ban)/Journal of Huazhong University of Science and Technology (Natural Science Edition), vol. 41, no. 1, pp. 41–45, 2013.

D. Wang, H.-Y. Sun, J. Wang, and L.-H. Fu, “Trusted analysis model for interactive behavior of a software system based on slicing technology,” Beijing Gongye Daxue Xuebao/Journal of Beijing University of Technology, vol. 39, no. 5, pp. 713–721, 2013.

Y. Yuan and Q. Han, “A Software Behavior Trustworthiness Measurement Method based on Data Mining,” International Journal of Computational Intelligence Systems, vol. 4, no. 5, pp. 817–825, 2011.

Y. Yuan and Q. Han, “A data mining based measurement method for software trustworthiness,” Journal of Electronics, vol. 21, no. 1, pp. 13–16, 2012.

L. Zhuang, M. Cai, and C. X. Shen, “Hierarchical verification of behavior trustworthiness,” Journal of Beijing University of Technology. Beijing Gongye Daxue Xuebao, vol. 38, no. 9, pp. 1396–1401, 2012.

L. Zhuang, C. X. Shen, and M. Cai, “Research on state space reduction of behavior-based trusted dynamic measurement,” Chinese Journal of Computers. Jisuanji Xuebao, vol. 37, no. 5, pp. 1071–1081, 2014.

F. Zhang, M. Xu, and L. You, “A behavior modeling method based on system call and algebra process CCS,” Journal of Wuhan University, vol. 56, no. 2, pp. 133–137, 2010.

F. Zhang, M. Jiang, H. Wu, and M. Xu, “Approach for trust analysis of software dynamic behavior based on noninterference,” Computer Science, vol. 39, no. 1, pp. 101–104, 2012.

Q. Zhao, H.-Q. Wang, G.-S. Feng, and J. Zhao, “Measuring method of software dependability based on Pi calculus,” Jilin Daxue Xuebao (Gongxueban)/Journal of Jilin University (Engineering and Technology Edition), vol. 41, no. 6, pp. 1684–1689, 2011.

N. N. Fu, X. Zhou, and T. Zhan, “QtPi: a calculus to enforce trustworthiness requirements,” Journal of Computer Research and Development, vol. 48, no. 11, pp. 2120–2130, 2011.

E. Amoroso, T. Nguyen, J. Weiss, J. Watson, P. Lapiska, and T. Starr, “Toward an approach to measuring software trust,” in Proceedings of the 1991 IEEE Computer Society Symposium on Research in Security and Privacy, pp. 198–218, Oakland, CA, USA.

E. Amoroso, C. Taylor, J. Watson, M. Marietta, and J. Weiss, “A process-oriented methodology for assessing and improving software trustworthiness,” in Proceedings of the 2nd ACM Conference on Computer and Communications Security, CCS 1994, pp. 39–50, USA, November 1994.

H. Zhang, F. Shu, Y. Yang, X. Wang, and Q. Wang, “A Fuzzy-Based Method for Evaluating the Trustworthiness of Software Processes,” in New Modeling Concepts for Today’s Software Processes, vol. 6195 of Lecture Notes in Computer Science, pp. 297–308, Springer Berlin Heidelberg, Berlin, Heidelberg, 2010.

J. Du, Y. Yang, Q. Wang, and M. S. Li. Evidence-Based Trustworthy, “Software Process Assessment Method,” Journal of Frontiers of Computer Science and Technology, vol. 5, no. 6, pp. 501–512, June 2011.

H. Tao and Y. Chen, “A Quantitative Relation Model Between Trustworthy Attributes,” in Proceedings of the 3rd International Conference on Quantitative Logic and Soft Computing, pp. 197–204, Xi'an, China, 2012.

H. Tao and J. Zhao, “Research of software trustworthiness measurement based on validation,” in Proceedings of the 2nd International Symposium on System and Software Reliability, ISSSR 2016, pp. 7–12, October 2016.