| 
				
			 | 
			
			
				@@ -91,7 +91,7 @@ class TestHunk(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				91
			 | 
			
				91
			 | 
			
			
				 class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				92
			 | 
			
				92
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				93
			 | 
			
				93
			 | 
			
			
				     def _init_diff(self): 
			 | 
		
	
		
			
			| 
				94
			 | 
			
				
			 | 
			
			
				-        hunk = cdiff.Hunk([], '@@ -1,2 +1,2 @@\n', (1,2), (1,2)) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				94
			 | 
			
			
				+        hunk = cdiff.Hunk(['hunk header\n'], '@@ -1,2 +1,2 @@\n', (1,2), (1,2)) 
			 | 
		
	
		
			
			| 
				95
			 | 
			
				95
			 | 
			
			
				         hunk.append(('-', 'hella\n')) 
			 | 
		
	
		
			
			| 
				96
			 | 
			
				96
			 | 
			
			
				         hunk.append(('+', 'hello\n')) 
			 | 
		
	
		
			
			| 
				97
			 | 
			
				97
			 | 
			
			
				         hunk.append((' ', 'world\n')) 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -110,7 +110,7 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				110
			 | 
			
				110
			 | 
			
			
				     def test_markup_traditional(self): 
			 | 
		
	
		
			
			| 
				111
			 | 
			
				111
			 | 
			
			
				         diff = self._init_diff() 
			 | 
		
	
		
			
			| 
				112
			 | 
			
				112
			 | 
			
			
				         out = list(diff.markup_traditional()) 
			 | 
		
	
		
			
			| 
				113
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(len(out), 7) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				113
			 | 
			
			
				+        self.assertEqual(len(out), 8) 
			 | 
		
	
		
			
			| 
				114
			 | 
			
				114
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				115
			 | 
			
				115
			 | 
			
			
				         sys.stdout.write('\n') 
			 | 
		
	
		
			
			| 
				116
			 | 
			
				116
			 | 
			
			
				         for markup in out: 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -119,19 +119,20 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				119
			 | 
			
				119
			 | 
			
			
				         self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				120
			 | 
			
				120
			 | 
			
			
				         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				121
			 | 
			
				121
			 | 
			
			
				         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				122
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[3], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				123
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[4], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				122
			 | 
			
			
				+        self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				123
			 | 
			
			
				+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				124
			 | 
			
			
				+        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				124
			 | 
			
				125
			 | 
			
			
				                 '\x1b[1;31m-\x1b[0m\x1b[31mhell\x1b[4m' 
			 | 
		
	
		
			
			| 
				125
			 | 
			
				126
			 | 
			
			
				                 '\x1b[31ma\x1b[0m\x1b[31m\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				126
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				127
			 | 
			
			
				+        self.assertEqual(out[6], 
			 | 
		
	
		
			
			| 
				127
			 | 
			
				128
			 | 
			
			
				                 '\x1b[1;32m+\x1b[0m\x1b[32mhell\x1b[4m' 
			 | 
		
	
		
			
			| 
				128
			 | 
			
				129
			 | 
			
			
				                 '\x1b[32mo\x1b[0m\x1b[32m\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				129
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[6], '\x1b[0m world\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				130
			 | 
			
			
				+        self.assertEqual(out[7], '\x1b[0m world\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				130
			 | 
			
				131
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				131
			 | 
			
				132
			 | 
			
			
				     def test_markup_side_by_side_padded(self): 
			 | 
		
	
		
			
			| 
				132
			 | 
			
				133
			 | 
			
			
				         diff = self._init_diff() 
			 | 
		
	
		
			
			| 
				133
			 | 
			
				134
			 | 
			
			
				         out = list(diff.markup_side_by_side(6)) 
			 | 
		
	
		
			
			| 
				134
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(len(out), 6) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				135
			 | 
			
			
				+        self.assertEqual(len(out), 7) 
			 | 
		
	
		
			
			| 
				135
			 | 
			
				136
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				136
			 | 
			
				137
			 | 
			
			
				         sys.stdout.write('\n') 
			 | 
		
	
		
			
			| 
				137
			 | 
			
				138
			 | 
			
			
				         for markup in out: 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -140,13 +141,14 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				140
			 | 
			
				141
			 | 
			
			
				         self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				141
			 | 
			
				142
			 | 
			
			
				         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				142
			 | 
			
				143
			 | 
			
			
				         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				143
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[3], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				144
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[4], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				144
			 | 
			
			
				+        self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				145
			 | 
			
			
				+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				146
			 | 
			
			
				+        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				145
			 | 
			
				147
			 | 
			
			
				                 '\x1b[33m1\x1b[0m ' 
			 | 
		
	
		
			
			| 
				146
			 | 
			
				148
			 | 
			
			
				                 '\x1b[31mhell\x1b[4m\x1b[31ma\x1b[0m\x1b[31m\x1b[0m  ' 
			 | 
		
	
		
			
			| 
				147
			 | 
			
				149
			 | 
			
			
				                 '\x1b[0m\x1b[33m1\x1b[0m ' 
			 | 
		
	
		
			
			| 
				148
			 | 
			
				150
			 | 
			
			
				                 '\x1b[32mhell\x1b[4m\x1b[32mo\x1b[0m\x1b[32m\x1b[0m\n') 
			 | 
		
	
		
			
			| 
				149
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				151
			 | 
			
			
				+        self.assertEqual(out[6], 
			 | 
		
	
		
			
			| 
				150
			 | 
			
				152
			 | 
			
			
				                 '\x1b[33m2\x1b[0m ' 
			 | 
		
	
		
			
			| 
				151
			 | 
			
				153
			 | 
			
			
				                 '\x1b[0mworld\x1b[0m  ' 
			 | 
		
	
		
			
			| 
				152
			 | 
			
				154
			 | 
			
			
				                 '\x1b[0m\x1b[33m2\x1b[0m ' 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -155,7 +157,7 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				155
			 | 
			
				157
			 | 
			
			
				     def test_markup_side_by_side_off_by_one(self): 
			 | 
		
	
		
			
			| 
				156
			 | 
			
				158
			 | 
			
			
				         diff = self._init_diff() 
			 | 
		
	
		
			
			| 
				157
			 | 
			
				159
			 | 
			
			
				         out = list(diff.markup_side_by_side(5)) 
			 | 
		
	
		
			
			| 
				158
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(len(out), 6) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				160
			 | 
			
			
				+        self.assertEqual(len(out), 7) 
			 | 
		
	
		
			
			| 
				159
			 | 
			
				161
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				160
			 | 
			
				162
			 | 
			
			
				         sys.stdout.write('\n') 
			 | 
		
	
		
			
			| 
				161
			 | 
			
				163
			 | 
			
			
				         for markup in out: 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -164,13 +166,14 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				164
			 | 
			
				166
			 | 
			
			
				         self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				165
			 | 
			
				167
			 | 
			
			
				         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				166
			 | 
			
				168
			 | 
			
			
				         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				167
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[3], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				168
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[4], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				169
			 | 
			
			
				+        self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				170
			 | 
			
			
				+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				171
			 | 
			
			
				+        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				169
			 | 
			
				172
			 | 
			
			
				                 '\x1b[33m1\x1b[0m ' 
			 | 
		
	
		
			
			| 
				170
			 | 
			
				173
			 | 
			
			
				                 '\x1b[31mhell\x1b[4m\x1b[31ma\x1b[0m ' 
			 | 
		
	
		
			
			| 
				171
			 | 
			
				174
			 | 
			
			
				                 '\x1b[0m\x1b[33m1\x1b[0m ' 
			 | 
		
	
		
			
			| 
				172
			 | 
			
				175
			 | 
			
			
				                 '\x1b[32mhell\x1b[4m\x1b[32mo\x1b[0m\n') 
			 | 
		
	
		
			
			| 
				173
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				176
			 | 
			
			
				+        self.assertEqual(out[6], 
			 | 
		
	
		
			
			| 
				174
			 | 
			
				177
			 | 
			
			
				                 '\x1b[33m2\x1b[0m ' 
			 | 
		
	
		
			
			| 
				175
			 | 
			
				178
			 | 
			
			
				                 '\x1b[0mworld\x1b[0m ' 
			 | 
		
	
		
			
			| 
				176
			 | 
			
				179
			 | 
			
			
				                 '\x1b[0m\x1b[33m2\x1b[0m ' 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -179,7 +182,7 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				179
			 | 
			
				182
			 | 
			
			
				     def test_markup_side_by_side_wrapped(self): 
			 | 
		
	
		
			
			| 
				180
			 | 
			
				183
			 | 
			
			
				         diff = self._init_diff() 
			 | 
		
	
		
			
			| 
				181
			 | 
			
				184
			 | 
			
			
				         out = list(diff.markup_side_by_side(4)) 
			 | 
		
	
		
			
			| 
				182
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(len(out), 6) 
			 | 
		
	
		
			
			| 
				
			 | 
			
				185
			 | 
			
			
				+        self.assertEqual(len(out), 7) 
			 | 
		
	
		
			
			| 
				183
			 | 
			
				186
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				184
			 | 
			
				187
			 | 
			
			
				         sys.stdout.write('\n') 
			 | 
		
	
		
			
			| 
				185
			 | 
			
				188
			 | 
			
			
				         for markup in out: 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -188,13 +191,14 @@ class TestDiff(unittest.TestCase): 
			 | 
		
	
		
			
			| 
				188
			 | 
			
				191
			 | 
			
			
				         self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				189
			 | 
			
				192
			 | 
			
			
				         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				190
			 | 
			
				193
			 | 
			
			
				         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				191
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[3], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				192
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[4], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				194
			 | 
			
			
				+        self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				195
			 | 
			
			
				+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m') 
			 | 
		
	
		
			
			| 
				
			 | 
			
				196
			 | 
			
			
				+        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				193
			 | 
			
				197
			 | 
			
			
				                 '\x1b[33m1\x1b[0m ' 
			 | 
		
	
		
			
			| 
				194
			 | 
			
				198
			 | 
			
			
				                 '\x1b[31mhel\x1b[0m\x1b[1;35m>\x1b[0m ' 
			 | 
		
	
		
			
			| 
				195
			 | 
			
				199
			 | 
			
			
				                 '\x1b[0m\x1b[33m1\x1b[0m ' 
			 | 
		
	
		
			
			| 
				196
			 | 
			
				200
			 | 
			
			
				                 '\x1b[32mhel\x1b[0m\x1b[1;35m>\x1b[0m\n') 
			 | 
		
	
		
			
			| 
				197
			 | 
			
				
			 | 
			
			
				-        self.assertEqual(out[5], 
			 | 
		
	
		
			
			| 
				
			 | 
			
				201
			 | 
			
			
				+        self.assertEqual(out[6], 
			 | 
		
	
		
			
			| 
				198
			 | 
			
				202
			 | 
			
			
				                 '\x1b[33m2\x1b[0m ' 
			 | 
		
	
		
			
			| 
				199
			 | 
			
				203
			 | 
			
			
				                 '\x1b[0mwor\x1b[0m\x1b[1;35m>\x1b[0m ' 
			 | 
		
	
		
			
			| 
				200
			 | 
			
				204
			 | 
			
			
				                 '\x1b[0m\x1b[33m2\x1b[0m ' 
			 |