Changeset 53667 in webkit

Timestamp:

Jan 21, 2010 6:35:12 PM (14 years ago)

Author:

Chris Jerdonek

Message:

Create a unit-tested subroutine to parse patch files created
by svn-create-patch.

Reviewed by David Kilzer.

​https://bugs.webkit.org/show_bug.cgi?id=33475

• Scripts/VCSUtils.pm:
  • Added parseDiff().
  • Added parsePatch().

• Scripts/webkitperl/VCSUtils_unittest/parseDiff.pl: Added.
  • Added unit tests for parseDiff().

• Scripts/webkitperl/VCSUtils_unittest/parseDiffHeader.pl:
  • Total number of tests now computed dynamically.

• Scripts/webkitperl/VCSUtils_unittest/parsePatch.pl: Added.
  • Added unit tests for parsePatch().

Location:

trunk/WebKitTools

Files:

• ChangeLog (modified) (1 diff)
• Scripts/VCSUtils.pm (modified) (2 diffs)
• Scripts/webkitperl/VCSUtils_unittest/parseDiff.pl (added)
• Scripts/webkitperl/VCSUtils_unittest/parseDiffHeader.pl (modified) (3 diffs)
• Scripts/webkitperl/VCSUtils_unittest/parsePatch.pl (added)

trunk/WebKitTools/ChangeLog

@@ +1 @@
+2010-01-21  Chris Jerdonek  <cjerdonek@webkit.org>
+
+        Reviewed by David Kilzer.
+
+        Create a unit-tested subroutine to parse patch files created
+        by svn-create-patch.
+
+        https://bugs.webkit.org/show_bug.cgi?id=33475
+
+        * Scripts/VCSUtils.pm:
+          - Added parseDiff().
+          - Added parsePatch().
+
+        * Scripts/webkitperl/VCSUtils_unittest/parseDiff.pl: Added.
+          - Added unit tests for parseDiff().
+
+        * Scripts/webkitperl/VCSUtils_unittest/parseDiffHeader.pl:
+          - Total number of tests now computed dynamically.
+
+        * Scripts/webkitperl/VCSUtils_unittest/parsePatch.pl: Added.
+          - Added unit tests for parsePatch().
+
 2010-01-21  Kevin Ollivier  <kevino@theolliviers.com>
 

trunk/WebKitTools/Scripts/VCSUtils.pm

@@ -63 +63 @@
         &makeFilePathRelative
         &normalizePath
+        &parsePatch
         &pathRelativeToSVNRepositoryRootForPath
         &runPatchCommand
@@ -481 +482 @@
 }
 
+# Parse one diff from a patch file created by svn-create-patch, and
+# advance the file handle so the last line read is the first line
+# of the next header block.
+#
+# This subroutine preserves any leading junk encountered before the header.
+#
+# Args:
+#   $fileHandle: a file handle advanced to the first line of the next
+#                header block. Leading junk is okay.
+#   $line: the line last read from $fileHandle.
+#
+# Returns ($diffHashRef, $lastReadLine):
+#   $diffHashRef:
+#     copiedFromPath: if a file copy, the path from which the file was
+#                     copied. Otherwise, undefined.
+#     indexPath: the path in the "Index:" line.
+#     sourceRevision: the revision number of the source. This is the same
+#                     as the revision number the file was copied from, in
+#                     the case of a file copy.
+#     svnConvertedText: the diff converted to SVN format.
+#   $lastReadLine: the line last read from $fileHandle
+sub parseDiff($$)
+{
+    my ($fileHandle, $line) = @_;
+
+    my $headerStartRegEx = qr#^Index: #; # SVN-style header for the default
+    my $gitHeaderStartRegEx = qr#^diff --git \w/#;
+
+    my $headerHashRef; # Last header found, as returned by parseDiffHeader().
+    my $svnText;
+    while (defined($line)) {
+        if (!$headerHashRef && ($line =~ $gitHeaderStartRegEx)) {
+            # Then assume all diffs in the patch are Git-formatted. This
+            # block was made to be enterable at most once since we assume
+            # all diffs in the patch are formatted the same (SVN or Git).
+            $headerStartRegEx = $gitHeaderStartRegEx;
+        }
+
+        if ($line !~ $headerStartRegEx) {
+            # Then we are in the body of the diff.
+            $svnText .= $line;
+            $line = <$fileHandle>;
+            next;
+        } # Otherwise, we found a diff header.
+
+        if ($headerHashRef) {
+            # Then this is the second diff header of this while loop.
+            last;
+        }
+
+        ($headerHashRef, $line) = parseDiffHeader($fileHandle, $line);
+
+        $svnText .= $headerHashRef->{svnConvertedText};
+    }
+
+    my %diffHashRef;
+    $diffHashRef{copiedFromPath} = $headerHashRef->{copiedFromPath};
+    $diffHashRef{indexPath} = $headerHashRef->{indexPath};
+    $diffHashRef{sourceRevision} = $headerHashRef->{sourceRevision};
+    $diffHashRef{svnConvertedText} = $svnText;
+
+    return (\%diffHashRef, $line);
+}
+
+# Parse a patch file created by svn-create-patch.
+#
+# Args:
+#   $fileHandle: A file handle to the patch file that has not yet been
+#                read from.
+#
+# Returns:
+#   @diffHashRefs: an array of diff hash references. See parseDiff() for
+#                  a description of each $diffHashRef.
+sub parsePatch($)
+{
+    my ($fileHandle) = @_;
+
+    my @diffHashRefs; # return value
+
+    my $line = <$fileHandle>;
+
+    while (defined($line)) { # Otherwise, at EOF.
+
+        my $diffHashRef;
+        ($diffHashRef, $line) = parseDiff($fileHandle, $line);
+
+        push @diffHashRefs, $diffHashRef;
+    }
+
+    return @diffHashRefs;
+}
+
 # If possible, returns a ChangeLog patch equivalent to the given one,
 # but with the newest ChangeLog entry inserted at the top of the

trunk/WebKitTools/Scripts/webkitperl/VCSUtils_unittest/parseDiffHeader.pl

@@ -37 +37 @@
 use VCSUtils;
 
-my @headerKeys = ( # The $headerHashRef keys to check.
+my @diffHeaderHashRefKeys = ( # The $diffHeaderHashRef keys to check.
     "copiedFromPath",
     "indexPath",
@@ -44 +44 @@
 );
 
-# Test parseDiffHeader() for the given $diffTestHashRef.
-sub doDiffTest($)
-{
-    my ($diffTestHashRef) = @_;
-
-    my $fileHandle;
-    open($fileHandle, "<", \$diffTestHashRef->{inputText});
-
-    my $line = <$fileHandle>;
-
-    my ($headerHashRef, $lastReadLine) = VCSUtils::parseDiffHeader($fileHandle, $line);
-
-    my $titleHeader = "parseDiffHeader(): [$diffTestHashRef->{diffName}] ";
-    my $title;
-
-    foreach my $headerKey (@headerKeys) {
-        my $title = "${titleHeader}key=\"$headerKey\"";
-        is($headerHashRef->{$headerKey}, $diffTestHashRef->{$headerKey}, $title);
-    }
-
-    is($lastReadLine, $diffTestHashRef->{lastReadLine}, "${titleHeader}lastReadLine");
-
-    my $nextLine = <$fileHandle>;
-    is($nextLine, $diffTestHashRef->{nextLine}, "${titleHeader}nextLine");
-}
-
-my @diffTests = (
+# The array of test cases.
+my @testCaseHashRefs = (
 {
     # New test
@@ -248 +223 @@
 );
 
-plan(tests => @diffTests * 6); # Multiply by number of assertions per call to doDiffTest().
-
-foreach my $diffTestHashRef (@diffTests) {
-    doDiffTest($diffTestHashRef);
+# Return the arguments for each assertion per test case.
+#
+# In particular, the number of assertions per test case is the length
+# of the return value of this subroutine on a sample input.
+#
+# Returns @assertionArgsArrayRefs:
+#   $assertionArgsArrayRef: A reference to an array of parameters to pass
+#                           to each call to is(). The parameters are--
+#                             $got: The value obtained
+#                             $expected: The expected value
+#                             $testName: The name of the test
+sub testParseDiffHeaderAssertionArgs($)
+{
+    my ($testCaseHashRef) = @_;
+
+    my $fileHandle;
+    open($fileHandle, "<", \$testCaseHashRef->{inputText});
+
+    my $line = <$fileHandle>;
+
+    my ($headerHashRef, $lastReadLine) = VCSUtils::parseDiffHeader($fileHandle, $line);
+
+    my $testNameStart = "parseDiffHeader(): [$testCaseHashRef->{diffName}] ";
+
+    my @assertionArgsArrayRefs; # Return value
+    my @assertionArgs;
+    foreach my $diffHeaderHashRefKey (@diffHeaderHashRefKeys) {
+        my $testName = "${testNameStart}key=\"$diffHeaderHashRefKey\"";
+        @assertionArgs = ($headerHashRef->{$diffHeaderHashRefKey}, $testCaseHashRef->{$diffHeaderHashRefKey}, $testName);
+        push(@assertionArgsArrayRefs, \@assertionArgs);
+    }
+
+    @assertionArgs = ($lastReadLine, $testCaseHashRef->{lastReadLine}, "${testNameStart}lastReadLine");
+    push(@assertionArgsArrayRefs, \@assertionArgs);
+
+    my $nextLine = <$fileHandle>;
+    @assertionArgs = ($nextLine, $testCaseHashRef->{nextLine}, "${testNameStart}nextLine");
+    push(@assertionArgsArrayRefs, \@assertionArgs);
+
+    return @assertionArgsArrayRefs;
 }
+
+# Test parseDiffHeader() for the given test case.
+sub testParseDiffHeader($)
+{
+    my ($testCaseHashRef) = @_;
+
+    my @assertionArgsArrayRefs = testParseDiffHeaderAssertionArgs($testCaseHashRef);
+
+    foreach my $arrayRef (@assertionArgsArrayRefs) {
+        # The parameters are -- is($got, $expected, $testName).
+        is($arrayRef->[0], $arrayRef->[1], $arrayRef->[2]);
+    }
+}
+
+# Count the number of assertions per test case to calculate the total number
+# of Test::More tests. We could have used any test case for the count.
+my $assertionCount = testParseDiffHeaderAssertionArgs($testCaseHashRefs[0]);
+
+plan(tests => @testCaseHashRefs * $assertionCount); # Total number of tests
+
+foreach my $testCaseHashRef (@testCaseHashRefs) {
+    testParseDiffHeader($testCaseHashRef);
+}