Summary

Class:ICSharpCode.SharpZipLib.Checksum.Crc32
Assembly:ICSharpCode.SharpZipLib
File(s):C:\Users\Neil\Documents\Visual Studio 2015\Projects\icsharpcode\SZL_master\ICSharpCode.SharpZipLib\Checksum\Crc32.cs
Covered lines:82
Uncovered lines:0
Coverable lines:82
Total lines:189
Line coverage:100%
Branch coverage:100%

Metrics

MethodCyclomatic ComplexitySequence CoverageBranch Coverage
ComputeCrc32(...)1100100
.ctor()1100100
Reset()1100100
Update(...)1100100
Update(...)2100100
Update(...)7100100
.cctor()1100100

File(s)

C:\Users\Neil\Documents\Visual Studio 2015\Projects\icsharpcode\SZL_master\ICSharpCode.SharpZipLib\Checksum\Crc32.cs

#LineLine coverage
 1using System;
 2
 3namespace ICSharpCode.SharpZipLib.Checksum
 4{
 5  /// <summary>
 6  /// CRC-32 with reversed data and unreversed output
 7  /// </summary>
 8  /// <remarks>
 9  /// Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
 10  /// x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x^1+x^0.
 11  ///
 12  /// Polynomials over GF(2) are represented in binary, one bit per coefficient,
 13  /// with the lowest powers in the most significant bit.  Then adding polynomials
 14  /// is just exclusive-or, and multiplying a polynomial by x is a right shift by
 15  /// one.  If we call the above polynomial p, and represent a byte as the
 16  /// polynomial q, also with the lowest power in the most significant bit (so the
 17  /// byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
 18  /// where a mod b means the remainder after dividing a by b.
 19  ///
 20  /// This calculation is done using the shift-register method of multiplying and
 21  /// taking the remainder.  The register is initialized to zero, and for each
 22  /// incoming bit, x^32 is added mod p to the register if the bit is a one (where
 23  /// x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
 24  /// x (which is shifting right by one and adding x^32 mod p if the bit shifted
 25  /// out is a one).  We start with the highest power (least significant bit) of
 26  /// q and repeat for all eight bits of q.
 27  ///
 28  /// The table is simply the CRC of all possible eight bit values.  This is all
 29  /// the information needed to generate CRC's on data a byte at a time for all
 30  /// combinations of CRC register values and incoming bytes.
 31  /// </remarks>
 32  public sealed class Crc32 : IChecksum
 33  {
 34    #region Instance Fields
 135    readonly static uint crcInit = 0xFFFFFFFF;
 136    readonly static uint crcXor = 0xFFFFFFFF;
 37
 138    readonly static uint[] crcTable = {
 139      0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
 140      0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
 141      0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
 142      0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
 143      0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
 144      0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
 145      0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
 146      0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
 147      0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
 148      0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
 149      0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
 150      0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
 151      0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
 152      0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
 153      0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
 154      0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
 155      0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
 156      0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
 157      0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
 158      0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
 159      0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
 160      0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
 161      0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
 162      0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
 163      0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
 164      0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
 165      0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
 166      0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
 167      0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
 168      0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
 169      0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
 170      0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
 171      0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
 172      0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
 173      0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
 174      0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
 175      0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
 176      0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
 177      0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
 178      0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
 179      0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
 180      0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
 181      0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
 182      0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
 183      0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
 184      0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
 185      0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
 186      0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
 187      0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
 188      0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
 189      0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
 190      0x2D02EF8D
 191    };
 92
 93    /// <summary>
 94    /// The CRC data checksum so far.
 95    /// </summary>
 96    uint checkValue;
 97    #endregion
 98
 99    internal static uint ComputeCrc32(uint oldCrc, byte bval)
 100    {
 4516642101      return (uint)(Crc32.crcTable[(oldCrc ^ bval) & 0xFF] ^ (oldCrc >> 8));
 102    }
 103
 104    /// <summary>
 105    /// Initialise a default instance of <see cref="Crc32"></see>
 106    /// </summary>
 66290107    public Crc32()
 108    {
 66290109      Reset();
 66290110    }
 111
 112    /// <summary>
 113    /// Resets the CRC data checksum as if no update was ever called.
 114    /// </summary>
 115    public void Reset()
 116    {
 66451117      checkValue = crcInit;
 66451118    }
 119
 120    /// <summary>
 121    /// Returns the CRC data checksum computed so far.
 122    /// </summary>
 123    /// <remarks>Reversed Out = false</remarks>
 124    public long Value {
 125      get {
 66251126        return (long)(checkValue ^ crcXor);
 127      }
 128    }
 129
 130    /// <summary>
 131    /// Updates the checksum with the int bval.
 132    /// </summary>
 133    /// <param name = "bval">
 134    /// the byte is taken as the lower 8 bits of bval
 135    /// </param>
 136    /// <remarks>Reversed Data = true</remarks>
 137    public void Update(int bval)
 138    {
 4528259139      checkValue = unchecked(crcTable[(checkValue ^ bval) & 0xFF] ^ (checkValue >> 8));
 4528259140    }
 141
 142    /// <summary>
 143    /// Updates the CRC data checksum with the bytes taken from
 144    /// a block of data.
 145    /// </summary>
 146    /// <param name="buffer">Contains the data to update the CRC with.</param>
 147    public void Update(byte[] buffer)
 148    {
 2149       if (buffer == null) {
 1150        throw new ArgumentNullException(nameof(buffer));
 151      }
 152
 1153      Update(buffer, 0, buffer.Length);
 1154    }
 155
 156    /// <summary>
 157    /// Update CRC data checksum based on a portion of a block of data
 158    /// </summary>
 159    /// <param name = "buffer">Contains the data to update the CRC with.</param>
 160    /// <param name = "offset">The offset into the buffer where the data starts</param>
 161    /// <param name = "count">The number of data bytes to update the CRC with.</param>
 162    public void Update(byte[] buffer, int offset, int count)
 163    {
 5155164       if (buffer == null) {
 1165        throw new ArgumentNullException(nameof(buffer));
 166      }
 167
 5154168       if (offset < 0) {
 1169        throw new ArgumentOutOfRangeException(nameof(offset), "cannot be less than zero");
 170      }
 171
 5153172       if (offset >= buffer.Length) {
 2173        throw new ArgumentOutOfRangeException(nameof(offset), "not a valid index into buffer");
 174      }
 175
 5151176       if (count < 0) {
 1177        throw new ArgumentOutOfRangeException(nameof(count), "cannot be less than zero");
 178      }
 179
 5150180       if (offset + count > buffer.Length) {
 1181        throw new ArgumentOutOfRangeException(nameof(count), "exceeds buffer size");
 182      }
 183
 9066816184       for (int i = 0; i < count; ++i) {
 4528259185        Update(buffer[offset++]);
 186      }
 5149187    }
 188  }
 189}