From 607ef28aadb281ab61a2be493a637126e967a388 Mon Sep 17 00:00:00 2001
From: wuestholz <unknown>
Date: Thu, 29 May 2014 21:41:00 +0200
Subject: Set up the same test infrastructure as in Boogie.

---
 Test/pydiff.py | 100 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 Test/pydiff.py

(limited to 'Test/pydiff.py')

diff --git a/Test/pydiff.py b/Test/pydiff.py
new file mode 100644
index 00000000..407fe251
--- /dev/null
+++ b/Test/pydiff.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+"""
+Simple driver around python's difflib that implements a basic ``diff`` like
+tool. This exists to provide a simple ``diff`` like tool that will run on
+Windows where only the ``fc`` tool is available.
+"""
+import argparse
+import difflib
+import os
+import sys
+
+
+def main(args):
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
+                                     description=__doc__
+                                    )
+    # Open in binary mode so python doesn't try and do
+    # universal line endings for us.
+    parser.add_argument('from-file',
+                        type=argparse.FileType('rb'),
+                       )
+    parser.add_argument('to-file',
+                        type=argparse.FileType('rb'),
+                       )
+    parser.add_argument('-U','--unified=',
+                        type=int,
+                        default=3,
+                        help='Number of context lines to show. '
+                             'Default %(default)s'
+                       )
+    parser.add_argument('--strip-trailing-cr',
+                        action='store_true',
+                        help='strip trailing carriage return when comparing'
+                       )
+    parser.add_argument('--ignore-all-space','-w',
+                        action='store_true',
+                        help='Ignore all whitespace characters when comparing'
+                       )
+
+    parsedArgs = parser.parse_args(args)
+    fromFile, fromFileName = preProcess(getattr(parsedArgs,'from-file'),
+                                        parsedArgs.strip_trailing_cr,
+                                        parsedArgs.ignore_all_space
+                                       )
+    toFile, toFileName = preProcess(getattr(parsedArgs,'to-file'),
+                                    parsedArgs.strip_trailing_cr,
+                                    parsedArgs.ignore_all_space
+                                   )
+
+    result = difflib.unified_diff(fromFile,
+                                  toFile,
+                                  fromFileName,
+                                  toFileName,
+                                  n=getattr(parsedArgs,'unified='),
+                                 )
+    # Force lazy computation to happen now
+    result = list(result)
+
+    if len(result) == 0:
+        # Files are identical
+        return 0
+    else:
+        for l in result:
+            sys.stdout.write(l)
+        return 1
+
+def preProcess(openFile, stripTrailingCR=False, ignoreAllSpace=False):
+    """
+    Helper function to read lines in a file and do any necessary
+    pre-processing
+    """
+    original = openFile.readlines()
+
+    # Translation table deletes white space characters Note we don't remove
+    # newline characters because this will create a mess when outputting the
+    # diff. Is this the right behaviour?
+    deleteChars=' \t'
+    translationTable = str.maketrans('','', deleteChars)
+
+    copy = [ ]
+    for line in original:
+        newLine = str(line.decode())
+
+        if stripTrailingCR:
+            if newLine[-2:] == '\r\n' or newLine[-2:] == '\n\r':
+                newLine = newLine[:-2] + '\n'
+
+        if ignoreAllSpace:
+            newLine = newLine.translate(translationTable)
+
+        copy.append(newLine)
+
+    return (copy, openFile.name)
+
+def getFileName(openFile):
+    return openFile.name
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))
+
-- 
cgit v1.2.3