UnitTestPractice/Password.cpp at main · jbaeee/UnitTestPractice · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include"Password.h"
#include<string>
#include<cctype>

using std::string;

/*
 The function receives a string counts how many times the same character
 occurs at the beginning of the string, before any other characters (or the
 end of the string). The function is case-sensitive so 'Z' is different than
 'z' and any ASCII characters are allowed.
*/
intPassword::count_leading_characters(string phrase){
int repetition = 1;
int index = 0;
while( index < phrase.length()-1 && phrase[index] == phrase[index+1] ){
 repetition++;
 index++;
 }
return repetition;
}

/*
 receives a string and returns whether it has both at least one upper-case
 letter and at least one lower-case letter
*/
boolPassword::has_mixed_case(string pass){
bool has_upper_case = false;
bool has_lower_case = false;

for(int i = 0; i < pass.size(); i++){
char ch = pass[i];
if (isupper(ch)){
 has_upper_case = true;
 }
if (islower(ch)){
 has_lower_case = true;
 }

if(has_lower_case && has_upper_case){
returntrue;
 }

 }

returnfalse;
}