From 446c218b48a85f0c205730272092b0536d2d8ca8 Mon Sep 17 00:00:00 2001 From: Benjamin Fast <89418456+bfast3@users.noreply.github.com> Date: Tue, 8 Oct 2024 19:53:22 -0600 Subject: [PATCH] checkpoint commit, fixed some small bugs --- input_tokens.txt | 89 +++++++++++---- lexer.py | 13 ++- method_syntax.py | 72 ++++++++---- method_tokens.txt | 95 ++++++++++++---- output.txt | 275 ++++++++++++++++++++++++++++++++-------------- output_tokens.txt | 95 ++++++++++++---- parser.py | 1 + testError.java | 94 ++++++++++++++++ testOriginal.java | 86 +++++++++++++++ 9 files changed, 654 insertions(+), 166 deletions(-) create mode 100644 testError.java create mode 100644 testOriginal.java diff --git a/input_tokens.txt b/input_tokens.txt index 91d4020..c47b990 100644 --- a/input_tokens.txt +++ b/input_tokens.txt @@ -1,45 +1,92 @@ -Token(STATEMENT, public class Example) +Token(STATEMENT, public class testError) Token(LBRACE, {) -Token(METHOD, public static void main(String[] args)) +Token(METHOD, public int add(int a, int b)) +Token(LBRACE, {) +Token(STATEMENT, return a+b;) +Token(RBRACE, }) +Token(METHOD, int addCheck(int a, int b)) +Token(LBRACE, {) +Token(IF, if(a > 0 && b > 0)) +Token(LBRACE, {) +Token(STATEMENT, return a+b+a;) +Token(ELSE, else) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Hello, World!");) -Token(METHOD, private int add(int a, int b)) Token(STATEMENT, return a + b;) -Token(METHOD, protected void displayMessage()) +Token(RBRACE, }) +Token(RBRACE, }) +Token(METHOD, protected static void print(String a)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("This is a message.");) +Token(STATEMENT, System.out.println(a);) Token(RBRACE, }) -Token(METHOD, int subtract(int a, int b)) +Token(METHOD, void printTwice(String a)) Token(LBRACE, {) -Token(STATEMENT, return a - b;) +Token(STATEMENT, System.out.println(a);) +Token(STATEMENT, System.out.println(a);) Token(RBRACE, }) -Token(IF, if (x > 0)) +Token(METHOD, public static void main(String[] args)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Positive");) +Token(STATEMENT, int one = 1;) +Token(STATEMENT, int two = 2;) +Token(STATEMENT, String apple = "apple";) +Token(STATEMENT, testOriginal a = new testOriginal();) +Token(STATEMENT, int result = a.add(one, two);) +Token(IF, if (result == 1)) +Token(STATEMENT, System.out.println("one");) Token(RBRACE, }) -Token(METHOD, else if (x < 0)) +Token(METHOD, else if (result == 2)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Negative");) +Token(STATEMENT, System.out.println("two");) Token(RBRACE, }) Token(ELSE, else) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Zero");) -Token(RBRACE, }) -Token(SWITCH, switch (x)) +Token(STATEMENT, System.out.println("other");) +Token(SWITCH, switch (result)) Token(LBRACE, {) Token(STATEMENT, case 1:) -Token(STATEMENT, System.out.println("One");) +Token(STATEMENT, System.out.println("one");) Token(STATEMENT, break;) Token(STATEMENT, case 2:) -Token(STATEMENT, System.out.println("Two");) +Token(STATEMENT, System.out.println("two");) +Token(STATEMENT, break;) +Token(STATEMENT, case 3:) +Token(STATEMENT, System.out.println("three");) Token(STATEMENT, break;) +Token(STATEMENT, default:) +Token(STATEMENT, System.out.println("other");) +Token(STATEMENT, int count = 0;) +Token(DO, do) +Token(LBRACE, {) +Token(STATEMENT, System.out.println(count);) +Token(STATEMENT, count++;) Token(RBRACE, }) -Token(FOR, for (int i = 0; i < 10; i++)) +Token(WHILE, while(count < 10);) +Token(FOR, for(int i = 0; i < apple.length(); i++)) Token(LBRACE, {) -Token(STATEMENT, System.out.println(i);) +Token(STATEMENT, System.out.println(apple.charAt(i));) +Token(STATEMENT, int count2 = 0;) +Token(WHILE, while (count2 < 9)) +Token(LBRACE, {) +Token(STATEMENT, System.out.println(apple);) +Token(STATEMENT, count2 ++;) +Token(RBRACE, }) +Token(STATEMENT, //Big nested test) +Token(IF, if(result == 3)) +Token(LBRACE, {) +Token(IF, if (apple == "apple")) +Token(LBRACE, {) +Token(IF, if(true)) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("all true");) +Token(RBRACE, }) Token(RBRACE, }) -Token(WHILE, while (x < 100)) +Token(METHOD, else if(apple == "banana")) Token(LBRACE, {) -Token(STATEMENT, x++;) +Token(STATEMENT, System.out.println("Not true");) +Token(RBRACE, }) +Token(RBRACE, }) +Token(ELSE, else) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("other");) +Token(RBRACE, }) Token(RBRACE, }) Token(RBRACE, }) diff --git a/lexer.py b/lexer.py index 65f3872..e20bb9f 100644 --- a/lexer.py +++ b/lexer.py @@ -141,9 +141,20 @@ def split_line_and_tokenize(self, line): } """ - lexer = Lexer(java_code) + code = '' + fileToRead = input('Please enter a java file to parse: ') + try: + with open(fileToRead, 'r') as f: + for line in f.readlines(): + code += f'{line}\n' # Append each line to code with a newline + except IOError: + print("Error: failed to read file") + + + lexer = Lexer(code) tokens = lexer.tokenize() with open('input_tokens.txt', 'w') as f: for token in tokens: f.write(f"{token}\n") + print('input_tokens.txt successfully created!') diff --git a/method_syntax.py b/method_syntax.py index 89cdd09..4ba390a 100644 --- a/method_syntax.py +++ b/method_syntax.py @@ -24,57 +24,45 @@ def parse_tokens(input_file): tokens.append(Token(token_type, value)) return tokens -# Function to correct method declaration errors def correct_method_declaration(method_declaration): # Default visibility modifier and return type default_visibility = "public" default_return_type = "void" + reserved_keywords = {'if', 'else', 'switch', 'for', 'while', 'do'} # Regex pattern to parse method declarations method_pattern = re.compile(r''' ^\s* (?Ppublic|private|protected)?\s* (?Pstatic\s+)? # Optional 'static' - (?P[\w<>\[\]]+)?\s+ # Return type (optional if missing) + (?P(?!if|else|switch|for|while|do)[\w<>\[\]]+)\s+ # Exclude keywords (?P\w+)\s* # Method name - (\((?P.*)\))? # Parameters in parentheses (optional) + \((?P.*)\) # Parameters in parentheses ''', re.VERBOSE) match = method_pattern.match(method_declaration) if not match: - # If the method declaration doesn't match the pattern, return an error - return method_declaration # Return as is if it cannot be parsed + # If the method declaration doesn't match the pattern, return as is + return method_declaration + method_name = match.group('method_name') + + # Check if the method name is a reserved keyword + if method_name in reserved_keywords: + return method_declaration # This is not a valid method, skip correction + + # Continue with the existing correction logic visibility = match.group('visibility') static_part = match.group('static') or '' return_type = match.group('return_type') - method_name = match.group('method_name') parameters = match.group('parameters') - # Correct missing visibility modifier if not visibility: visibility = default_visibility - - # Correct missing return type if not return_type: return_type = default_return_type - # Correct invalid visibility modifiers - valid_visibilities = {'public', 'private', 'protected'} - if visibility not in valid_visibilities: - visibility = default_visibility - - # Correct invalid method names - if not re.match(r'^[a-zA-Z_]\w*$', method_name): - method_name = 'correctedMethodName' # Provide a default valid method name - - # Correct missing parentheses - if parameters is None: - parameters = '' - - # Reconstruct the corrected method declaration corrected_method = f"{visibility} {static_part}{return_type} {method_name}({parameters})" - return corrected_method # Main function to process tokens and correct method declarations @@ -94,8 +82,44 @@ def process_tokens(input_file, output_file): for token in corrected_tokens: file.write(f"Token({token.type}, {token.value})\n") +# A method to count and return the number of methods +def count_methods(input_file): + tokens = parse_tokens(input_file) + count = 0 + for token in tokens: + if token.type == 'METHOD' and not token.value.startswith("else if"): #the else if was being counted as a method and this change fixed it + count += 1 + return count + +# Method to take all the information and generate the output file need +def generate_output_file(updated_file, output_file, original_file, count): + + original_tokens = parse_tokens(original_file) + updated_tokens = parse_tokens(updated_file) + + with open(output_file, 'w') as of: + of.write("Original file (updated)\n") #removed the updated in final build + + # can add some sort of formatting logic here + for token in original_tokens: + of.write(f'{token.value}\n') + + of.write('\n') + of.write("Corrected file: \n") + for token in updated_tokens: + of.write(f'{token.value}\n') + of.write('\n') + of.write(f'Method count: {count}') + # Example usage if __name__ == "__main__": input_file = 'output_tokens.txt' # Input file with tokens output_file = 'method_tokens.txt' # Output file with corrected tokens process_tokens(input_file, output_file) + + original_file = 'input_tokens.txt' + output_file = 'output.txt' + updated_file = 'method_tokens.txt' + count = count_methods(updated_file) + generate_output_file(updated_file, output_file, original_file, count) + print("output.txt successfully created!") \ No newline at end of file diff --git a/method_tokens.txt b/method_tokens.txt index 503b612..3686ac0 100644 --- a/method_tokens.txt +++ b/method_tokens.txt @@ -1,48 +1,103 @@ -Token(STATEMENT, public class Example) +Token(STATEMENT, public class testError) Token(LBRACE, {) -Token(METHOD, public static void main(String[] args)) +Token(METHOD, public int add(int a, int b)) +Token(LBRACE, {) +Token(STATEMENT, return a+b;) +Token(RBRACE, }) +Token(METHOD, public int addCheck(int a, int b)) +Token(LBRACE, {) +Token(RBRACE, }) +Token(IF, if(a > 0 && b > 0)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Hello, World!");) +Token(STATEMENT, return a+b+a;) Token(RBRACE, }) -Token(METHOD, private int add(int a, int b)) +Token(ELSE, else) Token(LBRACE, {) Token(STATEMENT, return a + b;) Token(RBRACE, }) -Token(METHOD, protected void displayMessage()) +Token(RBRACE, }) +Token(METHOD, protected static void print(String a)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("This is a message.");) +Token(STATEMENT, System.out.println(a);) Token(RBRACE, }) -Token(METHOD, public int subtract(int a, int b)) +Token(METHOD, public void printTwice(String a)) Token(LBRACE, {) -Token(STATEMENT, return a - b;) +Token(STATEMENT, System.out.println(a);) +Token(STATEMENT, System.out.println(a);) Token(RBRACE, }) -Token(IF, if (x > 0)) +Token(METHOD, public static void main(String[] args)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Positive");) +Token(STATEMENT, int one = 1;) +Token(STATEMENT, int two = 2;) +Token(STATEMENT, String apple = "apple";) +Token(STATEMENT, testOriginal a = new testOriginal();) +Token(STATEMENT, int result = a.add(one, two);) Token(RBRACE, }) -Token(METHOD, public else if(x < 0)) +Token(IF, if (result == 1)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Negative");) +Token(STATEMENT, System.out.println("one");) +Token(RBRACE, }) +Token(METHOD, else if (result == 2)) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("two");) Token(RBRACE, }) Token(ELSE, else) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Zero");) +Token(STATEMENT, System.out.println("other");) Token(RBRACE, }) -Token(SWITCH, switch (x)) +Token(SWITCH, switch (result)) Token(LBRACE, {) Token(STATEMENT, case 1:) -Token(STATEMENT, System.out.println("One");) +Token(STATEMENT, System.out.println("one");) Token(STATEMENT, break;) Token(STATEMENT, case 2:) -Token(STATEMENT, System.out.println("Two");) +Token(STATEMENT, System.out.println("two");) Token(STATEMENT, break;) +Token(STATEMENT, case 3:) +Token(STATEMENT, System.out.println("three");) +Token(STATEMENT, break;) +Token(STATEMENT, default:) +Token(STATEMENT, System.out.println("other");) +Token(STATEMENT, int count = 0;) +Token(RBRACE, }) +Token(DO, do) +Token(LBRACE, {) +Token(STATEMENT, System.out.println(count);) +Token(STATEMENT, count++;) +Token(RBRACE, }) +Token(WHILE, while(count < 10);) +Token(LBRACE, {) Token(RBRACE, }) -Token(FOR, for (int i = 0; i < 10; i++)) +Token(FOR, for(int i = 0; i < apple.length(); i++)) Token(LBRACE, {) -Token(STATEMENT, System.out.println(i);) +Token(STATEMENT, System.out.println(apple.charAt(i));) +Token(STATEMENT, int count2 = 0;) Token(RBRACE, }) -Token(WHILE, while (x < 100)) +Token(WHILE, while (count2 < 9)) Token(LBRACE, {) -Token(STATEMENT, x++;) +Token(STATEMENT, System.out.println(apple);) +Token(STATEMENT, count2 ++;) +Token(RBRACE, }) +Token(STATEMENT, //Big nested test) +Token(IF, if(result == 3)) +Token(LBRACE, {) +Token(RBRACE, }) +Token(IF, if (apple == "apple")) +Token(LBRACE, {) +Token(RBRACE, }) +Token(IF, if(true)) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("all true");) +Token(RBRACE, }) +Token(RBRACE, }) +Token(METHOD, else if(apple == "banana")) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("Not true");) +Token(RBRACE, }) +Token(RBRACE, }) +Token(ELSE, else) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("other");) +Token(RBRACE, }) Token(RBRACE, }) Token(RBRACE, }) diff --git a/output.txt b/output.txt index bf85764..3f898b2 100644 --- a/output.txt +++ b/output.txt @@ -1,85 +1,200 @@ -Original Java Code: - -public class Example { - public static void main(String[] args) - System.out.println("Hello, World!"); - - private int add(int a, int b) - return a + b; - - protected void displayMessage() - System.out.println("This is a message."); - - int subtract(int a, int b) { - return a - b; - } - - do - System.out.println("Do something"); - while (x < 5); - - if (x > 0) - System.out.println("Positive"); - else if (x < 0) - System.out.println("Negative"); - else - System.out.println("Zero"); - - switch (x) - case 1: - System.out.println("One"); - break; - case 2: - System.out.println("Two"); - break; - - for (int i = 0; i < 10; i++) - System.out.println(i); - - while (x < 100) - x++; +Original file (updated) +public class testError +{ +public int add(int a, int b) +{ +return a+b; } - -Corrected Java Code: -public class Example { - public static void main(String[] args) +int addCheck(int a, int b) { - System.out.println("Hello, World!"); - - private int add(int a, int b) - return a + b; - - protected void displayMessage() - System.out.println("This is a message."); - - int subtract(int a, int b) { - return a - b; - } - - do - System.out.println("Do something"); - while (x < 5); - - if (x > 0) - System.out.println("Positive"); - else if (x < 0) - System.out.println("Negative"); - else - System.out.println("Zero"); - - switch (x) - case 1: - System.out.println("One"); - break; - case 2: - System.out.println("Two"); - break; - - for (int i = 0; i < 10; i++) - System.out.println(i); +if(a > 0 && b > 0) +{ +return a+b+a; +else +{ +return a + b; +} +} +protected static void print(String a) +{ +System.out.println(a); +} +void printTwice(String a) +{ +System.out.println(a); +System.out.println(a); +} +public static void main(String[] args) +{ +int one = 1; +int two = 2; +String apple = "apple"; +testOriginal a = new testOriginal(); +int result = a.add(one, two); +if (result == 1) +System.out.println("one"); +} +else if (result == 2) +{ +System.out.println("two"); +} +else +{ +System.out.println("other"); +switch (result) +{ +case 1: +System.out.println("one"); +break; +case 2: +System.out.println("two"); +break; +case 3: +System.out.println("three"); +break; +default: +System.out.println("other"); +int count = 0; +do +{ +System.out.println(count); +count++; +} +while(count < 10); +for(int i = 0; i < apple.length(); i++) +{ +System.out.println(apple.charAt(i)); +int count2 = 0; +while (count2 < 9) +{ +System.out.println(apple); +count2 ++; +} +//Big nested test +if(result == 3) +{ +if (apple == "apple") +{ +if(true) +{ +System.out.println("all true"); +} +} +else if(apple == "banana") +{ +System.out.println("Not true"); +} +} +else +{ +System.out.println("other"); +} +} +} - while (x < 100) - x++; +Corrected file: +public class testError +{ +public int add(int a, int b) +{ +return a+b; +} +public int addCheck(int a, int b) +{ +} +if(a > 0 && b > 0) +{ +return a+b+a; +} +else +{ +return a + b; +} +} +protected static void print(String a) +{ +System.out.println(a); +} +public void printTwice(String a) +{ +System.out.println(a); +System.out.println(a); +} +public static void main(String[] args) +{ +int one = 1; +int two = 2; +String apple = "apple"; +testOriginal a = new testOriginal(); +int result = a.add(one, two); +} +if (result == 1) +{ +System.out.println("one"); +} +else if (result == 2) +{ +System.out.println("two"); +} +else +{ +System.out.println("other"); +} +switch (result) +{ +case 1: +System.out.println("one"); +break; +case 2: +System.out.println("two"); +break; +case 3: +System.out.println("three"); +break; +default: +System.out.println("other"); +int count = 0; +} +do +{ +System.out.println(count); +count++; +} +while(count < 10); +{ +} +for(int i = 0; i < apple.length(); i++) +{ +System.out.println(apple.charAt(i)); +int count2 = 0; +} +while (count2 < 9) +{ +System.out.println(apple); +count2 ++; +} +//Big nested test +if(result == 3) +{ +} +if (apple == "apple") +{ +} +if(true) +{ +System.out.println("all true"); +} +} +else if(apple == "banana") +{ +System.out.println("Not true"); +} +} +else +{ +System.out.println("other"); +} +} } -Number of methods: 1 +Method count: 5 \ No newline at end of file diff --git a/output_tokens.txt b/output_tokens.txt index a3dab22..bfcafd8 100644 --- a/output_tokens.txt +++ b/output_tokens.txt @@ -1,48 +1,103 @@ -Token(STATEMENT, public class Example) +Token(STATEMENT, public class testError) Token(LBRACE, {) -Token(METHOD, public static void main(String[] args)) +Token(METHOD, public int add(int a, int b)) +Token(LBRACE, {) +Token(STATEMENT, return a+b;) +Token(RBRACE, }) +Token(METHOD, int addCheck(int a, int b)) +Token(LBRACE, {) +Token(RBRACE, }) +Token(IF, if(a > 0 && b > 0)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Hello, World!");) +Token(STATEMENT, return a+b+a;) Token(RBRACE, }) -Token(METHOD, private int add(int a, int b)) +Token(ELSE, else) Token(LBRACE, {) Token(STATEMENT, return a + b;) Token(RBRACE, }) -Token(METHOD, protected void displayMessage()) +Token(RBRACE, }) +Token(METHOD, protected static void print(String a)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("This is a message.");) +Token(STATEMENT, System.out.println(a);) Token(RBRACE, }) -Token(METHOD, int subtract(int a, int b)) +Token(METHOD, void printTwice(String a)) Token(LBRACE, {) -Token(STATEMENT, return a - b;) +Token(STATEMENT, System.out.println(a);) +Token(STATEMENT, System.out.println(a);) Token(RBRACE, }) -Token(IF, if (x > 0)) +Token(METHOD, public static void main(String[] args)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Positive");) +Token(STATEMENT, int one = 1;) +Token(STATEMENT, int two = 2;) +Token(STATEMENT, String apple = "apple";) +Token(STATEMENT, testOriginal a = new testOriginal();) +Token(STATEMENT, int result = a.add(one, two);) Token(RBRACE, }) -Token(METHOD, else if (x < 0)) +Token(IF, if (result == 1)) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Negative");) +Token(STATEMENT, System.out.println("one");) +Token(RBRACE, }) +Token(METHOD, else if (result == 2)) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("two");) Token(RBRACE, }) Token(ELSE, else) Token(LBRACE, {) -Token(STATEMENT, System.out.println("Zero");) +Token(STATEMENT, System.out.println("other");) Token(RBRACE, }) -Token(SWITCH, switch (x)) +Token(SWITCH, switch (result)) Token(LBRACE, {) Token(STATEMENT, case 1:) -Token(STATEMENT, System.out.println("One");) +Token(STATEMENT, System.out.println("one");) Token(STATEMENT, break;) Token(STATEMENT, case 2:) -Token(STATEMENT, System.out.println("Two");) +Token(STATEMENT, System.out.println("two");) Token(STATEMENT, break;) +Token(STATEMENT, case 3:) +Token(STATEMENT, System.out.println("three");) +Token(STATEMENT, break;) +Token(STATEMENT, default:) +Token(STATEMENT, System.out.println("other");) +Token(STATEMENT, int count = 0;) +Token(RBRACE, }) +Token(DO, do) +Token(LBRACE, {) +Token(STATEMENT, System.out.println(count);) +Token(STATEMENT, count++;) +Token(RBRACE, }) +Token(WHILE, while(count < 10);) +Token(LBRACE, {) Token(RBRACE, }) -Token(FOR, for (int i = 0; i < 10; i++)) +Token(FOR, for(int i = 0; i < apple.length(); i++)) Token(LBRACE, {) -Token(STATEMENT, System.out.println(i);) +Token(STATEMENT, System.out.println(apple.charAt(i));) +Token(STATEMENT, int count2 = 0;) Token(RBRACE, }) -Token(WHILE, while (x < 100)) +Token(WHILE, while (count2 < 9)) Token(LBRACE, {) -Token(STATEMENT, x++;) +Token(STATEMENT, System.out.println(apple);) +Token(STATEMENT, count2 ++;) +Token(RBRACE, }) +Token(STATEMENT, //Big nested test) +Token(IF, if(result == 3)) +Token(LBRACE, {) +Token(RBRACE, }) +Token(IF, if (apple == "apple")) +Token(LBRACE, {) +Token(RBRACE, }) +Token(IF, if(true)) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("all true");) +Token(RBRACE, }) +Token(RBRACE, }) +Token(METHOD, else if(apple == "banana")) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("Not true");) +Token(RBRACE, }) +Token(RBRACE, }) +Token(ELSE, else) +Token(LBRACE, {) +Token(STATEMENT, System.out.println("other");) +Token(RBRACE, }) Token(RBRACE, }) Token(RBRACE, }) diff --git a/parser.py b/parser.py index d9cef38..da5b921 100644 --- a/parser.py +++ b/parser.py @@ -102,3 +102,4 @@ def process_tokens(input_file, output_file): input_file = 'input_tokens.txt' # Your input file with tokens output_file = 'output_tokens.txt' # The output file with missing braces identified process_tokens(input_file, output_file) + print('output_tokens.txt successfully created!') \ No newline at end of file diff --git a/testError.java b/testError.java new file mode 100644 index 0000000..9861b23 --- /dev/null +++ b/testError.java @@ -0,0 +1,94 @@ +public class testError { + + public int add(int a, int b) { + return a+b; + } + + int addCheck(int a, int b) { + if(a > 0 && b > 0) { + return a+b+a; + + else { + return a + b; + } + } + + + protected static void print(String a) { + System.out.println(a); + } + + void printTwice(String a) { + System.out.println(a); + System.out.println(a); + } + + public static void main(String[] args) { + int one = 1; + int two = 2; + + String apple = "apple"; + + testOriginal a = new testOriginal(); + + int result = a.add(one, two); + + if (result == 1) + System.out.println("one"); + } + else if (result == 2) { + System.out.println("two"); + } + else { + System.out.println("other"); + + + switch (result) { + case 1: + System.out.println("one"); + break; + case 2: + System.out.println("two"); + break; + case 3: + System.out.println("three"); + break; + default: + System.out.println("other"); + + + int count = 0; + + do { + System.out.println(count); + count++; + } while(count < 10); + + for(int i = 0; i < apple.length(); i++) { + System.out.println(apple.charAt(i)); + + + int count2 = 0; + while (count2 < 9) { + System.out.println(apple); + count2 ++; + } + + //Big nested test + if(result == 3) { + if (apple == "apple") { + if(true) { + System.out.println("all true"); + } + } + else if(apple == "banana") { + System.out.println("Not true"); + } + } + else { + System.out.println("other"); + } + } + } + + diff --git a/testOriginal.java b/testOriginal.java new file mode 100644 index 0000000..ca50e7c --- /dev/null +++ b/testOriginal.java @@ -0,0 +1,86 @@ +public class testOriginal { + + public int add(int a, int b) { + return a + b; + } + + int addCheck(int a, int b) { + if (a > 0 && b > 0) { + return a + b + a; + } else { + return a + b; + } + } + + protected static void print(String a) { + System.out.println(a); + } + + void printTwice(String a) { + System.out.println(a); + System.out.println(a); + } + + public static void main(String[] args) { + int one = 1; + int two = 2; + + String apple = "apple"; + + testOriginal a = new testOriginal(); + + int result = a.add(one, two); + + if (result == 1) { + System.out.println("one"); + } else if (result == 2) { + System.out.println("two"); + } else { + System.out.println("other"); + } + + switch (result) { + case 1: + System.out.println("one"); + break; + case 2: + System.out.println("two"); + break; + case 3: + System.out.println("three"); + break; + default: + System.out.println("other"); + + int count = 0; + + do { + System.out.println(count); + count++; + } while (count < 10); + + for (int i = 0; i < apple.length(); i++) { + System.out.println(apple.charAt(i)); + + int count2 = 0; + while (count2 < 9) { + System.out.println(apple); + count2++; + } + + // Big nested test + if (result == 3) { + if (apple == "apple") { + if (true) { + System.out.println("all true"); + } + } else if (apple == "banana") { + System.out.println("Not true"); + } + } else { + System.out.println("other"); + } + } + } + } +}