trackler 2.2.1.96 → 2.2.1.97

data/tracks/java/exercises/bracket-push/README.md

@@ -3,6 +3,68 @@
 Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
 verify that all the pairs are matched and nested correctly.
 
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/java/exercises/hello-world/.meta/version

@@ -0,0 +1 @@
+1.1.0

data/tracks/java/exercises/pascals-triangle/.meta/hints.md

@@ -0,0 +1,58 @@
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

data/tracks/java/exercises/pascals-triangle/README.md

@@ -14,6 +14,68 @@ the right and left of the current position in the previous row.
 # ... etc
 ```
 
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/java/exercises/series/.meta/hints.md

@@ -0,0 +1,58 @@
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

data/tracks/java/exercises/series/README.md

@@ -20,6 +20,68 @@ whatever you get.
 Note that these series are only required to occupy *adjacent positions*
 in the input; the digits need not be *numerically consecutive*.
 
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/python/exercises/grep/grep_test.py

@@ -1,5 +1,8 @@
-import os
 import unittest
+try:
+    import builtins
+except ImportError:
+    import __builtin__ as builtins
 
 from grep import grep
 
@@ -15,8 +18,7 @@ And Heroes gave (so stood the will of Jove)
 To dogs and to all ravening fowls a prey,
 When fierce dispute had separated once
 The noble Chief Achilles from the son
-Of Atreus, Agamemnon, King of men.
-'''
+Of Atreus, Agamemnon, King of men.'''
 
 MIDSUMMERNIGHTFILENAME = 'midsummer-night.txt'
 MIDSUMMERNIGHTCONTENTS = '''I do entreat your grace to pardon me.
@@ -25,8 +27,7 @@ Nor how it may concern my modesty,
 In such a presence here to plead my thoughts;
 But I beseech your grace that I may know
 The worst that may befall me in this case,
-If I refuse to wed Demetrius.
-'''
+If I refuse to wed Demetrius.'''
 
 PARADISELOSTFILENAME = 'paradise-lost.txt'
 PARADISELOSTCONTENTS = '''Of Mans First Disobedience, and the Fruit
@@ -36,17 +37,59 @@ With loss of Eden, till one greater Man
 Restore us, and regain the blissful Seat,
 Sing Heav'nly Muse, that on the secret top
 Of Oreb, or of Sinai, didst inspire
-That Shepherd, who first taught the chosen Seed
-'''
+That Shepherd, who first taught the chosen Seed'''
+FILENAMES = [
+    ILIADFILENAME,
+    MIDSUMMERNIGHTFILENAME,
+    PARADISELOSTFILENAME,
+]
+FILES = {}
 
 
-def remove_file(file_name):
-    try:
-        os.remove(file_name)
-    except OSError:
+class File(object):
+    def __init__(self, name=''):
+        self.name = name
+        self.contents = ''
+
+    def read(self):
+        return self.contents
+
+    def readlines(self):
+        return [line + '\n' for line in self.read().split('\n') if line]
+
+    def write(self, data):
+        self.contents += data
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
         pass
 
 
+# Store builtin definition of open()
+builtins.oldopen = builtins.open
+
+
+def open(name, mode='r', *args, **kwargs):
+    # if name is a mocked file name, lookup corresponding mocked file
+    if name in FILENAMES:
+        if mode == 'w' or name not in FILES:
+            FILES[name] = File(name)
+        return FILES[name]
+    # else call builtin open()
+    else:
+        return builtins.oldopen(name, mode, *args, **kwargs)
+
+
+builtins.open = open
+
+
+# remove mocked file contents
+def remove_file(file_name):
+    del FILES[file_name]
+
+
 def create_file(name, contents):
     with open(name, 'w') as f:
         f.write(contents)
@@ -55,6 +98,8 @@ def create_file(name, contents):
 class GrepTest(unittest.TestCase):
     @classmethod
     def setUpClass(self):
+        # Override builtin open() with mock-file-enabled one
+        builtins.open = open
         create_file(ILIADFILENAME, ILIADCONTENTS)
         create_file(MIDSUMMERNIGHTFILENAME, MIDSUMMERNIGHTCONTENTS)
         create_file(PARADISELOSTFILENAME, PARADISELOSTCONTENTS)
@@ -64,151 +109,169 @@ class GrepTest(unittest.TestCase):
         remove_file(ILIADFILENAME)
         remove_file(MIDSUMMERNIGHTFILENAME)
         remove_file(PARADISELOSTFILENAME)
+        # Restore builtin open()
+        builtins.open = builtins.oldopen
 
     def test_one_file_one_match_no_flags(self):
         self.assertMultiLineEqual(
             grep("Agamemnon", [ILIADFILENAME]),
-            "Of Atreus, Agamemnon, King of men.\n")
+            "Of Atreus, Agamemnon, King of men.\n"
+        )
 
     def test_one_file_one_match_print_line_numbers_flag(self):
         self.assertMultiLineEqual(
             grep("Forbidden", [PARADISELOSTFILENAME], "-n"),
-            "2:Of that Forbidden Tree, whose mortal tast\n")
+            "2:Of that Forbidden Tree, whose mortal tast\n"
+        )
 
     def test_one_file_one_match_case_insensitive_flag(self):
         self.assertMultiLineEqual(
             grep("FORBIDDEN", [PARADISELOSTFILENAME], "-i"),
-            "Of that Forbidden Tree, whose mortal tast\n")
+            "Of that Forbidden Tree, whose mortal tast\n"
+        )
 
     def test_one_file_one_match_print_file_names_flag(self):
         self.assertMultiLineEqual(
             grep("Forbidden", [PARADISELOSTFILENAME], "-l"),
-            PARADISELOSTFILENAME + '\n')
+            PARADISELOSTFILENAME + '\n'
+        )
 
     def test_one_file_one_match_match_entire_lines_flag(self):
         self.assertMultiLineEqual(
             grep("With loss of Eden, till one greater Man",
                  [PARADISELOSTFILENAME], "-x"),
-            "With loss of Eden, till one greater Man\n")
+            "With loss of Eden, till one greater Man\n"
+        )
 
     def test_one_file_one_match_multiple_flags(self):
         self.assertMultiLineEqual(
-            grep("OF ATREUS, Agamemnon, KIng of MEN.", [ILIADFILENAME],
-                 "-n -i -x"), "9:Of Atreus, Agamemnon, King of men.\n")
+            grep(
+                "OF ATREUS, Agamemnon, KIng of MEN.",
+                [ILIADFILENAME],
+                "-n -i -x"
+            ),
+            "9:Of Atreus, Agamemnon, King of men.\n"
+        )
 
     def test_one_file_several_matches_no_flags(self):
         self.assertMultiLineEqual(
             grep("may", [MIDSUMMERNIGHTFILENAME]),
-            ("Nor how it may concern my modesty,\n"
-             "But I beseech your grace that I may know\n"
-             "The worst that may befall me in this case,\n"))
+            "Nor how it may concern my modesty,\n"
+            "But I beseech your grace that I may know\n"
+            "The worst that may befall me in this case,\n"
+        )
 
     def test_one_file_several_matches_print_line_numbers_flag(self):
         self.assertMultiLineEqual(
             grep("may", [MIDSUMMERNIGHTFILENAME], "-n"),
-            ("3:Nor how it may concern my modesty,\n"
-             "5:But I beseech your grace that I may know\n"
-             "6:The worst that may befall me in this case,\n"))
+            "3:Nor how it may concern my modesty,\n"
+            "5:But I beseech your grace that I may know\n"
+            "6:The worst that may befall me in this case,\n"
+        )
 
     def test_one_file_several_matches_match_entire_lines_flag(self):
         self.assertMultiLineEqual(
-            grep("may", [MIDSUMMERNIGHTFILENAME], "-x"), "")
+            grep("may", [MIDSUMMERNIGHTFILENAME], "-x"),
+            ""
+        )
 
     def test_one_file_several_matches_case_insensitive_flag(self):
         self.assertMultiLineEqual(
             grep("ACHILLES", [ILIADFILENAME], "-i"),
-            ("Achilles sing, O Goddess! Peleus' son;\n"
-             "The noble Chief Achilles from the son\n"))
+            "Achilles sing, O Goddess! Peleus' son;\n"
+            "The noble Chief Achilles from the son\n"
+        )
 
     def test_one_file_several_matches_inverted_flag(self):
         self.assertMultiLineEqual(
             grep("Of", [PARADISELOSTFILENAME], "-v"),
-            ("Brought Death into the World, and all our woe,\n"
-             "With loss of Eden, till one greater Man\n"
-             "Restore us, and regain the blissful Seat,\n"
-             "Sing Heav'nly Muse, that on the secret top\n"
-             "That Shepherd, who first taught the chosen Seed\n"))
+            "Brought Death into the World, and all our woe,\n"
+            "With loss of Eden, till one greater Man\n"
+            "Restore us, and regain the blissful Seat,\n"
+            "Sing Heav'nly Muse, that on the secret top\n"
+            "That Shepherd, who first taught the chosen Seed\n"
+        )
 
     def test_one_file_no_matches_various_flags(self):
         self.assertMultiLineEqual(
-            grep("Gandalf", [ILIADFILENAME], "-n -l -x -i"), "")
+            grep("Gandalf", [ILIADFILENAME], "-n -l -x -i"),
+            ""
+        )
 
     def test_multiple_files_one_match_no_flags(self):
         self.assertMultiLineEqual(
-            grep(
-                "Agamemnon",
-                [ILIADFILENAME, MIDSUMMERNIGHTFILENAME, PARADISELOSTFILENAME]),
-            "iliad.txt:Of Atreus, Agamemnon, King of men.\n")
+            grep("Agamemnon", FILENAMES),
+            "iliad.txt:Of Atreus, Agamemnon, King of men.\n"
+        )
 
     def test_multiple_files_several_matches_no_flags(self):
         self.assertMultiLineEqual(
-            grep("may",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]),
-            ("midsummer-night.txt:Nor how it may concern my modesty,\n"
-             "midsummer-night.txt:But I beseech your grace that I may know\n"
-             "midsummer-night.txt:The worst that may befall me in this case,\n"
-             ))
+            grep("may", FILENAMES),
+            "midsummer-night.txt:Nor how it may concern my modesty,\n"
+            "midsummer-night.txt:But I beseech your grace that I may know\n"
+            "midsummer-night.txt:The worst that may befall me in this case,\n"
+        )
 
     def test_multiple_files_several_matches_print_line_numbers_flag(self):
+        expected = (
+            "midsummer-night.txt:5:But I beseech your grace that I may know\n"
+            "midsummer-night.txt:6:The worst that may befall me in this case,"
+            "\nparadise-lost.txt:2:Of that Forbidden Tree, whose mortal tast\n"
+            "paradise-lost.txt:6:Sing Heav'nly Muse, that on the secret top\n"
+        )
         self.assertMultiLineEqual(
-            grep("that",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-n"),
-            ("midsummer-night.txt:5:But I beseech your grace that I may know\n"
-             "midsummer-night.txt:6:The worst that may befall me in this case,"
-             "\nparadise-lost.txt:2:Of that Forbidden Tree, whose mortal tast"
-             "\nparadise-lost.txt:6:Sing Heav'nly Muse, that on the secret top"
-             "\n"))
+            grep("that", FILENAMES, "-n"),
+            expected
+        )
 
     def test_multiple_files_one_match_print_file_names_flag(self):
         self.assertMultiLineEqual(
-            grep("who",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-l"), ILIADFILENAME + '\n' + PARADISELOSTFILENAME + '\n')
+            grep("who", FILENAMES, "-l"),
+            ILIADFILENAME + '\n' + PARADISELOSTFILENAME + '\n')
 
     def test_multiple_files_several_matches_case_insensitive_flag(self):
+        expected = (
+            "iliad.txt:Caused to Achaia's host, sent many a soul\n"
+            "iliad.txt:Illustrious into Ades premature,\n"
+            "iliad.txt:And Heroes gave (so stood the will of Jove)\n"
+            "iliad.txt:To dogs and to all ravening fowls a prey,\n"
+            "midsummer-night.txt:I do entreat your grace to pardon me.\n"
+            "midsummer-night.txt:In such a presence here to plead my thoughts;"
+            "\nmidsummer-night.txt:If I refuse to wed Demetrius.\n"
+            "paradise-lost.txt:Brought Death into the World, and all our woe,"
+            "\nparadise-lost.txt:Restore us, and regain the blissful Seat,\n"
+            "paradise-lost.txt:Sing Heav'nly Muse, that on the secret top\n"
+        )
         self.assertMultiLineEqual(
-            grep("TO",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-i"),
-            ("iliad.txt:Caused to Achaia's host, sent many a soul\n"
-             "iliad.txt:Illustrious into Ades premature,\n"
-             "iliad.txt:And Heroes gave (so stood the will of Jove)\n"
-             "iliad.txt:To dogs and to all ravening fowls a prey,\n"
-             "midsummer-night.txt:I do entreat your grace to pardon me.\n"
-             "midsummer-night.txt:In such a presence here to plead my thoughts"
-             ";\nmidsummer-night.txt:If I refuse to wed Demetrius.\n"
-             "paradise-lost.txt:Brought Death into the World, and all our woe,"
-             "\nparadise-lost.txt:Restore us, and regain the blissful Seat,\n"
-             "paradise-lost.txt:Sing Heav'nly Muse, that on the secret top\n"))
+            grep("TO", FILENAMES, "-i"),
+            expected
+        )
 
     def test_multiple_files_several_matches_inverted_flag(self):
         self.assertMultiLineEqual(
-            grep(
-                "a", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                "-v"), ("iliad.txt:Achilles sing, O Goddess! Peleus' son;\n"
-                        "iliad.txt:The noble Chief Achilles from the son\n"
-                        "midsummer-night.txt:If I refuse to wed Demetrius.\n"))
+            grep("a", FILENAMES, "-v"),
+            "iliad.txt:Achilles sing, O Goddess! Peleus' son;\n"
+            "iliad.txt:The noble Chief Achilles from the son\n"
+            "midsummer-night.txt:If I refuse to wed Demetrius.\n"
+        )
 
     def test_multiple_files_one_match_match_entire_lines_flag(self):
         self.assertMultiLineEqual(
             grep("But I beseech your grace that I may know",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-x"),
+                 FILENAMES, "-x"),
             "midsummer-night.txt:But I beseech your grace that I may know\n")
 
     def test_multiple_files_one_match_multiple_flags(self):
         self.assertMultiLineEqual(
             grep("WITH LOSS OF EDEN, TILL ONE GREATER MAN",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-n -i -x"),
+                 FILENAMES, "-n -i -x"),
             "paradise-lost.txt:4:With loss of Eden, till one greater Man\n")
 
     def test_multiple_files_no_matches_various_flags(self):
         self.assertMultiLineEqual(
-            grep("Frodo",
-                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-n -l -x -i"), "")
+            grep("Frodo", FILENAMES, "-n -l -x -i"),
+            ""
+        )
 
 
 if __name__ == '__main__':