public void Malformed_Weird()
{
var empty = new EmptyEnumerable <int>();
var emptyOrdered = new EmptyOrderedEnumerable <int>();
var groupByDefault = new GroupByDefaultEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var groupBySpecific = new GroupBySpecificEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var lookupDefault = new LookupDefaultEnumerable <int, int>();
var lookupSpecific = new LookupSpecificEnumerable <int, int>();
var range = new RangeEnumerable();
var repeat = new RepeatEnumerable <int>();
var reverseRange = new ReverseRangeEnumerable();
var oneItemDefault = new OneItemDefaultEnumerable <int>();
var oneItemSpecific = new OneItemSpecificEnumerable <int>();
var oneItemDefaultOrdered = new OneItemDefaultOrderedEnumerable <int>();
var oneItemSpecificOrdered = new OneItemSpecificOrderedEnumerable <int>();
try { empty.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { emptyOrdered.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.Reverse(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
public void SettingExceptAfterGettingEnumeratorThrows()
{
var enumerable = new RangeEnumerable(Start, Finish);
int first = enumerable.FirstOrDefault();
enumerable.Except = _except;
Assert.Fail("{0}", first);
}
public void SimpleRangeWorks()
{
var enumerable = new RangeEnumerable(Start, Finish);
var expected = new List <int>();
for (int i = Start; i <= Finish; i++)
{
expected.Add(i);
}
expected.AssertIsEquivalent(enumerable.ToList());
}
public static ReverseRangeEnumerable ReverseRange(ref RangeEnumerable source)
{
if (source.IsDefaultValue())
{
throw CommonImplementation.Uninitialized(nameof(source));
}
var newStart = (source.Start + source.InnerCount) - 1;
return(new ReverseRangeEnumerable(Enumerable.ReverseRangeSigil, newStart, source.InnerCount));
}
public void ExceptWorks()
{
var enumerable = new RangeEnumerable(Start, Finish)
{
Except = _except
};
var expected = new List <int>();
for (int i = Start; i <= Finish; i++)
{
if (!_except.Contains(i))
{
expected.Add(i);
}
}
expected.AssertIsEquivalent(enumerable.ToList());
}
protected override int EvaluateFilterMulti(ArrayPtr <float> dest, ArrayPtr <float> src, int numSamples, int numChannels)
{
// when using floating point samples, use a scaler instead of a divider
// because division is much slower operation than multiplying.
double dScaler = 1.0 / _resultDivider;
Debug.Assert(_length != 0);
Debug.Assert(src != null);
Debug.Assert(dest != null);
Debug.Assert(_filterCoeffs != null);
Debug.Assert(numChannels < 16);
var end = numChannels * (numSamples - _length);
Parallel.ForEach(RangeEnumerable.Range(0, end, numChannels), (int j) =>
{
double[] sums = new double[16];
uint c, i;
for (c = 0; c < numChannels; c++)
{
sums[c] = 0;
}
var ptr = src + j;
for (i = 0; i < _length; i++)
{
float coef = _filterCoeffs[i];
for (c = 0; c < numChannels; c++)
{
sums[c] += ptr[0] * coef;
ptr++;
}
}
for (c = 0; c < numChannels; c++)
{
sums[c] *= dScaler;
dest[j + c] = (float)sums[c];
}
});
return(numSamples - _length);
}
public void ChangingExceptAfterSettingDoesNotAffectExceptValues()
{
var enumerable = new RangeEnumerable(Start, Finish)
{
Except = _except
};
var expected = new List <int>();
for (int i = Start; i <= Finish; i++)
{
if (!_except.Contains(i))
{
expected.Add(i);
}
}
_except.Add(23);
expected.AssertIsEquivalent(enumerable.ToList());
}
public void SettingExceptTwiceExceptsBothSets()
{
var enumerable = new RangeEnumerable(Start, Finish)
{
Except = _except
};
var expected = new List <int>();
for (int i = Start; i <= Finish; i++)
{
if (!_except.Contains(i) && !_exceptSecond.Contains(i))
{
expected.Add(i);
}
}
enumerable.Except = _exceptSecond;
expected.AssertIsEquivalent(enumerable.ToList());
_except.AddRange(_exceptSecond);
_except.AssertIsEquivalent(enumerable.Except);
}
protected override int EvaluateFilterMulti(ArrayPtr <short> dest, ArrayPtr <short> src, int numSamples, int numChannels)
{
Debug.Assert(_length != 0);
Debug.Assert(src != null);
Debug.Assert(dest != null);
Debug.Assert(_filterCoeffs != null);
Debug.Assert(numChannels < 16);
var end = numChannels * (numSamples - _length);
Parallel.ForEach(RangeEnumerable.Range(0, end, numChannels), (int j) =>
{
long[] sums = new long[16];
uint c, i;
for (c = 0; c < numChannels; c++)
{
sums[c] = 0;
}
var ptr = src + j;
for (i = 0; i < _length; i++)
{
short coef = _filterCoeffs[i];
for (c = 0; c < numChannels; c++)
{
sums[c] += ptr[0] * coef;
ptr++;
}
}
for (c = 0; c < numChannels; c++)
{
sums[c] >>= _resultDivFactor;
dest[j + c] = (short)sums[c];
}
});
return(numSamples - _length);
}
protected override int EvaluateFilterStereo(ArrayPtr <short> dest, ArrayPtr <short> src, int numSamples)
{
Debug.Assert(_length != 0);
Debug.Assert(src != null);
Debug.Assert(dest != null);
Debug.Assert(_filterCoeffs != null);
int end = 2 * (numSamples - _length);
Parallel.ForEach(RangeEnumerable.Range(0, end, 2), (int j) =>
{
long suml = 0, sumr = 0;
ArrayPtr <short> ptr = src + j;
for (int i = 0; i < _length; i += 4)
{
// loop is unrolled by factor of 4 here for efficiency
suml += ptr[2 * i + 0] * _filterCoeffs[i + 0] +
ptr[2 * i + 2] * _filterCoeffs[i + 1] +
ptr[2 * i + 4] * _filterCoeffs[i + 2] +
ptr[2 * i + 6] * _filterCoeffs[i + 3];
sumr += ptr[2 * i + 1] * _filterCoeffs[i + 0] +
ptr[2 * i + 3] * _filterCoeffs[i + 1] +
ptr[2 * i + 5] * _filterCoeffs[i + 2] +
ptr[2 * i + 7] * _filterCoeffs[i + 3];
}
suml >>= _resultDivFactor;
sumr >>= _resultDivFactor;
// saturate to 16 bit integer limits
suml = (suml < short.MinValue) ? short.MinValue : (suml > short.MaxValue) ? short.MaxValue : suml;
// saturate to 16 bit integer limits
sumr = (sumr < short.MinValue) ? short.MinValue : (sumr > short.MaxValue) ? short.MaxValue : sumr;
dest[j] = (short)suml;
dest[j + 1] = (short)sumr;
});
return(numSamples - _length);
}
protected override int EvaluateFilterStereo(ArrayPtr <float> dest, ArrayPtr <float> src, int numSamples)
{
double dScaler = 1.0 / _resultDivider;
Debug.Assert(_length != 0);
Debug.Assert(src != null);
Debug.Assert(dest != null);
Debug.Assert(_filterCoeffs != null);
int end = 2 * (numSamples - _length);
Parallel.ForEach(RangeEnumerable.Range(0, end, 2), (int j) =>
{
double sumr = 0, suml = 0;
ArrayPtr <float> ptr = src + j;
for (int i = 0; i < _length; i += 4)
{
// loop is unrolled by factor of 4 here for efficiency
suml += ptr[2 * i + 0] * _filterCoeffs[i + 0] +
ptr[2 * i + 2] * _filterCoeffs[i + 1] +
ptr[2 * i + 4] * _filterCoeffs[i + 2] +
ptr[2 * i + 6] * _filterCoeffs[i + 3];
sumr += ptr[2 * i + 1] * _filterCoeffs[i + 0] +
ptr[2 * i + 3] * _filterCoeffs[i + 1] +
ptr[2 * i + 5] * _filterCoeffs[i + 2] +
ptr[2 * i + 7] * _filterCoeffs[i + 3];
}
suml *= dScaler;
sumr *= dScaler;
dest[j] = (float)suml;
dest[j + 1] = (float)sumr;
});
return(numSamples - _length);
}
public override async Task <byte[]> DecodeFrame(Stream dataSource, uint width, uint height)
{
var compressedData = new byte[GetDataSize(width, height, BlockSize)];
var readCount = await dataSource.ReadAsync(compressedData, 0, compressedData.Length);
if (readCount != compressedData.Length)
{
throw new IOException("Not enough data!");
}
var scanlineSize = width * BytesPerPixel;
var frameData = new byte[scanlineSize * height];
Parallel.ForEach(RangeEnumerable.Range(0, (int)width, 4), new ParallelOptions(), y =>
{
var colors = new RGBAColor[4];
var offset = (int)((y / 4) * (width / 4) * BlockSize);
for (var x = 0; x < width; x += 4, offset += BlockSize)
{
var color0 = BitConverter.ToUInt16(compressedData, offset + 8);
var color1 = BitConverter.ToUInt16(compressedData, offset + 10);
var bitmask = BitConverter.ToUInt32(compressedData, offset + 12);
colors[0] = GetDXTColor(color0);
colors[1] = GetDXTColor(color1);
colors[2].b = (byte)((2 * colors[0].b + colors[1].b + 1) / 3);
colors[2].g = (byte)((2 * colors[0].g + colors[1].g + 1) / 3);
colors[2].r = (byte)((2 * colors[0].r + colors[1].r + 1) / 3);
colors[3].b = (byte)((colors[0].b + 2 * colors[1].b + 1) / 3);
colors[3].g = (byte)((colors[0].g + 2 * colors[1].g + 1) / 3);
colors[3].r = (byte)((colors[0].r + 2 * colors[1].r + 1) / 3);
var k = 0;
for (var j = 0; j < 4; j++)
{
for (var i = 0; i < 4; i++, k++)
{
var select = (bitmask & (0x03 << k * 2)) >> k * 2;
var current = colors[select];
if (((x + i) >= width) || ((y + j) >= height))
{
continue;
}
var dataOffset = (y + j) * scanlineSize + (x + i) * BytesPerPixel;
frameData[dataOffset + 0] = current.b;
frameData[dataOffset + 1] = current.g;
frameData[dataOffset + 2] = current.r;
}
}
for (var j = 0; j < 4; j++)
{
var word = compressedData[offset + 2 * j] + 256 * compressedData[offset + 2 * j + 1];
for (var i = 0; i < 4; i++)
{
if (((x + i) < width) && ((y + j) < height))
{
var dataOffset = (y + j) * scanlineSize + (x + i) * BytesPerPixel + 3;
frameData[dataOffset] = (byte)(word & 0x0F);
frameData[dataOffset] = (byte)(frameData[dataOffset] | (frameData[dataOffset] << 4));
}
word >>= 4;
}
}
}
});
return(frameData);
}
public void GlobalSetup() => source = new RangeEnumerable(Count);
public void Malformed_Weird()
{
var groupByDefault = new GroupByDefaultEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var groupBySpecific = new GroupBySpecificEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var lookupDefault = new LookupDefaultEnumerable <int, int>();
var lookupSpecific = new LookupSpecificEnumerable <int, int>();
var range = new RangeEnumerable();
var repeat = new RepeatEnumerable <int>();
var reverseRange = new ReverseRangeEnumerable();
var oneItemDefault = new OneItemDefaultEnumerable <int>();
var oneItemSpecific = new OneItemSpecificEnumerable <int>();
var oneItemDefaultOrdered = new OneItemDefaultOrderedEnumerable <int>();
var oneItemSpecificOrdered = new OneItemSpecificOrderedEnumerable <int>();
// groupByDefault
{
try { groupByDefault.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// groupBySpecific
{
try { groupBySpecific.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupDefault
{
try { lookupDefault.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupSpecific
{
try { lookupSpecific.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// range
{
try { range.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// repeat
{
try { repeat.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// reverseRange
{
try { reverseRange.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefault
{
try { oneItemDefault.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecific
{
try { oneItemSpecific.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefaultOrdered
{
try { oneItemDefaultOrdered.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecificOrdered
{
try { oneItemSpecificOrdered.Take(0); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.TakeWhile(x => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.TakeWhile((x, ix) => true); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
}
public void Malformed_Weird()
{
var empty = new EmptyEnumerable <int>();
var emptyOrdered = new EmptyOrderedEnumerable <int>();
var groupByDefault = new GroupByDefaultEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var groupBySpecific = new GroupBySpecificEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var lookupDefault = new LookupDefaultEnumerable <int, int>();
var lookupSpecific = new LookupSpecificEnumerable <int, int>();
var range = new RangeEnumerable();
var repeat = new RepeatEnumerable <int>();
var reverseRange = new ReverseRangeEnumerable();
var oneItemDefault = new OneItemDefaultEnumerable <int>();
var oneItemSpecific = new OneItemSpecificEnumerable <int>();
var oneItemDefaultOrdered = new OneItemDefaultOrderedEnumerable <int>();
var oneItemSpecificOrdered = new OneItemSpecificOrderedEnumerable <int>();
// empty
{
try { empty.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { empty.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// emptyOrdered
{
try { emptyOrdered.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { emptyOrdered.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// groupByDefault
{
try { groupByDefault.Contains(new GroupingEnumerable <int, int>()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.Contains(new GroupingEnumerable <int, int>(), null); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// groupBySpecific
{
try { groupBySpecific.Contains(new GroupingEnumerable <int, int>()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.Contains(new GroupingEnumerable <int, int>(), null); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupDefault
{
try { lookupDefault.Contains(new GroupingEnumerable <int, int>()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.Contains(new GroupingEnumerable <int, int>(), null); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupSpecific
{
try { lookupSpecific.Contains(new GroupingEnumerable <int, int>()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.Contains(new GroupingEnumerable <int, int>(), null); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// range
{
try { range.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// repeat
{
try { repeat.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// reverseRange
{
try { reverseRange.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefault
{
try { oneItemDefault.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecific
{
try { oneItemSpecific.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefaultOrdered
{
try { oneItemDefaultOrdered.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecificOrdered
{
try { oneItemSpecificOrdered.Contains(1); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.Contains(1, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
}
public override async Task <byte[]> DecodeFrame(Stream dataSource, uint width, uint height)
{
var compressedData = new byte[GetDataSize(width, height, BlockSize)];
var readCount = await dataSource.ReadAsync(compressedData, 0, compressedData.Length);
if (readCount != compressedData.Length)
{
throw new IOException("Not enough data!");
}
var scanlineSize = width * BytesPerPixel;
var frameData = new byte[scanlineSize * height];
Parallel.ForEach(RangeEnumerable.Range(0, (int)height, 4), new ParallelOptions(), y =>
{
var colors = new RGBAColor[4];
var alphas = new byte[8];
var offset = (int)((y / 4) * (width / 4) * BlockSize);
for (var x = 0; x < width; x += 4, offset += BlockSize)
{
alphas[0] = compressedData[offset];
alphas[1] = compressedData[offset + 1];
var alphamaskIndex = offset + 2;
colors[0] = GetDXTColor(BitConverter.ToUInt16(compressedData, offset + 8));
colors[1] = GetDXTColor(BitConverter.ToUInt16(compressedData, offset + 10));
var bitmask = BitConverter.ToUInt32(compressedData, offset + 12);
colors[2].b = (byte)((2 * colors[0].b + colors[1].b + 1) / 3);
colors[2].g = (byte)((2 * colors[0].g + colors[1].g + 1) / 3);
colors[2].r = (byte)((2 * colors[0].r + colors[1].r + 1) / 3);
colors[3].b = (byte)((colors[0].b + 2 * colors[1].b + 1) / 3);
colors[3].g = (byte)((colors[0].g + 2 * colors[1].g + 1) / 3);
colors[3].r = (byte)((colors[0].r + 2 * colors[1].r + 1) / 3);
var k = 0;
for (var j = 0; j < 4; j++)
{
for (var i = 0; i < 4; i++, k++)
{
var select = (bitmask & (0x03 << k * 2)) >> k * 2;
var col = colors[select];
// only put pixels out < width or height
if (((x + i) >= width) || ((y + j) >= height))
{
continue;
}
var dataOffset = (y + j) * scanlineSize + (x + i) * BytesPerPixel;
frameData[dataOffset + 0] = col.b;
frameData[dataOffset + 1] = col.g;
frameData[dataOffset + 2] = col.r;
}
}
// 8-alpha or 6-alpha block?
if (alphas[0] > alphas[1])
{
// 8-alpha block: derive the other six alphas.
// Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (byte)((6 * alphas[0] + 1 * alphas[1] + 3) / 7); // bit code 010
alphas[3] = (byte)((5 * alphas[0] + 2 * alphas[1] + 3) / 7); // bit code 011
alphas[4] = (byte)((4 * alphas[0] + 3 * alphas[1] + 3) / 7); // bit code 100
alphas[5] = (byte)((3 * alphas[0] + 4 * alphas[1] + 3) / 7); // bit code 101
alphas[6] = (byte)((2 * alphas[0] + 5 * alphas[1] + 3) / 7); // bit code 110
alphas[7] = (byte)((1 * alphas[0] + 6 * alphas[1] + 3) / 7); // bit code 111
}
else
{
// 6-alpha block.
// Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (byte)((4 * alphas[0] + 1 * alphas[1] + 2) / 5); // Bit code 010
alphas[3] = (byte)((3 * alphas[0] + 2 * alphas[1] + 2) / 5); // Bit code 011
alphas[4] = (byte)((2 * alphas[0] + 3 * alphas[1] + 2) / 5); // Bit code 100
alphas[5] = (byte)((1 * alphas[0] + 4 * alphas[1] + 2) / 5); // Bit code 101
alphas[6] = 0x00; // Bit code 110
alphas[7] = 0xFF; // Bit code 111
}
// Note: Have to separate the next two loops,
// it operates on a 6-byte system.
// First three bytes
//bits = *((ILint*)alphamask);
var bits = (compressedData[alphamaskIndex]) | (compressedData[alphamaskIndex + 1] << 8) |
(compressedData[alphamaskIndex + 2] << 16);
for (var j = 0; j < 2; j++)
{
for (var i = 0; i < 4; i++)
{
// only put pixels out < width or height
if (((x + i) < width) && ((y + j) < height))
{
var dataOffset = (y + j) * scanlineSize + (x + i) * BytesPerPixel + 3;
frameData[dataOffset] = alphas[bits & 0x07];
}
bits >>= 3;
}
}
// Last three bytes
//bits = *((ILint*)&alphamask[3]);
bits = (compressedData[alphamaskIndex + 3]) | (compressedData[alphamaskIndex + 4] << 8) |
(compressedData[alphamaskIndex + 5] << 16);
for (var j = 2; j < 4; j++)
{
for (var i = 0; i < 4; i++)
{
// only put pixels out < width or height
if (((x + i) < width) && ((y + j) < height))
{
var dataOffset = (y + j) * scanlineSize + (x + i) * BytesPerPixel + 3;
frameData[dataOffset] = alphas[bits & 0x07];
}
bits >>= 3;
}
}
}
});
return(frameData);
}
public void Malformed_Weird()
{
var groupByDefault = new GroupByDefaultEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var groupBySpecific = new GroupBySpecificEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var lookupDefault = new LookupDefaultEnumerable <int, int>();
var lookupSpecific = new LookupSpecificEnumerable <int, int>();
var range = new RangeEnumerable();
var repeat = new RepeatEnumerable <int>();
var reverseRange = new ReverseRangeEnumerable();
var oneItemDefault = new OneItemDefaultEnumerable <int>();
var oneItemSpecific = new OneItemSpecificEnumerable <int>();
var oneItemDefaultOrdered = new OneItemDefaultOrderedEnumerable <int>();
var oneItemSpecificOrdered = new OneItemSpecificOrderedEnumerable <int>();
// groupByDefault
{
try { groupByDefault.OrderBy(x => x.Key); Assert.Fail(); }catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.OrderBy(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.OrderByDescending(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupByDefault.OrderByDescending(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// groupBySpecific
{
try { groupBySpecific.OrderBy(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.OrderBy(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.OrderByDescending(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { groupBySpecific.OrderByDescending(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupDefault
{
try { lookupDefault.OrderBy(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.OrderBy(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.OrderByDescending(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupDefault.OrderByDescending(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupSpecific
{
try { lookupSpecific.OrderBy(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.OrderBy(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.OrderByDescending(x => x.Key); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { lookupSpecific.OrderByDescending(x => x.Key, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// range
{
try { range.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { range.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// repeat
{
try { repeat.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { repeat.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// reverseRange
{
try { reverseRange.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { reverseRange.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefault
{
try { oneItemDefault.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefault.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecific
{
try { oneItemSpecific.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecific.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefaultOrdered
{
try { oneItemDefaultOrdered.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemDefaultOrdered.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecificOrdered
{
try { oneItemSpecificOrdered.OrderBy(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.OrderBy(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.OrderByDescending(x => x); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
try { oneItemSpecificOrdered.OrderByDescending(x => x, new _IntComparer()); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
}
public void Malformed_Weird()
{
var empty = new EmptyEnumerable <int>();
var emptyOrdered = new EmptyOrderedEnumerable <int>();
var groupByDefault = new GroupByDefaultEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var groupBySpecific = new GroupBySpecificEnumerable <int, int, int, EmptyEnumerable <int>, EmptyEnumerator <int> >();
var lookupDefault = new LookupDefaultEnumerable <int, int>();
var lookupSpecific = new LookupSpecificEnumerable <int, int>();
var range = new RangeEnumerable();
var repeat = new RepeatEnumerable <int>();
var reverseRange = new ReverseRangeEnumerable();
var oneItemDefault = new OneItemDefaultEnumerable <int>();
var oneItemSpecific = new OneItemSpecificEnumerable <int>();
var oneItemDefaultOrdered = new OneItemDefaultOrderedEnumerable <int>();
var oneItemSpecificOrdered = new OneItemSpecificOrderedEnumerable <int>();
// empty
{
var boxed = (BoxedEnumerable <int>)empty;
try { boxed.ToList(); Assert.Fail(); }catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// emptyOrdered
{
var boxed = (BoxedEnumerable <int>)emptyOrdered;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// groupByDefault
{
var boxed = (BoxedEnumerable <GroupingEnumerable <int, int> >)groupByDefault;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// groupBySpecific
{
var boxed = (BoxedEnumerable <GroupingEnumerable <int, int> >)groupBySpecific;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupDefault
{
var boxed = (BoxedEnumerable <GroupingEnumerable <int, int> >)lookupDefault;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// lookupDefault
{
var boxed = (BoxedEnumerable <GroupingEnumerable <int, int> >)lookupSpecific;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// range
{
var boxed = (BoxedEnumerable <int>)range;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// repeat
{
var boxed = (BoxedEnumerable <int>)repeat;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// reverseRange
{
var boxed = (BoxedEnumerable <int>)reverseRange;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefault
{
var boxed = (BoxedEnumerable <int>)oneItemDefault;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecific
{
var boxed = (BoxedEnumerable <int>)oneItemSpecific;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemDefaultOrdered
{
var boxed = (BoxedEnumerable <int>)oneItemDefaultOrdered;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
// oneItemSpecificOrdered
{
var boxed = (BoxedEnumerable <int>)oneItemSpecificOrdered;
try { boxed.ToList(); Assert.Fail(); } catch (ArgumentException exc) { Assert.AreEqual("source", exc.ParamName); }
}
}
